solid_cache 0.6.0 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7ba0486907f0e4656593843d1cca1c7ec35763772ff6d5a2a4e43b9d43b023b3
-  data.tar.gz: a93991c212dcb6d0a1dedb20e2d8d85e0664092c2342db895489beafb9f17e23
+  metadata.gz: 74f6b8bdfea57b8ffbe60b8f525b3907c7278f4b73d07fad2506a41b0884a14c
+  data.tar.gz: b3af9a6526d97bcb9b5ac1fd313b9c9cf76551ae75e214479a10fe9b04d678d3
 SHA512:
-  metadata.gz: 9897aef78db43aff6bceea922aa43669f76a48852d4dc94e64ce8aa198c1ca7fd04152a15033760a6fecad11245b650369342345c6f07e366c3d3d4e0a71f1da
-  data.tar.gz: cd59a068b761fd6060005d9ef78328cd03a3420ee539c07a6afd14eed072a0e9a092d135fbadeb5a58d38aa5a146e8481286b50ef411548a15b701464c0394b0
+  metadata.gz: b6503fe5c3f9d3158ec64bc054465e48f1479236b05fd3b023f4c7050b8c2c0019a546cae0c494a91da0c7b3e9abf3cc3f8f700b2d6c9853a3832b8a726d750a
+  data.tar.gz: 38eec70ef2680b811f9f3baf42e02d5d81d72947c508f45a4ca0cd8d2c1d6d761280e5ec15261c4ca3b94fbdfe20dd1cf96a2cf871255791b41a2d11cfe8aa29

data/README.md

@@ -4,25 +4,19 @@
 
 Solid Cache is a database-backed Active Support cache store implementation.
 
-Using SQL databases backed by SSDs we can have caches that are much larger and cheaper than traditional memory only Redis or Memcached backed caches.
+Using SQL databases backed by SSDs we can have caches that are much larger and cheaper than traditional memory-only Redis or Memcached backed caches.
 
-## Usage
+## Introduction
 
-To set Solid Cache as your Rails cache, you should add this to your environment config:
-
-```ruby
-config.cache_store = :solid_cache_store
-```
-
-Solid Cache is a FIFO (first in, first out) cache. While this is not as efficient as an LRU cache, this is mitigated by the longer cache lifespan.
+Solid Cache is a FIFO (first in, first out) cache. While this is not as efficient as an LRU cache, it is mitigated by the longer cache lifespan.
 
 A FIFO cache is much easier to manage:
-1. We don't need to track when items are read
+1. We don't need to track when items are read.
 2. We can estimate and control the cache size by comparing the maximum and minimum IDs.
 3. By deleting from one end of the table and adding at the other end we can avoid fragmentation (on MySQL at least).
 
-### Installation
-Add this line to your application's Gemfile:
+## Installation
+Add this line to your application's `Gemfile`:
 
 ```ruby
 gem "solid_cache"
@@ -38,13 +32,69 @@ Or install it yourself as:
 $ gem install solid_cache
 ```
 
-Add the migration to your app:
+#### Cache database configuration
+
+The default installation of Solid Cache expects a database named `cache` in `database.yml`. It should
+have it's own connection pool to avoid mixing cache queries in other transactions.
+
+You can use the primary database for your cache like this:
+
+```yaml
+# config/database.yml
+production:
+  primary: &production_primary
+    ...
+  cache:
+    <<: *production_primary
+```
+
+Or a separate database like this:
+
+```yaml
+production:
+  primary:
+    ...
+  cache:
+    database: cache_development
+    host: 127.0.0.1
+    migrations_paths: "db/cache/migrate"
+```
+
+#### Install Solid Cache
+
+Now, you need to install the necessary migrations and configure the cache store. You can do both at once using the provided generator:
+
+```bash
+# If using the primary database
+$ bin/rails generate solid_cache:install
+
+# Or if using a dedicated database
+$ DATABASE=cache bin/rails generate solid_cache:install
+```
+
+This will set solid_cache as the cache store in production, and will copy the optional configuration file and the required migration over to your app.
+
+Alternatively, you can add only the migration to your app:
 
 ```bash
-$ bin/rails solid_cache:install:migrations
+# If using the primary database
+$ bin/rails generate solid_cache:install:migrations
+
+# Or if using a dedicated database
+$ DATABASE=cache bin/rails generate solid_cache:install:migrations
 ```
 
