solid_cache_mongoid 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: cf9d5857f9532ff873ca0667c47e572d61ccaee958a9768d0bf372832ed45067
-  data.tar.gz: 2e6a812dd2b7930ddf81f7f1cddbf08cef0cf039365f974412b7460642964ee4
+  metadata.gz: a0a03bc074cafd74ca8702ecf9adbe0ebff49846a848d4d11d2acb3ed304547e
+  data.tar.gz: f8394194bdddca35cf85f46bbcd556e5b10e4342f5c45930d695ff780dcbc942
 SHA512:
-  metadata.gz: 1355e87bd9234e18d12a7a33fb70d9145be98088fa1117f983110a998fe5ec5f2857e8baf1d826a601112c224839e4e37ff0f0d738f04709ecdb550173032da2
-  data.tar.gz: 86dc49c94645cf8c6ecdc5c5d69ead576bf15ed66d3ecf0629952f7c49db7beafa3c181e993e3b4050a02ba0cdc50cb03931a79518315b71d03b3574c82e30a6
+  metadata.gz: 947dd55858789b134d31497476cb2881153a14576c86fa2cf27d56aadbd867215d53a78faf66660f930a20648eaf2e961d28b4aafffe3179dbcc6bd611a86a28
+  data.tar.gz: 1241fc8dbe3dfca7f5e0206ad42b795ebe2a328cd9ecd5d31e615311c9aac343068f5434e5c95d68b7bb0fb4d5aee056a5ebc044e9e39e9869e9a3d156ea628a

data/README.md

@@ -1,189 +1,163 @@
-# Solid Cache
+# Solid Cache for Mongoid
 
