ar_cache 1.0.0

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2020 OuYangJinTing
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,166 @@
+# ArCache
+
+`ArCache` is an modern cacheing library for `ActiveRecord` inspired by cache-money and second_level_cache.  
+It works automatically by copied `ActiveRecord` related code.
+When executing standard `ActiveRecord` query, it will first query the cache, and if there is none in the cache,
+then query the database and write the result to the cache.
+
+> **! WARNING: Please read these [information](#Warning) before using `ArCache`.**
+
+## Features
+
+- `Low impact`: If your code strictly comply with the activerecord style, you don’t need to modify any code.([see more details](#Warning))
+- `Read cache`: Automatically intercept ActiveRecord queries, then try to fetch data from cache.
+- `Write cache`: If the query is cacheable and the cached data is not exists, it will be automatically written to the cache after the query.
+- `Expire cache`: Automatically expire cache after updated/modified data.
+- `Iterative cache`: The cache version will be updated after table fields, `ArCache` switch or `ArCache` coder changed.
+- `Shared cache`: The cache is not only used with ActiveRecord, you can easily use it in other places.([see examples](examples))
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'ar_cache'
+```
+
+And then execute:
+
+```shell
+bundle install
+```
+
+## Post Installation
+
+If is an `rails` application:
+
+```shell
+rails generate ar_cache:install
+```
+
+Otherwise copy [configuration](lib/generators/ar_cache/templates/configuration.rb) and [migration](lib/generators/ar_cache/templates/migrate/create_ar_cache_records.rb.tt) files to your application.
+
+After that review the migrations then migrate:
+
+```shell
+rake db:migrate
+```
+
+## Usage
+
+`ArCache` works automatically, so you don’t need to care about how to use the cache, just need to know how to skip and delete the cache.
+
+Skip cache:
+
+- `ActiveRecord::Persistence#reload`, eg:
+
+```ruby
+User.find(1).reload
+```
+
+- `ActiveRecord::Relation#skip_ar_cache`, eg:
+
+```ruby
+User.skip_ar_cache.find(1)
+User.where(id: [1, 2]).skip_ar_cache.load
+```
+
+Delete cache:
+
+- `ArCache::Table`, eg:
+
+```ruby
+User.ar_cache_table.delete(id...)
+User.first.ar_cache_table.delete(id...)
+```
+
+## Configuration
+
+For configuration information, please see [configuration](lib/generators/ar_cache/templates/configuration.rb) file.
+
+## Cacheable query
+
+If all the following conditions are met, ArCache will try to read the cache:
+
+- Use hash as `#where` parameter.
+- Query condition contains unique index.
+- Condition of unique index is only one array or no array.
+- No call `#select` or select value is table column.
+- No call `#order` or order value is table column and only one.
+- No call `#limit` or value of the unique index isn't array.
+- No call `#joins`.
+- No call `#left_joins`.
+- No call `#skip_query_cache!`.
+- No call `#skip_ar_cache`.
+- No call `#explain`.
+- No call `#from`.
+- No call `#group`.
+- No call `value`.
+- ...
+
+**Cacheable example:**
+
+```ruby
+User.find(1) # primary key cache
+User.where(id: [1, 2]) # array query cache
+User.where(email: 'foobar@gmail.com') # sigle-column unique index cache
+User.where(name: 'foobar', status: :active) # multi-column unique index cache
+User.includes(:account).where(id: [1, 2]) # association cache
+User.first.account # association model cache
+```
+
+## Cache iteration
+
+The following cases will cause cache iteration：
+
+- Table field changes.
+- Open `ArCache` or close `ArCache`.
+- `ActiveRecord` update/delete condition does not hit the unique index.
+- `ActiveRecord` update/delete join other tables.
+
+**Notice: After iteration, all existing caches of the table will be expired!**
+
+## How it works(Work in progress)
+
+`ArCache` works based on the unique index of the table.
+
+## Warning
+
+- Prohibit the use of `#execute` update/delete operations!
+- Prohibit use `ActiveRecord` other underlying methods to directly update/delete data! (You is a fake activerecord user if this code appears)
+- Prohibit skip `ActiveRecord` directly update/delete data!
+
+## Alternatives
+
+There are some other gems implementations for `ActiveRecord` cache such as:
+
+- [identity_cache](https://github.com/Shopify/identity_cache)
+- [second_level_cache](https://github.com/hooopo/second_level_cache)
+- [cache-money](https://github.com/ngmoco/cache-money)
+
+However, `ArCache` has some differences:
+
+- It don’t depend with `ActiveRecord` callbacks, so don’t need to deal with dirty cache manually.
+- It cache real database data, so can use it's cache at other places.
+- It can automatically handle cache iteration, so don't need to update cache version manually.
+- It proxy standard ActiveRecord query, so don't need to modify the code and remember the additional api.
+- The new data need to perform a query before the cache will take effect.
+- The cache will not be updated after the data is updated, but the cache will be expired directly.
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake test` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and the created tag, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at <https://github.com/OuYangJinTing/ar_cache>. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [code of conduct](https://github.com/OuYangJinTing/ar_cache/blob/master/CODE_OF_CONDUCT.md).
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).
+
+## Code of Conduct
+
+Everyone interacting in the `ArCache` project's codebases, issue trackers, chat rooms and mailing lists is expected to follow the [code of conduct](https://github.com/OuYangJinTing/ar_cache/blob/master/CODE_OF_CONDUCT.md).

data/Rakefile

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require 'bundler/gem_tasks'
+require 'rake/testtask'
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'test'
+  t.libs << 'lib'
+  t.test_files = FileList['test/**/*_test.rb']
+  t.verbose = true
+  t.warning = true
+  t.options = '--warnings --color'
+end
+
+Rake::TestTask.new(:bench) do |t|
+  t.libs << 'test'
+  t.libs << 'lib'
+  t.test_files = FileList['test/**/*_benchmark.rb']
+  t.verbose = true
+  t.warning = true
+  t.options = '--verbose --warnings --color'
+end
+
+require 'rubocop/rake_task'
+
+RuboCop::RakeTask.new
+
+task default: %i[test rubocop]

data/ar_cache.gemspec

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require_relative 'lib/ar_cache/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'ar_cache'
+  spec.version       = ArCache::VERSION
+  spec.authors       = ['OuYangJinTing']
+  spec.email         = ['2729877005qq@gmail.com']
+
+  spec.summary       = 'An modern cacheing library for ActiveRecord inspired by cache-money and second_level_cache.'
+  spec.description   = spec.summary
+  spec.homepage      = 'https://github.com/OuYangJinTing/ar_cache'
+  spec.license       = 'MIT'
+  spec.required_ruby_version = Gem::Requirement.new('>= 3.0.0')
+
+  spec.metadata['homepage_uri'] = spec.homepage
+  spec.metadata['source_code_uri'] = 'https://github.com/OuYangJinTing/ar_cache.git'
+  spec.metadata['changelog_uri'] = 'https://github.com/OuYangJinTing/ar_cache/CHANGELOG.md'
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  spec.files = Dir.chdir(File.expand_path(__dir__)) do
+    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{\A(?:test|spec|features)/}) }
+  end
+  spec.bindir        = 'exe'
+  spec.executables   = spec.files.grep(%r{\Aexe/}) { |f| File.basename(f) }
+  spec.require_paths = ['lib']
+
+  spec.add_runtime_dependency 'activerecord', '>= 6.1', '< 7'
+
+  # For more information and examples about making a new gem, checkout our
+  # guide at: https://bundler.io/guides/creating_gem.html
+end

data/bin/activerecord-test

@@ -0,0 +1,20 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+if [ ! -d 'tmp/rails/' ]; then
+  git clone --branch=6-1-ar_cache-test https://github.com/OuYangJinTing/rails.git tmp/rails && cd tmp/rails
+else
+  cd tmp/rails && git pull origin 6-1-ar_cache-test
+fi
+
+BUNDLE_GEMFILE=./Gemfile
+bundle install
+
+cd activerecord
+BUNDLE_GEMFILE=../Gemfile
+# bundle exec rake rebuild_mysql_databases
+bundle exec rake rebuild_postgresql_databases
+bundle exec rake test:sqlite3
+bundle exec rake test:postgresql

data/bin/console

@@ -0,0 +1,15 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require 'bundler/setup'
+require 'ar_cache'
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require 'irb'
+IRB.start(__FILE__)

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/gemfiles/rails-6-1

@@ -0,0 +1,3 @@
+eval_gemfile '../Gemfile.common'
+
+gem 'rails', '~> 6.1'

data/gemfiles/rails-edge

@@ -0,0 +1,3 @@
+eval_gemfile '../Gemfile.common'
+
+gem 'rails', github: 'rails/rails', branch: 'main'

data/lib/ar_cache.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require 'active_support/cache'
+require 'active_record'
+
+require 'ar_cache/version'
+require 'ar_cache/configuration'
+require 'ar_cache/record'
+require 'ar_cache/store'
+require 'ar_cache/marshal'
+require 'ar_cache/table'
+require 'ar_cache/mock_table'
+require 'ar_cache/query'
+require 'ar_cache/where_clause'
+require 'ar_cache/log_subscriber'
+require 'ar_cache/active_record'
+
+require_relative './generators/ar_cache/install_generator' if defined?(Rails)
+
+module ArCache
+  singleton_class.delegate :configure, to: Configuration
+end

data/lib/ar_cache/active_record.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require 'ar_cache/active_record/model_schema'
+require 'ar_cache/active_record/relation'
+require 'ar_cache/active_record/core'
+require 'ar_cache/active_record/persistence'
+require 'ar_cache/active_record/insert_all'
+require 'ar_cache/active_record/associations/singular_association'
+require 'ar_cache/active_record/associations/has_one_through_association'
+require 'ar_cache/active_record/connection_adapters/abstract/transaction'
+require 'ar_cache/active_record/connection_adapters/abstract/database_statements'
+
+# rubocop:disable Layout/LineLength
+ActiveSupport.on_load(:active_record, run_once: true) do
+  ActiveRecord::Core::ClassMethods.prepend(ArCache::ActiveRecord::Core::ClassMethods)
+
+  ActiveRecord::ModelSchema.prepend(ArCache::ActiveRecord::ModelSchema)
+  ActiveRecord::ModelSchema::ClassMethods.prepend(ArCache::ActiveRecord::ModelSchema::ClassMethods)
+
+  ActiveRecord::Persistence.prepend(ArCache::ActiveRecord::Persistence)
+
+  ActiveRecord::InsertAll.prepend(ArCache::ActiveRecord::InsertAll)
+
+  ActiveRecord::Relation.prepend(ArCache::ActiveRecord::Relation)
+
+  ActiveRecord::Associations::SingularAssociation.prepend(ArCache::ActiveRecord::Associations::SingularAssociation)
+  ActiveRecord::Associations::HasOneThroughAssociation.prepend(ArCache::ActiveRecord::Associations::HasOneThroughAssociation)
+
+  ActiveRecord::ConnectionAdapters::NullTransaction.prepend(ArCache::ActiveRecord::ConnectionAdapters::NullTransaction)
+  ActiveRecord::ConnectionAdapters::RealTransaction.prepend(ArCache::ActiveRecord::ConnectionAdapters::Transaction)
+  ActiveRecord::ConnectionAdapters::SavepointTransaction.prepend(ArCache::ActiveRecord::ConnectionAdapters::Transaction)
+  ActiveRecord::ConnectionAdapters::TransactionManager.prepend(ArCache::ActiveRecord::ConnectionAdapters::TransactionManager)
+
+  ActiveRecord::ConnectionAdapters::DatabaseStatements.prepend(ArCache::ActiveRecord::ConnectionAdapters::DatabaseStatements)
+end
+# rubocop:enable Layout/LineLength

data/lib/ar_cache/active_record/associations/has_one_through_association.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module ArCache
+  module ActiveRecord
+    module Associations
+      module HasOneThroughAssociation
+        private def find_target # rubocop:disable Metrics/PerceivedComplexity, Metrics/CyclomaticComplexity
+          return super if reflection.klass.ar_cache_table.disabled?
+          return super if reflection.through_reflection.klass.ar_cache_table.disabled?
+
+          if owner.strict_loading? && owner.validation_context.nil?
+            Base.strict_loading_violation!(owner: owner.class, association: reflection.klass)
+          end
+
+          if reflection.strict_loading? && owner.validation_context.nil?
+            Base.strict_loading_violation!(owner: owner.class, association: reflection.name)
+          end
+
+          # TODO: Should not instantiate AR
+          through_record = if reflection.scope
+                             owner.association(reflection.through_reflection.name).scope.merge(reflection.scope).first
+                           else
+                             owner.send(reflection.through_reflection.name)
+                           end
+          return super if through_record.is_a?(::ActiveRecord::Associations::CollectionProxy)
+          return nil if !through_record || through_record.destroyed?
+
+          record = through_record.send(reflection.source_reflection.name)
+          record = record.first if record.is_a?(::ActiveRecord::Associations::CollectionProxy)
+          return nil unless record
+
+          record.tap { |r| set_inverse_instance(r) }
+        rescue StandardError # If scope depend on other table, will raise exception
+          super
+        end
+      end
+    end
+  end
+end

data/lib/ar_cache/active_record/associations/singular_association.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module ArCache
+  module ActiveRecord
+    module Associations
+      module SingularAssociation
+        private def skip_statement_cache?(...)
+          # Polymorphic associations do not support computing the class, so can't judge ArCache status.
+          # But SingularAssociation query usually can hit the unique index, so here return true directly.
+          return true if is_a?(::ActiveRecord::Associations::BelongsToPolymorphicAssociation)
+          return true if reflection.klass.ar_cache_table.enabled?
+
+          super
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+module ArCache
+  module ActiveRecord
+    module ConnectionAdapters
+      module DatabaseStatements
+        def insert(arel, ...)
+          super.tap do
+            if arel.is_a?(String)
+              sql = arel.downcase
+              ArCache::Table.all.each do |table|
+                current_transaction.add_changed_table(table.name) if sql.include?(table.name)
+              end
+            else # is Arel::InsertManager
+              klass = arel.ast.relation.instance_variable_get(:@klass)
+              current_transaction.add_changed_table(klass.table_name)
+            end
+          end
+        end
+        alias create insert
+
+        def update(arel, ...)
+          super.tap { |num| update_ar_cache_version(arel) unless num.zero? }
+        end
+
+        def delete(arel, ...)
+          super.tap { |num| update_ar_cache_version(arel) unless num.zero? }
+        end
+
+        def truncate(table_name, ...)
+          super.tap { update_ar_cache_version_by_table(table_name) }
+        end
+
+        def truncate_tables(*table_names)
+          super.tap do
+            table_names.each { |table_name| update_ar_cache_version_by_table(table_name) }
+          end
+        end
+
+        private def update_ar_cache_version(arel_or_sql_string)
+          if arel_or_sql_string.is_a?(String)
+            update_ar_cache_version_by_sql(arel_or_sql_string)
+          else # is Arel::TreeManager
+            update_ar_cache_version_by_arel(arel_or_sql_string)
+          end
+        end
+
+        private def update_ar_cache_version_by_arel(arel)
+          # arel.ast.relation may be of the following types:
+          #   - Arel::Nodes::JoinSource
+          #   - Arel::Table
+          arel_table = arel.ast.relation.is_a?(Arel::Table) ? arel.ast.relation : arel.ast.relation.left
+          klass = arel_table.instance_variable_get(:@klass)
+          return if klass.ar_cache_table.disabled?
+
+          where_clause = ArCache::WhereClause.new(klass, arel.ast.wheres)
+          if where_clause.cacheable?
+            current_transaction.add_changed_table(klass.table_name)
+            current_transaction.add_ar_cache_keys(where_clause.cache_keys)
+          else
+            current_transaction.add_ar_cache_table(klass.ar_cache_table)
+          end
+        end
+
+        private def update_ar_cache_version_by_sql(sql)
+          sql = sql.downcase
+          ArCache::Table.all.each { |table| current_transaction.add_ar_cache_table(table) if sql.include?(table.name) }
+        end
+
+        private def update_ar_cache_version_by_table(table_name)
+          ArCache::Table.all.each { |table| table.update_version if table_name.casecmp?(table.name) }
+        end
+      end
+    end
+  end
+end