-Then run it:
+And set Solid Cache as your application's cache store backend manually, in your environment config:
+
+```ruby
+# config/environments/production.rb
+config.cache_store = :solid_cache_store
+```
+
+#### Run migrations
+
+Finally, you need to run the migrations:
+
 ```bash
 $ bin/rails db:migrate
 ```
@@ -93,9 +143,9 @@ Setting `databases` to `[cache_db, cache_db2]` is the equivalent of:
 SolidCache::Record.connects_to shards: { cache_db1: { writing: :cache_db1 },  cache_db2: { writing: :cache_db2 } }
 ```
 
-If `connects_to` is set it will be passed directly.
+If `connects_to` is set, it will be passed directly.
 
-If none of these are set, then Solid Cache will use the `ActiveRecord::Base` connection pool. This means that cache reads and writes will be part of any wrapping
+If none of these are set, Solid Cache will use the `ActiveRecord::Base` connection pool. This means that cache reads and writes will be part of any wrapping
 database transaction.
 
 #### Engine configuration
@@ -104,7 +154,9 @@ There are three options that can be set on the engine:
 
 - `executor` - the [Rails executor](https://guides.rubyonrails.org/threading_and_code_execution.html#executor) used to wrap asynchronous operations, defaults to the app executor
 - `connects_to` - a custom connects to value for the abstract `SolidCache::Record` active record model. Required for sharding and/or using a separate cache database to the main app. This will overwrite any value set in `config/solid_cache.yml`
-- `size_estimate_samples` - if `max_size` is set on the cache, the number of the samples used to estimates the size.
+- `size_estimate_samples` - if `max_size` is set on the cache, the number of the samples used to estimate the size.
+- `encrypted` - whether cache values should be encrypted (see [Enabling encryption](#enabling-encryption))
+- `encryption_context_properties` - custom encryption context properties
 
 These can be set in your Rails configuration:
 
@@ -116,7 +168,7 @@ end
 
 #### Cache configuration
 
-Solid Cache supports these options in addition to the standard `ActiveSupport::Cache::Store` options.
+Solid Cache supports these options in addition to the standard `ActiveSupport::Cache::Store` options:
 
 - `error_handler` - a Proc to call to handle any `ActiveRecord::ActiveRecordError`s that are raises (default: log errors as warnings)
 - `expiry_batch_size` - the batch size to use when deleting old records (default: `100`)
@@ -125,79 +177,40 @@ Solid Cache supports these options in addition to the standard `ActiveSupport::C
 - `max_age` - the maximum age of entries in the cache (default: `2.weeks.to_i`). Can be set to `nil`, but this is not recommended unless using `max_entries` to limit the size of the cache.
 - `max_entries` - the maximum number of entries allowed in the cache (default: `nil`, meaning no limit)
 - `max_size` - the maximum size of the cache entries (default `nil`, meaning no limit)
-- `cluster` - a Hash of options for the cache database cluster, e.g `{ shards: [:database1, :database2, :database3] }`
-- `clusters` - and Array of Hashes for multiple cache clusters (ignored if `:cluster` is set)
+- `cluster` - (deprecated) a Hash of options for the cache database cluster, e.g `{ shards: [:database1, :database2, :database3] }`
+- `clusters` - (deprecated) an Array of Hashes for multiple cache clusters (ignored if `:cluster` is set)
+- `shards` - an Array of databases
 - `active_record_instrumentation` - whether to instrument the cache's queries (default: `true`)
 - `clear_with` - clear the cache with `:truncate` or `:delete` (default `truncate`, except for when `Rails.env.test?` then `delete`)
 - `max_key_bytesize` - the maximum size of a normalized key in bytes (default `1024`)
 