-Solid Cache is a database-backed Active Support cache store that lets you keep a much larger cache than is typically possible with traditional memory-only Redis or Memcached stores. This is thanks to the speed of modern SSD drives, which make the access-time penalty of using disk vs RAM insignificant for most caching purposes. Simply put, you're now usually better off keeping a huge cache on disk rather than a small cache in memory.
+[![Gem Version](https://img.shields.io/gem/v/solid_cache_mongoid?style=flat-square)](https://rubygems.org/gems/solid_cache_mongoid)
+[![Downloads](https://img.shields.io/gem/dt/solid_cache_mongoid?style=flat-square)](https://rubygems.org/gems/solid_cache_mongoid)
+[![License](https://img.shields.io/github/license/duvanherfi/solid_cache_mongoid?style=flat-square)](MIT-LICENSE)
 
-## Installation
-
-Solid Cache is configured by default in new Rails 8 applications. But if you're running an earlier version, you can add it manually following these steps:
-
-1. `bundle add solid_cache_mongoid`
-2. `bin/rails solid_cache_mongoid:install`
-
-This will configure Solid Cache as the production cache store and create `config/cache.yml`.
-
-## Configuration
+A database-backed `ActiveSupport::Cache::Store` for Rails applications that run
+on **MongoDB**.
 
-Configuration will be read from `config/cache.yml` or `config/solid_cache.yml`. You can change the location of the config file by setting the `SOLID_CACHE_CONFIG` env variable.
+Rails 8 ships [Solid Cache](https://github.com/rails/solid_cache), which trades
+RAM for disk: modern SSDs are fast enough that a large cache on disk beats a
+small cache in memory for most workloads. But Solid Cache is built on Active
+Record. An application backed by Mongoid cannot use it, and gets pushed onto
+Redis or Memcached for caching alone — one more service to run, pay for, and be
+paged about.
 
-The format of the file is:
-
-```yml
-default: &default
-  # database: <%= ENV.fetch("SOLID_CACHE_DATABASE", "solid_cache") %>
-  # collection: solid_cache_entries
-  # client: default
-  # encrypt: false
-  store_options:
-    # Cap age of oldest cache entry to fulfill retention policies
-    # max_age: <%%= 60.days.to_i %>
-    max_size: <%%= 256.megabytes %>
-    namespace: <%%= Rails.env %>
-
-development:
-  <<: *default
+This is Solid Cache rewritten on Mongoid, so those applications can cache
+against the database they already have.
 
-test:
-  <<: *default
-
-production:
-  database: <%= ENV.fetch("SOLID_CACHE_DATABASE", "solid_cache") %>
-  <<: *default
-
-```
-
-For the full list of keys for `store_options` see [Cache configuration](#cache-configuration). Any options passed to the cache lookup will overwrite those specified here.
-
-After running `solid_cache:install`, `environments/production.rb` will replace your cache store with Solid Cache, but you can also do this manually:
+## Installation
 
 ```ruby
-# config/environments/production.rb
-config.cache_store = :solid_cache_mongoid_store
+# Gemfile
+gem "solid_cache_mongoid"
 ```
-### Engine configuration
-
-There are five 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
-- `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:
-
-```ruby
-Rails.application.configure do
-  config.solid_cache.size_estimate_samples = 1000
-end
+```sh
+bundle install
+bin/rails generate solid_cache_mongoid:install
 ```
 
-### Cache configuration
-
-Solid Cache supports these options in addition to the standard `ActiveSupport::Cache::Store` options:
+The generator writes `config/cache.yml` and points `config.cache_store` at
+`:solid_cache_mongoid_store` in development, test and production.
 
-- `error_handler` - a Proc to call to handle any transient database errors that are raised (default: log errors as warnings)
-- `expiry_batch_size` - the batch size to use when deleting old records (default: `100`)
-- `expiry_method` - what expiry method to use `thread` or `job` (default: `thread`)
-- `expiry_queue` - which queue to add expiry jobs to (default: `default`)
-- `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` - (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`)
+There is no migration to run. The collection is created on first write and the
+indexes are declared on the model — a unique index on `key_hash` for lookups,
+plus `byte_size` and a compound `key_hash + byte_size` used by size estimation.
 
-## Cache expiry
+Requires Rails >= 7.2 (< 8.1) and Mongoid >= 9.
 
-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).
-   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`.
-
-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.
+## Configuration
 
-Only triggering expiry when we write means that if the cache is idle, the background thread is also idle.
+The cache always lives in its own Mongo database — `solid_cache_mongoid` unless
+you name another one — in a `solid_cache_entries` collection. It never shares
+the application's database, so cache traffic and application traffic can be
+pointed at different clients, and dropping the cache can never touch business
+data.
 
-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`.
+`config/cache.yml`:
 
-## Enabling encryption
+```yaml
+default: &default
+  database: solid_cache_mongoid
+  store_options:
+    max_age: <%= 60.days.to_i %>
+    max_size: <%= 256.megabytes %>
+    namespace: <%= Rails.env %>
 
-To encrypt the cache values, you can add the encrypt property.
+development:
+  <<: *default
 
-```yaml
-# config/cache.yml
 production:
-  encrypt: true
-```
-or
-```ruby
-# application.rb
-config.solid_cache.encrypt = true
+  <<: *default
 ```
 
-You will need to set up your application to [use Active Record Encryption](https://www.mongodb.com/docs/mongoid/current/security/encryption).
+Top-level options:
 
-Solid Cache by default uses a custom encryptor and message serializer that are optimised for it.
-You can choose your own context properties instead if you prefer:
+| Option | Default | What it does |
+|---|---|---|
+| `database` | `solid_cache_mongoid` | Mongo database holding the cache. |
+| `collection` | `solid_cache_entries` | Collection name. |
+| `client` | — | Mongoid client to use, if not the default one. |
+| `encrypt` | `false` | Encrypt keys and values at rest. |
+| `encryption_context_properties` | `{ deterministic: false }` | Passed to Mongoid encryption. |
+| `size_estimate_samples` | `10_000` | Documents sampled when estimating cache size. |
 
-```ruby
-# application.rb
-config.solid_cache.encryption_context_properties = {
-  deterministic: false
-}
-```
+`store_options` are handed to the cache store itself: `max_age`, `max_size`,
+`max_entries`, `namespace`, `expiry_batch_size`, `expiry_method`,
+`expiry_queue`.
 
-## 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:
+### Encryption at rest
 
-1. Edit the index size in the migration.
-2. Set `max_key_bytesize` on your cache to the new value.
+Setting `encrypt: true` turns on Mongoid field encryption for `key` and
+`value`, keyed from `SOLID_CACHE_KEY_ENCRYPT` or, absent that, the
+application's `secret_key_base`. Encryption is non-deterministic by default:
+the same value encrypts differently each time, so an attacker reading the
+collection cannot tell which entries hold the same content.
 
-## Development
+## How expiry works
 
-Run the tests with `bin/rake test`. By default, these will run against SQLite.
+Expiry is not a cron job. Writes trigger it probabilistically, so the cache
+trims itself in proportion to how hard it is being used and an idle
+application does no work at all.
 
-You can also run the tests against MySQL and PostgreSQL. First start up the databases:
+Each pass asks for three times as many candidates as it intends to delete and
+then randomly samples down to the real count. That is deliberate: with several
+workers expiring concurrently, taking the first N of an ordered list means
+every worker fights over the same documents. Oversampling and choosing at
+random keeps their working sets mostly disjoint.
 
-```shell
-$ docker compose up -d
-```
+Candidates are ordered by `_id`. A BSON `ObjectId` begins with a 4-byte
+timestamp, so `_id` order is creation order — the same property upstream gets
+from an autoincrementing primary key — which means age-based expiry needs no
+index on `created_at`.
 
-Next, setup the database:
+## What is different from upstream Solid Cache
 
-```shell
-$ bin/rails db:setup
-```
+The port is not a search-and-replace of `ApplicationRecord` for a Mongoid
+model. The parts of Solid Cache that lean on SQL semantics had to be rebuilt.
 
+**Locking.** Upstream uses Active Record transactions and database advisory
+locks so concurrent expiry passes do not collide. MongoDB has no advisory
+locks, so this uses [`mongoid-locker`](https://github.com/mongoid/mongoid-locker),
+which takes a document-level lock through `locking_name` and `locked_at`
+fields on the entry itself.
 
-Then run the tests:
+**Binary storage.** Keys and values are `BSON::Binary`, not SQL `BLOB`
+columns, and are unwrapped on read. Serialized cache values are arbitrary
+bytes; letting BSON infer a type would corrupt them.
 
-```shell
-$ bin/rake test
-```
+**Key hashing.** Lookups match on a 64-bit hash of the key, clamped to
+`-(2**63)..(2**63 - 1)` so it fits BSON's `int64`. The index stays small and
+fixed-width regardless of how long the application's cache keys are. The hash
+is also uniformly distributed, which is what makes the sampling below work.
 
-### Testing with multiple Rails versions
+**Row counting.** Upstream estimates how many rows the table holds by
+subtracting the smallest primary key from the largest — cheap and accurate
+with an autoincrementing integer. ObjectIds are not subtractable that way, so
+this port counts documents instead.
 
-Solid Cache relies on [appraisal](https://github.com/thoughtbot/appraisal/tree/main) to test
-multiple Rails versions.
+**Query cache.** `without_query_cache` maps onto `Mongo::QueryCache.uncached`
+rather than Active Record's connection-level query cache.
 
-To run a test for a specific version run:
+**Sharding.** Upstream can spread the cache across several databases through
+`connects_to`. This port runs against a single unmanaged connection.
+Applications that need to shard should shard in MongoDB.
 
-```shell
-bundle exec appraisal rails-7-1 bin/rake test
-```
+## Size estimation
 
-After updating the dependencies in the `Gemfile` please run:
+Storing a `byte_size` per document makes the total cache size estimable
+without scanning the collection:
 
-```shell
-$ bundle
-$ appraisal update
-```
+1. Take the N largest documents by `byte_size` — there is an index for it — and
+   sum them exactly. These are the outliers that would otherwise skew any
+   sample.
+2. Use the smallest of those as a cutoff, and sample the rest through a random
+   window of the `key_hash` range. Because `key_hash` is uniformly distributed
+   and indexed together with `byte_size`, the sum comes straight out of the
+   index.
+3. Scale the sampled sum back up by the sampling fraction and add the outliers.
 
-This ensures that all the Rails versions dependencies are updated.
+The result is an estimate whose cost does not grow with the size of the cache.
 
-## Implementation
+## Batching
 
-Solid Cache is a FIFO (first in, first out) cache. While this is not as efficient as an LRU (least recently used) cache, it is mitigated by the longer cache lifespan.
+`read_multi` and `write_multi` slice their input into batches of 1000, so a
+wide `fetch_multi` costs a handful of round trips instead of one per key.
 
-A FIFO cache is much easier to manage:
-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.
+## Credit
 
-## License
-Solid Cache is licensed under MIT.
+Original Solid Cache by [Donal McBreen](https://github.com/djmb) and 37signals.
+Mongoid port by [Duvan Hernandez](https://github.com/duvanherfi). MIT licensed,
+same as upstream.

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

@@ -21,8 +21,9 @@ module SolidCacheMongoid
     # on key_hash and byte_size so we can grab a sum of the byte_sizes in a range of key_hash directly from that
     # index.
     #
-    # To decide how big the range should be, we use the difference between the smallest and largest database IDs as
-    # an estimate of the number of rows in the table. This should be a good estimate, because we delete rows in ID order
+    # To decide how big the range should be, we need the number of documents in the collection. Upstream Solid Cache
+    # subtracts the smallest primary key from the largest, which is cheap and accurate with an autoincrementing integer.
+    # ObjectIds cannot be subtracted that way, so here Entry.id_range counts the documents instead.
     #
     # We then calculate the fraction of the rows we want to sample by dividing the sample size by the estimated number
     # of rows.
@@ -38,7 +39,7 @@ module SolidCacheMongoid
     #    outliers_cutoff              OC = min(byte_size of N largest rows)
     #    outliers_size                OS = sum(byte_size of N largest rows)
     #
-    #    estimated number of rows     R = max(ID) - min(ID) + 1
+    #    estimated number of rows     R = number of documents in the collection
     #    sample_fraction              F = N / R
     #    sample_range_size            S = (Kmax - Kmin) * F
     #    sample range is              K1..K2 where K1 = Kmin + rand(Kmax - S) and K2 = K1 + S
@@ -80,7 +81,7 @@ module SolidCacheMongoid
             @outlier_size_and_cutoff ||= Entry.uncached do
               largest = Entry.largest_byte_sizes(samples)
 
-              # Usar agregación de MongoDB para calcular sum, count y min
+              # Let MongoDB aggregate the sum, count and min
               if largest.exists?
                 sum = largest.sum(:byte_size)
                 count = largest.count

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

@@ -32,7 +32,7 @@ module SolidCacheMongoid
             value = Entry.read(ESTIMATES_KEY)
             return [] unless value
 
-            # Convertir de BSON::Binary a string si es necesario
+            # Unwrap BSON::Binary into a string when needed
             value_str = value.is_a?(BSON::Binary) ? value.data : value.to_s
             value_str.presence&.split("|")&.map(&:to_i) || []
           end

data/app/models/solid_cache_mongoid/entry.rb

@@ -28,7 +28,7 @@ module SolidCacheMongoid
         without_query_cache do
           payloads.each_slice(MULTI_BATCH_SIZE).each do |payload_batch|
             add_key_hash_and_byte_size(payload_batch).each do |payload|
-              # Convertir key y value a BSON::Binary
+              # Store key and value as BSON::Binary
               key = payload.delete(:key)
               value = payload.delete(:value)
               obj = where(key_hash: payload[:key_hash]).first_or_initialize
@@ -54,7 +54,7 @@ module SolidCacheMongoid
               where(:key_hash.in => key_hashes)
                 .only(:key, :value)
                 .each do |entry|
-                  # Convertir BSON::Binary de vuelta a string
+                  # Unwrap BSON::Binary back into a string
                   key_str = entry.key.data
                   value_str = entry.value.data
                   results[key_str] = value_str

data/app/models/solid_cache_mongoid/record.rb

@@ -42,7 +42,7 @@ module SolidCacheMongoid
             ActiveSupport::Notifications.instrumenter = old
           end
         else
-          # Fallback al comportamiento previo que usaba IsolatedExecutionState
+          # Fall back to the previous behaviour, which used IsolatedExecutionState
           old = ActiveSupport::IsolatedExecutionState[:active_record_instrumenter]
           ActiveSupport::IsolatedExecutionState[:active_record_instrumenter] = instrumenter
           begin
@@ -64,10 +64,10 @@ module SolidCacheMongoid
       alias :cache :with_query_cache
 
       def lease_connection
-        # Obtiene el cliente Mongo actual del modelo
+        # The model's current Mongo client
         client = self.mongo_client
 
-        # Asegura que hay una conexión disponible
+        # Make sure a connection is available
         client.reconnect unless client.cluster.connected?
 
         yield client

data/lib/generators/{solid_cache → solid_cache_mongoid}/install/templates/config/cache.yml.tt

@@ -1,5 +1,5 @@
 default: &default
-  # database: <%= ENV.fetch("SOLID_CACHE_DATABASE", "solid_cache") %>
+  # database: <%= ENV.fetch("SOLID_CACHE_DATABASE", "solid_cache_mongoid") %>
   # collection: solid_cache_entries
   # client: default
   # encrypt: false
@@ -16,5 +16,5 @@ test:
   <<: *default
 
 production:
-  database: <%= ENV.fetch("SOLID_CACHE_DATABASE", "solid_cache") %>
+  database: <%= ENV.fetch("SOLID_CACHE_DATABASE", "solid_cache_mongoid") %>
   <<: *default

data/lib/solid_cache_mongoid/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module SolidCacheMongoid
-  VERSION = "0.1.0"
+  VERSION = "0.2.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: solid_cache_mongoid
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - Donal McBreen
 - Duvan Hernandez
 bindir: bin
 cert_chain: []
-date: 2025-12-12 00:00:00.000000000 Z
+date: 2026-08-31 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: mongoid
@@ -153,13 +153,9 @@ files:
 - app/models/solid_cache_mongoid/entry/size/moving_average_estimate.rb
 - app/models/solid_cache_mongoid/record.rb
 - lib/active_support/cache/solid_cache_mongoid_store.rb
-- lib/generators/solid_cache/install/USAGE
-- lib/generators/solid_cache/install/install_generator.rb
-- lib/generators/solid_cache/install/templates/config/cache.yml.tt
-- lib/generators/solid_cache/install/templates/db/cache_schema.rb
-- lib/generators/solid_cache/install/templates/db/cache_structure.mysql.sql
-- lib/generators/solid_cache/install/templates/db/cache_structure.postgresql.sql
-- lib/generators/solid_cache/install/templates/db/cache_structure.sqlite3.sql
+- lib/generators/solid_cache_mongoid/install/USAGE
+- lib/generators/solid_cache_mongoid/install/install_generator.rb
+- lib/generators/solid_cache_mongoid/install/templates/config/cache.yml.tt
 - lib/solid_cache_mongoid.rb
 - lib/solid_cache_mongoid/configuration.rb
 - lib/solid_cache_mongoid/connections.rb

data/lib/generators/solid_cache/install/templates/db/cache_schema.rb

@@ -1,12 +0,0 @@
-ActiveRecord::Schema[7.2].define(version: 1) do
-  create_table "solid_cache_entries", force: :cascade do |t|
-    t.binary "key", limit: 1024, null: false
-    t.binary "value", limit: 536870912, null: false
-    t.datetime "created_at", null: false
-    t.integer "key_hash", limit: 8, null: false
-    t.integer "byte_size", limit: 4, null: false
-    t.index ["byte_size"], name: "index_solid_cache_entries_on_byte_size"
-    t.index ["key_hash", "byte_size"], name: "index_solid_cache_entries_on_key_hash_and_byte_size"
-    t.index ["key_hash"], name: "index_solid_cache_entries_on_key_hash", unique: true
-  end
-end

data/lib/generators/solid_cache/install/templates/db/cache_structure.mysql.sql

@@ -1,56 +0,0 @@
-
-/*!40101 SET @OLD_CHARACTER_SET_CLIENT=@@CHARACTER_SET_CLIENT */;
-/*!40101 SET @OLD_CHARACTER_SET_RESULTS=@@CHARACTER_SET_RESULTS */;
-/*!40101 SET @OLD_COLLATION_CONNECTION=@@COLLATION_CONNECTION */;
-/*!50503 SET NAMES utf8mb4 */;
-/*!40103 SET @OLD_TIME_ZONE=@@TIME_ZONE */;
-/*!40103 SET TIME_ZONE='+00:00' */;
-/*!40014 SET @OLD_UNIQUE_CHECKS=@@UNIQUE_CHECKS, UNIQUE_CHECKS=0 */;
-/*!40014 SET @OLD_FOREIGN_KEY_CHECKS=@@FOREIGN_KEY_CHECKS, FOREIGN_KEY_CHECKS=0 */;
-/*!40101 SET @OLD_SQL_MODE=@@SQL_MODE, SQL_MODE='NO_AUTO_VALUE_ON_ZERO' */;
-/*!40111 SET @OLD_SQL_NOTES=@@SQL_NOTES, SQL_NOTES=0 */;
-DROP TABLE IF EXISTS `ar_internal_metadata`;
-/*!40101 SET @saved_cs_client     = @@character_set_client */;
-/*!50503 SET character_set_client = utf8mb4 */;
-CREATE TABLE `ar_internal_metadata` (
-  `key` varchar(255) NOT NULL,
-  `value` varchar(255) DEFAULT NULL,
-  `created_at` datetime(6) NOT NULL,
-  `updated_at` datetime(6) NOT NULL,
-  PRIMARY KEY (`key`)
-) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci;
-/*!40101 SET character_set_client = @saved_cs_client */;
-DROP TABLE IF EXISTS `schema_migrations`;
-/*!40101 SET @saved_cs_client     = @@character_set_client */;
-/*!50503 SET character_set_client = utf8mb4 */;
-CREATE TABLE `schema_migrations` (
-  `version` varchar(255) NOT NULL,
-  PRIMARY KEY (`version`)
-) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci;
-/*!40101 SET character_set_client = @saved_cs_client */;
-DROP TABLE IF EXISTS `solid_cache_entries`;
-/*!40101 SET @saved_cs_client     = @@character_set_client */;
-/*!50503 SET character_set_client = utf8mb4 */;
-CREATE TABLE `solid_cache_entries` (
-  `id` bigint NOT NULL AUTO_INCREMENT,
-  `key` varbinary(1024) NOT NULL,
-  `value` longblob NOT NULL,
-  `created_at` datetime(6) NOT NULL,
-  `key_hash` bigint NOT NULL,
-  `byte_size` int NOT NULL,
-  PRIMARY KEY (`id`),
-  UNIQUE KEY `index_solid_cache_entries_on_key_hash` (`key_hash`),
-  KEY `index_solid_cache_entries_on_byte_size` (`byte_size`),
-  KEY `index_solid_cache_entries_on_key_hash_and_byte_size` (`key_hash`,`byte_size`)
-) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci;
-/*!40101 SET character_set_client = @saved_cs_client */;
-/*!40103 SET TIME_ZONE=@OLD_TIME_ZONE */;
-
-/*!40101 SET SQL_MODE=@OLD_SQL_MODE */;
-/*!40014 SET FOREIGN_KEY_CHECKS=@OLD_FOREIGN_KEY_CHECKS */;
-/*!40014 SET UNIQUE_CHECKS=@OLD_UNIQUE_CHECKS */;
-/*!40101 SET CHARACTER_SET_CLIENT=@OLD_CHARACTER_SET_CLIENT */;
-/*!40101 SET CHARACTER_SET_RESULTS=@OLD_CHARACTER_SET_RESULTS */;
-/*!40101 SET COLLATION_CONNECTION=@OLD_COLLATION_CONNECTION */;
-/*!40111 SET SQL_NOTES=@OLD_SQL_NOTES */;
-

data/lib/generators/solid_cache/install/templates/db/cache_structure.postgresql.sql

@@ -1,128 +0,0 @@
-SET statement_timeout = 0;
-SET lock_timeout = 0;
-SET idle_in_transaction_session_timeout = 0;
-SET transaction_timeout = 0;
-SET client_encoding = 'UTF8';
-SET standard_conforming_strings = on;
-SELECT pg_catalog.set_config('search_path', '', false);
-SET check_function_bodies = false;
-SET xmloption = content;
-SET client_min_messages = warning;
-SET row_security = off;
-
-SET default_tablespace = '';
-
-SET default_table_access_method = heap;
-
---
--- Name: ar_internal_metadata; Type: TABLE; Schema: public; Owner: -
---
-
-CREATE TABLE public.ar_internal_metadata (
-    key character varying NOT NULL,
-    value character varying,
-    created_at timestamp(6) without time zone NOT NULL,
-    updated_at timestamp(6) without time zone NOT NULL
-);
-
-
---
--- Name: schema_migrations; Type: TABLE; Schema: public; Owner: -
---
-
-CREATE TABLE public.schema_migrations (
-    version character varying NOT NULL
-);
-
-
---
--- Name: solid_cache_entries; Type: TABLE; Schema: public; Owner: -
---
-
-CREATE TABLE public.solid_cache_entries (
-    id bigint NOT NULL,
-    key bytea NOT NULL,
-    value bytea NOT NULL,
-    created_at timestamp(6) without time zone NOT NULL,
-    key_hash bigint NOT NULL,
-    byte_size integer NOT NULL
-);
-
-
---
--- Name: solid_cache_entries_id_seq; Type: SEQUENCE; Schema: public; Owner: -
---
-
-CREATE SEQUENCE public.solid_cache_entries_id_seq
-    START WITH 1
-    INCREMENT BY 1
-    NO MINVALUE
-    NO MAXVALUE
-    CACHE 1;
-
-
---
--- Name: solid_cache_entries_id_seq; Type: SEQUENCE OWNED BY; Schema: public; Owner: -
---
-
-ALTER SEQUENCE public.solid_cache_entries_id_seq OWNED BY public.solid_cache_entries.id;
-
-
---
--- Name: solid_cache_entries id; Type: DEFAULT; Schema: public; Owner: -
---
-
-ALTER TABLE ONLY public.solid_cache_entries ALTER COLUMN id SET DEFAULT nextval('public.solid_cache_entries_id_seq'::regclass);
-
-
---
--- Name: ar_internal_metadata ar_internal_metadata_pkey; Type: CONSTRAINT; Schema: public; Owner: -
---
-
-ALTER TABLE ONLY public.ar_internal_metadata
-    ADD CONSTRAINT ar_internal_metadata_pkey PRIMARY KEY (key);
-
-
---
--- Name: schema_migrations schema_migrations_pkey; Type: CONSTRAINT; Schema: public; Owner: -
---
-
-ALTER TABLE ONLY public.schema_migrations
-    ADD CONSTRAINT schema_migrations_pkey PRIMARY KEY (version);
-
-
---
--- Name: solid_cache_entries solid_cache_entries_pkey; Type: CONSTRAINT; Schema: public; Owner: -
---
-
-ALTER TABLE ONLY public.solid_cache_entries
-    ADD CONSTRAINT solid_cache_entries_pkey PRIMARY KEY (id);
-
-
---
--- Name: index_solid_cache_entries_on_byte_size; Type: INDEX; Schema: public; Owner: -
---
-
-CREATE INDEX index_solid_cache_entries_on_byte_size ON public.solid_cache_entries USING btree (byte_size);
-
-
---
--- Name: index_solid_cache_entries_on_key_hash; Type: INDEX; Schema: public; Owner: -
---
-
-CREATE UNIQUE INDEX index_solid_cache_entries_on_key_hash ON public.solid_cache_entries USING btree (key_hash);
-
-
---
--- Name: index_solid_cache_entries_on_key_hash_and_byte_size; Type: INDEX; Schema: public; Owner: -
---
-
-CREATE INDEX index_solid_cache_entries_on_key_hash_and_byte_size ON public.solid_cache_entries USING btree (key_hash, byte_size);
-
-
---
--- PostgreSQL database dump complete
---
-
-SET search_path TO "$user", public;
-

data/lib/generators/solid_cache/install/templates/db/cache_structure.sqlite3.sql

@@ -1,6 +0,0 @@
-CREATE TABLE IF NOT EXISTS "schema_migrations" ("version" varchar NOT NULL PRIMARY KEY);
-CREATE TABLE IF NOT EXISTS "ar_internal_metadata" ("key" varchar NOT NULL PRIMARY KEY, "value" varchar, "created_at" datetime(6) NOT NULL, "updated_at" datetime(6) NOT NULL);
-CREATE TABLE IF NOT EXISTS "solid_cache_entries" ("id" integer PRIMARY KEY AUTOINCREMENT NOT NULL, "key" blob(1024) NOT NULL, "value" blob(536870912) NOT NULL, "created_at" datetime(6) NOT NULL, "key_hash" integer(8) NOT NULL, "byte_size" integer(4) NOT NULL);
-CREATE INDEX "index_solid_cache_entries_on_byte_size" ON "solid_cache_entries" ("byte_size");
-CREATE INDEX "index_solid_cache_entries_on_key_hash_and_byte_size" ON "solid_cache_entries" ("key_hash", "byte_size");
-CREATE UNIQUE INDEX "index_solid_cache_entries_on_key_hash" ON "solid_cache_entries" ("key_hash");