-For more information on cache clusters see [Sharding the cache](#sharding-the-cache)
+For more information on cache clusters, see [Sharding the cache](#sharding-the-cache)
 
 ### Cache expiry
 
 Solid Cache tracks writes to the cache. For every write it increments a counter by 1. Once the counter reaches 50% of the `expiry_batch_size` it adds a task to run on a background thread. That task will:
 
-1. Check if we have exceeded the `max_entries` or `max_size` values (if set)
+1. Check if we have exceeded the `max_entries` or `max_size` values (if set).
    The current entries are estimated by subtracting the max and min IDs from the `SolidCache::Entry` table.
    The current size is estimated by sampling the entry `byte_size` columns.
-2. If we have it will delete `expiry_batch_size` entries
-3. If not it will delete up to `expiry_batch_size` entries, provided they are all older than `max_age`.
+2. If we have, it will delete `expiry_batch_size` entries.
+3. If not, it will delete up to `expiry_batch_size` entries, provided they are all older than `max_age`.
 
 Expiring when we reach 50% of the batch size allows us to expire records from the cache faster than we write to it when we need to reduce the cache size.
 
-Only triggering expiry when we write means that the if the cache is idle, the background thread is also idle.
+Only triggering expiry when we write means that if the cache is idle, the background thread is also idle.
 
 If you want the cache expiry to be run in a background job instead of a thread, you can set `expiry_method` to `:job`. This will enqueue a `SolidCache::ExpiryJob`.
 
-### Using a dedicated cache database
-
-Add database configuration to database.yml, e.g.:
-
-```
-development:
-  cache:
-    database: cache_development
-    host: 127.0.0.1
-    migrations_paths: "db/cache/migrate"
-```
-
-Create database:
-```
-$ bin/rails db:create
-```
-
-Install migrations:
-```
-$ bin/rails solid_cache:install:migrations
-```
-
-Move migrations to custom migrations folder:
-```
-$ mkdir -p db/cache/migrate
-$ mv db/migrate/*.solid_cache.rb db/cache/migrate
-```
-
-Set the engine configuration to point to the new database:
-```yaml
-# config/solid_cache.yml
-production:
-  database: cache
-```
-
-Run migrations:
-```
-$ bin/rails db:migrate
-```
-
 ### Sharding the cache
 
 Solid Cache uses the [Maglev](https://static.googleusercontent.com/media/research.google.com/en//pubs/archive/44824.pdf) consistent hashing scheme to shard the cache across multiple databases.
 
 To shard:
 
-1. Add the configuration for the database shards to database.yml
-2. Configure the shards via `config.solid_cache.connects_to`
-3. Pass the shards for the cache to use via the cluster option
+1. Add the configuration for the database shards to database.yml.
+2. Configure the shards via `config.solid_cache.connects_to`.
+3. Pass the shards for the cache to use via the cluster option.
 
 For example:
 ```yml
@@ -220,58 +233,49 @@ production:
   databases: [cache_shard1, cache_shard2, cache_shard3]
 ```
 
-### Secondary cache clusters
-
-You can add secondary cache clusters. Reads will only be sent to the primary cluster (i.e. the first one listed).
-
-Writes will go to all clusters. The writes to the primary cluster are synchronous, but asynchronous to the secondary clusters.
+### Enabling encryption
 
-To specific multiple clusters you can do:
+To encrypt the cache values, you can add set the encrypt property.
 
 ```yaml
 # config/solid_cache.yml
 production:
-  databases: [cache_primary_shard1, cache_primary_shard2, cache_secondary_shard1, cache_secondary_shard2]
-  store_options:
-    clusters:
-      - shards: [cache_primary_shard1, cache_primary_shard2]
-      - shards: [cache_secondary_shard1, cache_secondary_shard2]
+  encrypt: true
+```
+or
+```ruby
+# application.rb
+config.solid_cache.encrypt = true
 ```
 
-### Named shard destinations
-
-By default, the node key used for sharding is the name of the database in `database.yml`.
-
-It is possible to add names for the shards in the cluster config. This will allow you to shuffle or remove shards without breaking consistent hashing.
+You will need to set up your application to (use Active Record Encryption)[https://guides.rubyonrails.org/active_record_encryption.html].
 
-```yaml
-production:
-  databases: [cache_primary_shard1, cache_primary_shard2, cache_secondary_shard1, cache_secondary_shard2]
-  store_options:
-    clusters:
-      - shards:
-          cache_primary_shard1: node1
-          cache_primary_shard2: node2
-      - shards:
-          cache_secondary_shard1: node3
-          cache_secondary_shard2: node4
-```
+Solid Cache by default uses a custom encryptor and message serializer that are optimised for it.
 
-### Enabling encryption
+Firstly it disabled compression with the encryptor `ActiveRecord::Encryption::Encryptor.new(compress: false)` - the cache already compresses the data.
+Secondly it uses `ActiveRecord::Encryption::MessagePackMessageSerializer.new` as the serializer. This serializer can only be used for binary columns,
+but can store about 40% more data than the standard serializer.
 
-Add this to an initializer:
+You can choose your own context properties instead if you prefer:
 
 ```ruby
-ActiveSupport.on_load(:solid_cache_entry) do
-  encrypts :value
-end
+# application.rb
+config.solid_cache.encryption_context_properties = {
+  encryptor: ActiveRecord::Encryption::Encryptor.new,
+  message_serializer: ActiveRecord::Encryption::MessageSerializer.new
+}
 ```
 
+**Note**
+
+Encryption currently does not work for PostgreSQL, as Rails does not yet support encrypting binary columns for it.
+See https://github.com/rails/rails/pull/52650.
+
 ### Index size limits
 The Solid Cache migrations try to create an index with 1024 byte entries. If that is too big for your database, you should:
 
-1. Edit the index size in the migration
-2. Set `max_key_bytesize` on your cache to the new value
+1. Edit the index size in the migration.
+2. Set `max_key_bytesize` on your cache to the new value.
 
 ## Development
 
@@ -298,10 +302,10 @@ $ TARGET_DB=mysql bin/rake test
 $ TARGET_DB=postgres bin/rake test
 ```
 
-### Testing with multiple Rails version
+### Testing with multiple Rails versions
 
 Solid Cache relies on [appraisal](https://github.com/thoughtbot/appraisal/tree/main) to test
-multiple Rails version.
+multiple Rails versions.
 
 To run a test for a specific version run:
 

data/Rakefile

@@ -15,7 +15,9 @@ def run_without_aborting(*tasks)
 
   tasks.each do |task|
     Rake::Task[task].invoke
-  rescue Exception
+  rescue Exception => e
+    puts e.message
+    puts e.backtrace
     errors << task
   end
 
@@ -23,7 +25,7 @@ def run_without_aborting(*tasks)
 end
 
 def configs
-  [ :default, :cluster, :cluster_inferred, :clusters, :clusters_named, :database, :no_database ]
+  [ :default, :connects_to, :database, :encrypted, :encrypted_custom, :no_database, :shards, :unprepared_statements ]
 end
 
 task :test do
@@ -34,6 +36,11 @@ end
 configs.each do |config|
   namespace :test do
     task config do
+      if config.to_s.start_with?("encrypted") && ENV["TARGET_DB"] == "postgres"
+        puts "Skipping encrypted tests on PostgreSQL as binary encrypted columns are not supported by Rails yet"
+        next
+      end
+
       if config == :default
         sh("bin/rails test")
       else
@@ -42,3 +49,5 @@ configs.each do |config|
     end
   end
 end
+
+task default: [:test]

data/app/models/solid_cache/entry/encryption.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module SolidCache
+  class Entry
+    module Encryption
+      extend ActiveSupport::Concern
+
+      included do
+        if SolidCache.configuration.encrypt?
+          encrypts :value, **SolidCache.configuration.encryption_context_properties
+        end
+      end
+    end
+  end
+end

data/app/models/solid_cache/entry/size/estimate.rb

@@ -27,7 +27,7 @@ module SolidCache
     # We then calculate the fraction of the rows we want to sample by dividing the sample size by the estimated number
     # of rows.
     #
-    # The we grab the byte_size sum of the rows in the range of key_hash values excluding any rows that are larger than
+    # Then we grab the byte_size sum of the rows in the range of key_hash values excluding any rows that are larger than
     # our minimum outlier cutoff. We then divide this by the sampling fraction to get an estimate of the size of the
     # non outlier rows
     #

data/app/models/solid_cache/entry/size/moving_average_estimate.rb

@@ -3,9 +3,9 @@
 module SolidCache
   class Entry
     module Size
-      # Moving averate cache size estimation
+      # Moving average cache size estimation
       #
-      # To reduce variablitity in the cache size estimate, we'll use a moving average of the previous 20 estimates.
+      # To reduce variability in the cache size estimate, we'll use a moving average of the previous 20 estimates.
       # The estimates are stored directly in the cache, under the "__solid_cache_entry_size_moving_average_estimates" key.
       #
       # We'll remove the largest and smallest estimates, and then average remaining ones.

data/app/models/solid_cache/entry.rb

@@ -2,41 +2,45 @@
 
 module SolidCache
   class Entry < Record
-    include Expiration, Size
+    include Encryption, Expiration, Size
 
     # The estimated cost of an extra row in bytes, including fixed size columns, overhead, indexes and free space
-    # Based on expirimentation on SQLite, MySQL and Postgresql.
+    # Based on experimentation on SQLite, MySQL and Postgresql.
     # A bit high for SQLite (more like 90 bytes), but about right for MySQL/Postgresql.
     ESTIMATED_ROW_OVERHEAD = 140
+
+    # Assuming MessagePack serialization
+    ESTIMATED_ENCRYPTION_OVERHEAD = 170
+
     KEY_HASH_ID_RANGE = -(2**63)..(2**63 - 1)
 
     class << self
       def write(key, value)
-        upsert_all_no_query_cache([ { key: key, value: value } ])
+        write_multi([ { key: key, value: value } ])
       end
 
       def write_multi(payloads)
-        upsert_all_no_query_cache(payloads)
+        without_query_cache do
+          upsert_all \
+            add_key_hash_and_byte_size(payloads),
+            unique_by: upsert_unique_by, on_duplicate: :update, update_only: [ :key, :value, :byte_size ]
+        end
       end
 
       def read(key)
-        result = select_all_no_query_cache(get_sql, key_hash_for(key)).first
-        result[1] if result&.first == key
+        read_multi([key])[key]
       end
 
       def read_multi(keys)
-        key_hashes = keys.map { |key| key_hash_for(key) }
-        results = select_all_no_query_cache(get_all_sql(key_hashes), key_hashes).to_h
-        results.except!(results.keys - keys)
-      end
-
-      def delete_by_key(key)
-        delete_no_query_cache(:key_hash, key_hash_for(key)) > 0
+        without_query_cache do
+          find_by_sql([select_sql(keys), *key_hashes_for(keys)]).pluck(:key, :value).to_h
+        end
       end
 
-      def delete_multi(keys)
-        serialized_keys = keys.map { |key| key_hash_for(key) }
-        delete_no_query_cache(:key_hash, serialized_keys)
+      def delete_by_key(*keys)
+        without_query_cache do
+          where(key_hash: key_hashes_for(keys)).delete_all
+        end
       end
 
       def clear_truncate
@@ -44,48 +48,29 @@ module SolidCache
       end
 
       def clear_delete
-        in_batches.delete_all
+        without_query_cache do
+          in_batches.delete_all
+        end
       end
 
       def lock_and_write(key, &block)
         transaction do
-          uncached do
+          without_query_cache do
             result = lock.where(key_hash: key_hash_for(key)).pick(:key, :value)
             new_value = block.call(result&.first == key ? result[1] : nil)
-            write(key, new_value)
+            write(key, new_value) if new_value
             new_value
           end
         end
       end
 
       def id_range
-        uncached do
+        without_query_cache do
           pick(Arel.sql("max(id) - min(id) + 1")) || 0
         end
       end
 
       private
-        def upsert_all_no_query_cache(payloads)
-          args = [ self,
-                   connection_for_insert_all,
-                   add_key_hash_and_byte_size(payloads) ].compact
-          options = { unique_by: upsert_unique_by,
-                      on_duplicate: :update,
-                      update_only: upsert_update_only }
-          insert_all = ActiveRecord::InsertAll.new(*args, **options)
-          sql = connection.build_insert_sql(ActiveRecord::InsertAll::Builder.new(insert_all))
-
-          message = +"#{self} "
-          message << "Bulk " if payloads.many?
-          message << "Upsert"
-          # exec_query_method does not clear the query cache, exec_insert_all does
-          connection.send exec_query_method, sql, message
-        end
-
-        def connection_for_insert_all
-          Rails.version >= "7.2" ? connection : nil
-        end
-
         def add_key_hash_and_byte_size(payloads)
           payloads.map do |payload|
             payload.dup.tap do |payload|
@@ -95,77 +80,42 @@ module SolidCache
           end
         end
 
-        def exec_query_method
-          connection.respond_to?(:internal_exec_query) ? :internal_exec_query : :exec_query
-        end
-
         def upsert_unique_by
           connection.supports_insert_conflict_target? ? :key_hash : nil
         end
 
-        def upsert_update_only
-          [ :key, :value, :byte_size ]
+        def select_sql(keys)
+          @get_sql ||= {}
+          @get_sql[keys.count] ||= \
+            where(key_hash: [ "1111", "2222" ])
+              .select(:key, :value)
+              .to_sql
+              .gsub("1111, 2222", (["?"] * keys.count).join(", "))
         end
 
-        def get_sql
-          @get_sql ||= build_sql(where(key_hash: 1).select(:key, :value))
-        end
-
-        def get_all_sql(key_hashes)
-          if connection.prepared_statements?
-            @get_all_sql_binds ||= {}
-            @get_all_sql_binds[key_hashes.count] ||= build_sql(where(key_hash: key_hashes).select(:key, :value))
-          else
-            @get_all_sql_no_binds ||= build_sql(where(key_hash: [ 1, 2 ]).select(:key, :value)).gsub("?, ?", "?")
-          end
+        def key_hash_for(key)
+          # Need to unpack this as a signed integer - Postgresql and SQLite don't support unsigned integers
+          Digest::SHA256.digest(key.to_s).unpack("q>").first
         end
 
-        def build_sql(relation)
-          collector = Arel::Collectors::Composite.new(
-            Arel::Collectors::SQLString.new,
-            Arel::Collectors::Bind.new,
-          )
-
-          connection.visitor.compile(relation.arel.ast, collector)[0]
+        def key_hashes_for(keys)
+          keys.map { |key| key_hash_for(key) }
         end
 
-        def select_all_no_query_cache(query, values)
-          uncached do
-            if connection.prepared_statements?
-              result = connection.select_all(sanitize_sql(query), "#{name} Load", Array(values), preparable: true)
-            else
-              result = connection.select_all(sanitize_sql([ query, values ]), "#{name} Load", Array(values), preparable: false)
-            end
-
-            result.cast_values(SolidCache::Entry.attribute_types)
-          end
+        def byte_size_for(payload)
+          payload[:key].to_s.bytesize + payload[:value].to_s.bytesize + estimated_row_overhead
         end
 
-        def delete_no_query_cache(attribute, values)
-          uncached do
-            relation = where(attribute => values)
-            sql = connection.to_sql(relation.arel.compile_delete(relation.table[primary_key]))
-
-            # exec_delete does not clear the query cache
-            if connection.prepared_statements?
-              connection.exec_delete(sql, "#{name} Delete All", Array(values))
-            else
-              connection.exec_delete(sql, "#{name} Delete All")
-            end
+        def estimated_row_overhead
+          if SolidCache.configuration.encrypt?
+            ESTIMATED_ROW_OVERHEAD + ESTIMATED_ENCRYPTION_OVERHEAD
+          else
+            ESTIMATED_ROW_OVERHEAD
           end
         end
 
-        def to_binary(key)
-          ActiveModel::Type::Binary.new.serialize(key)
-        end
-
-        def key_hash_for(key)
-          # Need to unpack this as a signed integer - Postgresql and SQLite don't support unsigned integers
-          Digest::SHA256.digest(key.to_s).unpack("q>").first
-        end
-
-        def byte_size_for(payload)
-          payload[:key].to_s.bytesize + payload[:value].to_s.bytesize + ESTIMATED_ROW_OVERHEAD
+        def without_query_cache(&block)
+          uncached(dirties: false, &block)
         end
     end
   end

data/db/migrate/20240820123641_create_solid_cache_entries.rb

@@ -0,0 +1,29 @@
+class CreateSolidCacheEntries < ActiveRecord::Migration[7.2]
+  def up
+    create_table :solid_cache_entries, if_not_exists: true do |t|
+      t.binary   :key,        null: false,   limit: 1024
+      t.binary   :value,      null: false,   limit: 512.megabytes
+      t.datetime :created_at, null: false
+      t.integer :key_hash,    null: false,    limit: 8
+      t.integer :byte_size,   null: false,    limit: 4
+
+      t.index  :key_hash, unique: true
+      t.index  [:key_hash, :byte_size]
+      t.index  :byte_size
+    end
+
+    raise "column \"key_hash\" does not exist" unless column_exists? :solid_cache_entries, :key_hash
+  rescue => e
+    if e.message =~ /(column "key_hash" does not exist|no such column: key_hash)/
+      raise \
+        "Could not find key_hash column on solid_cache_entries, if upgrading from v0.3 or earlier, have you followed " \
+        "the steps in https://github.com/rails/solid_cache/blob/main/upgrading_to_version_0.4.x.md?"
+    else
+      raise
+    end
+  end
+
+  def down
+    drop_table :solid_cache_entries
+  end
+end

data/lib/generators/solid_cache/install/templates/config/solid_cache.yml.tt

@@ -1,5 +1,5 @@
 default: &default
-  database: <%%= Rails.env %>
+  database: <%= ENV.fetch("DATABASE", "cache") %>
   store_options:
     max_age: <%%= 1.week.to_i %>
     max_size: <%%= 256.megabytes %>