nitro_pg_cache 0.1.rc1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 8e8a7e2dcc650c34494a5a2b8a5f701f7ec95023
+  data.tar.gz: 9bd438f3d4f30f738b4d750061585b1e5e821f3c
+SHA512:
+  metadata.gz: 6a4ab1152c2b6f30c8db51491cddd697f223a1c7d443949da17ac0b36e9c30f084a218f2595cc1e0190983a6efa045c29882fe6f4a6a76d01ced16116de20208
+  data.tar.gz: 486d149799dcd32d72d13c43be979848208f232d5843897c78bef8cf6c069b2720814f885ef6d02b0ebb74ce69ed4110436a063de0d22a4a03ff4385cc71c534

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright 2016 alekseyl
+
+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,475 @@
+# ATTENTION
+To use this gem you need PostgreSQL 9.4 and higher!
+
+# ATTENTION(РУС)
+Для корректной работы библиотеки требуется версия PostgreSQL не ниже 9.4!
+
+# NitroPgCache 
+This gem create DB-based solution for caching relation collections. It based on PostgreSQL version >= 9.4 . 
+It faster than memcache+dalli combination. In some cases three times faster, but with all DB facilities! 
+
+Right now nitro_pg_cache is in alpha-release state. It's working, but may need additional tuning and features, for example limits and expiring, 
+actually I don't know which will suit best. 
+
+#                                    FEATURES
+Already working*:
+(* all benchmark numbers are given with pg_cache_key gem enabled, this mean that in rails < 5 or without pg_cache_key, you'll get +25% additional speed bonus for cached collection )
+
+1. First rendering is faster then memcache+dalli on same machine. ~10% faster
+2. Reordering and sub-collection rendering on cached collection are 3 times faster then memcached+dalli** 
+   Rendering are done with DB speed i.e. You can assume that feed rendering speed now are some very small time constant. 100 and 1K records are rendering with
+  ~0.01s difference
+  ( partially rendered subcollection is a superposition of 1.15 and 3 times, depends of non-cached elems amount )
+  ** it's assymptotic value, when collection rendering takes much more time than other rendering parts, 
+      when collection is small and collection rendering is comparable to other page parts rendering you'll get less than 3
+      
+3. You can enable prerendering for any scope of your DB records ( if you has a reasonable amount of different keys|locals sets per db record )
+4. Agile managing of your cache because it's in DB now, you for example don't need to touch elems to remove
+  their cache you can do: NitroCache.where(nitro_cacheable: collection).delete_all
+5. In 4.x rails if you don't use pg_cache_key, but use nitro_cache then you get additional +25% speedup for completly cached feed
+
+Can be done soon
+
+6. Easily can switch back and forth from usual cache to db cache using cache_by key.
+7. Shards DB
+8. auto-renewable cache. we can save locals to jsonb column, after touching cached-element we can rerender
+  all dependent caches with saved locals. Differs from prerender that we don't prerender all possibilities, but only already rendered 
+  ( must check how mass update will suffer from json insert ).
+9. Expiring and quantity limits, cache expiring can be done on different conditions including last time viewed.
+
+# NitroPgCache (РУС)
+Данная библиотека реализует кеширование relation-коллекций на основе движка PostgreSQL последних версий (>=9.4). 
+Получившийся результат по всем показателям скороси не уступает 
+классической схеме memcache+dalli, а во многих случаях и превосходит ее в разы, обладая при этом всеми достоинствами базы данных.
+
+В настоящий момент библиотека находится в состоянии alpha-release. Основной функционал ее работает, но ряд дополнительных возможностей требует реализации. 
+Например ограничения на количество кешей, устаревание кешей и пр. . Если есть какие-то пожелания какие конкретно должны быть возможности связанные с этим: велкам
+
+#                                     ВОЗМОЖНОСТИ БИБЛИОТЕКИ
+
+Реализованные возможности*:
+(* величины указаны при использовании гема pg_cache_key для реализации cache_key у коллекций,
+  поэтому в 4-х рельсах nitro_cache получает еще +25% выигрыша по времени, если pg_cache_key не исопльзуется, даже на полностью кешированной коллекции, см 6) )
+
+1. Первичный рендеринг быстрее чем у memcache+dalli на ~10% для коллекции ( Это малоактуально если рендеринг коллекции занимает
+    менее 50% от рендеринга всей страницы, т.е. выигрыш на всей странице становится ~ 5% )
+2. Пересортировка или рендеринг подколлекций на закешированной матрешкой коллекции в 2-3 и более раз быстрее ( чем больше коллекция тем больше выигрыш )
+3. Возможность пререндеринга для элементов, т.е. при обновлении кешируемого элемента его кеши обновляются автоматом + спец рейк на их первичную генерацию
+  3.a Возможность пререндеринга только для определенного scope элементов.
+4. Управление кешем на уровне БД. Например сброс кешей можно делать без того чтобы трогать объекты: NitroCache.where(nitro_cacheable: collection).delete_all и пр.
+5. В четвертых рельсах, если не использовать gem pg_cache_key дополнительно выигрывает 25% времени от memcached+dalli
+
+Нереализованные пока
+
+6. Можно легко переключать между обычным кешем и бд кешем. используя cache_by ?
+7. БД Шардинг
+8. Авторекеш. Возможно в дальнейшем автоматичечки перекешировывать существующие кеши без использования prerender - true, а с сохранением к каждому
+  ключу еще и Json для локалс.
+9. Устаревание И лимитирование кешей. Может быть реализовано многими способами.
+
+## RESTRICTIONS:
+
+Only clear collections rendering can be cached with this gem. i.e.:
+  Can convert:
+```
+    -cache [@records, locals ] do
+      =render partial: 'record', collection: @records, locals: locals
+```
+  Can't convert ( you will need to split it )
+```    
+    -cache [@records, locals ] do
+      =render partial: 'record', collection: @records, locals: locals
+      =render partial: 'pagination_footer', records: @records
+```
+
+## ОГРАНИЧЕНИЯ:
+
+Только чистый кеш на коллекцию может использоваться с данной библиотекой:
+Может быть сконвертированно:
+```
+    -cache [@records, locals] do
+      =render partial: 'record', collection: @records, locals: locals
+```
+
+Не получится сконвертировать без изменений ( придется разделить коллекцию и футер)
+
+```
+    -cache [@records, locals ] do
+      =render partial: 'record', collection: @records, locals: locals
+      =render partial: 'pagination_footer', records: @records
+```
+
+##                               CACHING ALGORITHMS ( STRAIGHT/REVERSE/ARRAY CACHING )
+
+Three types of caching collection mechanism are used: straight, 'reverse', array-elem
+straight and reverse used for relation objects! array-elem - instantinated array or elem
+
+straight (db_cache_collection_s) - similar to usual cache, we check does every elements already cached, if so we just return aggregation result,
+if not - we just add +1 join on nitro_caches +1 select for nitro_cached_value as virtual attribute,
+ then we render element if nitro_cached_value.nil? or use nitro_cached_value otherwise.
+
+'reverse' (db_cache_collection_r) - is not similar to usual cache algorithms it used 'reversed' logic: we create special SQL-query only for non-cached
+elements, render them, and then we use aggregation on a previously given collection. This special SQL-query use all includes, joins, select which was in original
+query so we successfully escaping N+1 problems same way as usual cache did.
+This approach gives us more speed even on whole noncached collection. How it possible? Less string concatenation, less reallocation e.t.c
+
+array-elem (db_cache_array) - this is method used only with prerender: true for changed record.
+DON'T USE IT ELSEWHERE!! If you have complex hierarchy of models and don't include them on update action of your controller
+it may give you N+1 problem internally.
+
+##                              ВАРИАНТЫ КЕШИРОВАНИЯ ( STRAIGHT/REVERSE/ARRAY CACHING )
+
+Прямой и реверсивный ( straight and reverse ) используются только для relation объектов. array cache используется только если prerender: true
+для измененного элемента. 
+
+Прямое кеширование (db_cache_collection_s): мы классическим образом сначала проверяем что вся коллекция закеширована. Если закеширована - запросом с исолпьзованием str_agg собираем фид
+коллекции на уровне БД. нет - идем последовательно и рендерим, если нет кеша, или подставляем кеш, если он есть.
+
+Реверс кеширование (db_cache_collection_r): Мы делаем дополнительный специальный SQL-запрос, с учетом тех настроек инклюдов джойнов и селектов которые есть в
+полученном relation, но с условием что выбираются только элементы по которым нет кеша. прогоняем по ним рендеринг коллекции.
+и после этого проводим запрос на аггрегацию фида. Данный вариант кеширования оказался быстрее как прямого кеширования, так и обычной связки memcache + dali
+( я думаю из-за того что меньше работы со строками ). 
+
+array-elem (db_cache_array) - Этот метод используется только для prerender=true, только для тех элементов которые изменились.
+НЕ ИСПОЛЬЗУЙТЕ ЕГО НИГДЕ В ДРУГИХ СЛУЧАЯХ! 
+
+
+##                                    BENCHMARK VS MEMCACHE + DALLI
+
+Comparisons were made manually with rack mini-profiler gem +
+I used htop system-monitor to be sure that nothing going in the background and tempering with results
+
+CONFIGURATION: dalli + memcached same machine vs postgres 9.4 same machine 
+VM config:  8 logical cores, Core i7 SSD 10Gb RAM
+
+
+                                         ATTENTION NOTICE:   
+This numbers just a VERY particular case, you can use them to predict your own *comparative* numbers very carefully,
+and of course you can't predict your own time in seconds! 
+But I did it on two completly different tables and their collections and get very closed
+result in percents meaning that numbers are quite representative
+
+first column - records count
+rv - "reverse" cache when we first just render only __missing__ elements and save them to DB, and second aggregate all collection from db
+dbs - data base straight mean it's render's with one straightforward iteration
+mmch - usual matroska doll cache with memcached and dalli
+
+### FIRST RENDER
+
+| Records count | 'Reverse' nitro cache | Straight nitro cache | Memcache | Ratio  |
+|---------------|-----------------------|----------------------|----------|--------|
+|1K | 14.7s | 16s  | 17s | ~1.15 faster |
+|0.38K | 4.9s | 5.2s | 5.6s | |
+|0.1K | 1.3s | 1.4s | 1.5s | ~1.15 faster |
+
+### FIRST RENDER SUBCOLLECTION/REORDERING (i.e. when all elements are cached, but not whole collection)
+
+| Records count | 'Reverse' nitro cache | Memcache | Ratio  |
+|---------------|-----------------------|----------|--------|
+|1K | 0.5s | 1.5s | ~3 times faster |
+|0.38K | 0.35+s |  0.75+ |  ~2 times faster |
+|0.12K | 0.2-0.25 | 0.4-0.5+s |  ~2 times faster |
+
+### PARTIAL COLLECTION RENDERING 
+We can assume this is superposition of already obtained numbers. i.e inside range: 1.15-3
+( the right borders number depends on the collection size, the bigger collection bigger the number )
+
+### GETTING COLLECTION CACHE ( whole collection cached ( nitro wins cause it's not need to instantinate collection ) )
+
+!Notice: Next comparision is valid only for rails <=4.2 without pg_cache_key gem! 
+In rails >= 5 or with pg_cache_key gem it will bring nearly same result i.e. ratio will be 1!
+
+| Records count | 'Reverse' nitro cache | Memcache | Ratio  |
+|---------------|-----------------------|----------|--------|
+|1K   | 0.5s | 1s  | ~2 times faster |
+|0.38K | 0.35+s  | 0.6 | ~1.7 times faster |
+|0.12K  | 0.2-0.25 | 0.38s | ~1.7 times faster |
+
+
+##                                    СРАВНЕНИЕ С MEMCACHE + DALLI
+
+Сравнения провел вручную на живых страницах с исопльзованием rack mini-profiler gem. 
+Используя htop, следил, чтобы ничего не загружало систему дополнительно и портило результаты.
+
+Настройки виртуалки: dalli + memcached vs postgres 9.4 ( ~ 8 логических ядер + 10Gb, реальная машина Core i7 SSD 16Gb RAM)
+
+                                        ВНИМАНИЕ:   
+
+Полученные результаты это конкретный случай, их нельзя использовать для того чтобы предстказать ваш результат в секундах, 
+НО с определенной осторожностью можно предсказать относительные значения. Я прогонял тест на двух совершенно разных 
+таблицах/коллекциях и сравнительные значения были примерно одинаковые.
+
+Расшифровка таблицы: 
+first column - Количество записей из таблицы
+rv - (reverse) время потраченное при реверсивном кешировании/рендеринге 
+dbs - (data base straight) кеширование/рендеринг осуществляется в один прямой проход
+mmch - (memcache) обычный матрешный кеш memcached + dalli
+
+### Первичный рендеринг
+
+| Records count | 'Reverse' nitro cache | Straight nitro cache | Memcache | Ratio  |
+|---------------|-----------------------|----------------------|----------|--------|
+|1K | 14.7s | 16s  | 17s | ~1.15 faster |
+|0.38K | 4.9s | 5.2s | 5.6s | |
+|0.1K | 1.3s | 1.4s | 1.5s | ~1.15 faster |
+
+### Первичный рендеринг на подколлекцию или со сменой порядка (т.е. все отдельные элементы уже закешированы, но не вся коллекция)
+
+| Records count | 'Reverse' nitro cache | Memcache | Ratio  |
+|---------------|-----------------------|----------|--------|
+|1K | 0.5s | 1.5s | ~3 times faster |
+|0.38K | 0.35+s |  0.75+ |  ~2 times faster |
+|0.12K | 0.2-0.25 | 0.4-0.5+s |  ~2 times faster |
+
+### Частично закешированая коллекция
+Можно точно предположить что время/быстродействие будет суперпозицией от первых двух результатов и будет лежать в пределах 1.15-3
+
+### Получение полного кеша коллекции ( только для рельс < 5 )
+
+Обращаю внимание что в связи с отличием в получение cache_key на коллекции между rails 4.2 и rails 5 
+Данные цифры актуальны только для старых версий рельс без использования моего гема pg_cache_key
+В противному случае результаты будут примерно одинаковые!!
+
+| Records count | 'Reverse' nitro cache | Memcache | Ratio  |
+|---------------|-----------------------|----------|--------|
+|1K   | 0.5s | 1s  | ~2 times faster |
+|0.38K | 0.35+s  | 0.6 | ~1.7 times faster |
+|0.12K  | 0.2-0.25 | 0.38s | ~1.7 times faster |
+
+##                                     MEMORY USAGE
+
+I didn't make a special comparision, but I assume that there is a insufficient difference between usual cache and pg_cache.
+
+
+##                                     ИСПОЛЬЗОВАНИЕ ПАМЯТИ
+
+Объем используемой памяти примерно одинаковый и может зависеть от того какой конкретно пришел запрос, сколько в нем уже
+закешированных элементов сколько новых и пр.
+
+
+##                                           GENERAL FALLBACK
+With any variant of prerender true/false all not found caches get themselves cached usual way as in prerender-false case. i.e. as usual cache will do.
+
+##                                           ОСНОВНОЕ ПОВЕДЕНИЕ ПО УМОЛЧАНИЮ
+Независимо от того стоит prerender-true или нет, если на момент запроса значение nitro_cache_value пустое,
+то кеширование запускается обычным ходом, который совпадает, с вариантом когда prerender-false.
+
+
+##                                HOW IT BEHAVE WHEN SOMETHING CHANGES ( KEYS, PARTIALS, ETC )
+The main rule of thumb: no prerendering at server start, only mass cleaning old and creating new nitro_partial records!
+If you are using prerender, then run rake task prerender in parallel manually or by any automation script
+The rules of cache changes are depended on prerender state of partial true|false
+
+*Object changes:*
+
+1. prerender-true => after_commit -> render all locals variants
+2. prerender-false => after_commit -> clear all caches
+
+*Cache params changes:*
+
+1. New keys added.
+  prerender true => rails started as usual, you run prerender rake manually!!,
+  prerender false => do nothing! Everything will be rendered on demand!
+
+2. Keys were removed => nitro_partial.db_cached_partials.where.not( nitro_partial.cache_keys.keys ).delete_all at rails start.
+
+3. New partial
+ + the new nitro_partial record would be added to DB at rails start if we use prerender or at first render otherwise
+    all prerendering only in rake!
+4. Partial changed.
+ + remove all obsolete keys from DB at rails start
+5. Removing partial. all obsolete cache keys will be deleted at application start
+6. Prerender -> toggle
+    + true -> false => do_nothing
+    + false -> true => manually run rake :nitro_prerender to prerender those who don't exists.
+7. partial naming changes.
+    + it's possible to create rake rename_nitro_partial but right now you just rename your partial -
+   loose all rendered cache pieces and rerender them as if you create new one.
+   Also it's possible to change cache key mechanism generation and use not the file name, but file content
+   hash_key, then any renaming and moving of a file will not affect any cached values. Now it's not the point.
+8. When expiration params changes При изменении параметров устаревания, проверяем в rake :expire_db_nitro_cache который можно в кронджобы вписать.
+  все кеши на соответствие новым правилам. Ненужное удаляем.
+
+##                        ПРАВИЛА ИЗМНЕНИЯ КЕША, ЕСЛИ ЧТО_ТО ПОМЕНЯЛОСЬ (РУС)
+Главное правило: никакого пререндеринга на старте сервера иначе у деплоя развяжется пупок.
+На старте только: массовое удаление устаревшего, создание новых записей nitro_partial для новых паршиалов.
+Правила поведения кеша при изменениях ( поведение зависит от значения prerender - true|false)
+*При изменении объекта:*
+
+  1. prerender-true => after_commit -> render all variants
+  2. prerender-false => after_commit -> clear, view on demand -> render and mass save
+
+*При изменении параметров кеша:*
+
+  1. Добавились новые ключи.
+      true => рельсы стартуют без дополнительного пререндеринга, параллельно запускаем rake :nitro_prerender,
+      false => do nothing! Ключей не было, значений не было, все будет генериться по первому требованию
+  2. Удалились ключи true/false => nitro_partial.db_cached_partials.where.not( nitro_partial.keys ).delete_all на старте приложения можно.
+    + Если уже сгенеренные значения не важны то можно просто переписать код, кеши для не найденных файлов будут удалены,
+        новые можно прерндернуть соответствующим рейком
+  3. При изменении параметров устаревания, проверяем в rake :expire_db_nitro_cache который можно в кронджобы вписать.
+      все кеши на соответствие новым правилам. Ненужное удаляем.
+
+##                                           PARTIAL PRERENDER
+
+Since nitro_pg_cache works as usual cache* also we can prerender only for part of keys and part of records, only most wanted.
+
+For example I have feed different for admin and user, but since admin can wait more and also looks at the feed not
+very often. So I can set for prerender locals: { role: [User] }, instead of locals: { role: [User, Admin] }
+and get twice less prerendered caches.
+
+Another example: we have a long history of payments but actual need is only for a last year for example,
+so we can set prerender scope with condition on :created_at column, and prerender only a last year records.
+
+*see section LIMITATIONS for more details on the possibilities of replacing usual feed cache with nitro
+
+##                                          ЧАСТИЧНЫЙ ПРЕРЕНДЕРИНГ
+В силу того что nitro_cache может работать практически как обычный матрешный кеш* мы можем включить пререндеринг только для части
+ключей и части записей.
+
+Например у меня разное отображение ленты для админа и для пользователя. Админ пользуется лентой нечасто и в целом может
+подождать на полсекунды дольше. ТО в параметрах пререндеринга можно написать locals: { role: [User] }, вместо locals: { role: [User, Admin] }
+и пререндрить вполовину меньше вариантов для записи.
+
+Второй пример: мы ведем длинную историю оплат пользователей, но для работы бухов нужен последний квартал или там год
+мы можем выставить scope для пререндеринга по :created_at и пререрндерить только нужные записи.
+
+##                                         EXPIRING
+Right now all cache get timestamp for the last access ( :viewed_at ) so it possible to control cache expiration on time basis
+
+##                                        УСТАРЕВАНИЕ
+Сейчас все ключи хранят штамп времени последнего просмотра поэтому можно легко реализовать устаревающий кеш. например как рейк + крон-джоб
+
+
+##                              STRAIGHT VS REVERSE VS CLASSIC POSSIBLE PROBLEMS
+1. DB Sharding for reverse-cache. If we use db sharding reverse-cache may need additional tuning and testing since it's doing its job
+  in two steps. Straight-cache will work anyway.
+2. Exotic cases for any variant of pg_cache. If we render same collection twice with different partial inside one controller action ( it's quite unusual behaviour ),
+   than we may instatinate collection twice.
+
+##                              STRAIGHT VS REVERSE VS CLASSIC ВЕРОЯТНЫЕ ПРОБЛЕМЫ
+1. БД-шардинг при обратном кешировании. Если мы используем БД шардинг, то вариант реверс кеширования требует доработки, потому что мы должны спрашивать
+   аггрегацию сразу же после того как сделали апдейт, поэтому по идее это должно идти на мастер-шард.
+2. Экзотические варинты многоразового рендеринга с разными паршиалами одной коллекции в одном методе контроллера. Тогда может быть многоразовая инстантинация
+   на первом рендеринге.
+
+
+                                NitroPartial STRUCTURE AND SPECS
+1. В БД паршиалы уникальны по относительным путям
+2. Параметры специфические для паршиала ( сколько хранить записей и когда экспайрить, можно задавать прямо в рендер )
+2. При загрузке мы все паршиалы из БД всасываем в хеш partials_cache = { path: Partial }, проверяем наличие файлов,
+    если какого-то нет - вычищаем БД от его записей.
+3.  Проверяем что хеши на контент файлов не поменялись, для всех которые поменялись - удаляем кеш-записи
+4.  При запросе объекта Partial по путю из partials_cache в случае отсутствия оного - он сначала заправшивается в БД
+    ( это случай когда он параллельно был создан в соседнем процессе ) и если такого нет создается новый.
+
+
+## Usage
+
+### As cache replacement
+Replace:
+
+```ruby
+ -cache [@requests] do
+   =render partial: "admins/requests/request", collection: @requests, cached: true
+```
+
+with:
+```ruby
+ =db_cache_collection( collection: @requests, partial: "admins/requests/request.html.slim", as: :request, locals: {} )
+```
+
+inside request.html.slim replace:
+
+```ruby
+ -cache[request] do
+```
+
+with:
+```ruby
+ -db_cache(request) do
+```
+
+and inside your model:
+
+```ruby
+class Request < ActiveRecord::Base
+ acts_as_nitro_cacheable    
+end
+```
+
+### Prerender
+
+If you want to use prerender model will look like:
+
+```ruby
+class Request < ActiveRecord::Base
+ acts_as_nitro_cacheable    
+ add_prerender_partial( partial: "admins/requests/request.html.slim",
+                      all_locals: {},
+                      as: :request,
+                      scope: Request.except_created.with_deleted.where(created_at: -6.month.from_now..Time.now ) )
+end
+```
+
+
+## Installation
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'nitro_pg_cache'
+```
+
+And then execute:
+```bash
+$ bundle install
+```
+
+Or install it yourself as:
+```bash
+$ gem install nitro_pg_cache
+```
+
+```bash
+$ rake nitro_pg_cache:install:migrations
+$ rake db:migrate
+```
+
+## Contributing
+Issues and PR are welcome.
+
+## TODO
+  0. Нужно config в рельсах приделать. по аналогии с конфигом для дали например.
+
+  1. выписать какие из вариантов для пререндеринга не прошли пользовательского тестирования, проверить работу с комбинациями ключей
+  2. Обновление прогресса для rake db_cache по количеству записей, а не по уникальным ключам шаги.
+      Вариант: вынести получение незакешированной части коллекции в отдельный метод, получить общее количество незакешированных элементов,
+              переопределить рядом в рейке db_cache с вызовом inc на прогресс внутри.
+  3. устаревание expires?
+  4. Общие лимиты. можно устанавливать через конфиг на всех и на отдельные паршиалы следить
+     за переполнением можно в кронджобах
+  5. rspec (!!) Для целей тестирования достаточно переопределить ф-ию аггрегации и можно тестировать на sqlite :memory, т.е. в принципе замокать ее в спеках,
+ остальное должно работать везде. + замокать cashe_keys возможно придется также ( если не сработает: https://sqlite.org/json1.html )
+
+
+## Possibilities for the future
+Возможные направления для дальнейшей оптимизации рендеринга коллекций:
+
+1. паралельный рендеринг коллекции неоткешированных элементов, в силу того что нам не надо морочить голову с очерендностью рендеринга,
+можно параллельно отрендерить N подколлекций и бабахнуть это на БД одним запросом, скорее всего GIL не должен
+мешать потому что они не пересекаются и пр. 
+
+Актуально если мы не можем использовать prerender ( например у нас комбинаций ключей получается оч много ) НО почти неактуально, если мы используем пререндер.
+
+Также возможно: автоматическое получение параметров с которых начинает иметь смысл параллелить
+
+2. Еще одна возможность разгона рельсового приложения с получением коллекций: nginx-sql модуль. Имеет смыссл если коллекция будет получаться
+отдельным запросом.
+
+3. Настраиваемый размер коллекции при которой происходит переключение между дополнительным кешированием всей коллекции или же остаемся в рамках запроса на склейку строк. 
+   Сейчас сделан выбор в пользу оптимизации больших коллекций т.е. делается еще дополнительные запросы в БД, что дает нам еще
+   большую скорость на уже закешированных больших коллекциях, но на маленьких будет наверняка дороже чем сразу склеить результат. 
+
+
+## License
+The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,37 @@
+begin
+  require 'bundler/setup'
+rescue LoadError
+  puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
+end
+
+require 'rdoc/task'
+
+RDoc::Task.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'NitroPgCache'
+  rdoc.options << '--line-numbers'
+  rdoc.rdoc_files.include('README.md')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+APP_RAKEFILE = File.expand_path("../test/dummy/Rakefile", __FILE__)
+load 'rails/tasks/engine.rake'
+
+
+load 'rails/tasks/statistics.rake'
+
+
+
+require 'bundler/gem_tasks'
+
+require 'rake/testtask'
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'lib'
+  t.libs << 'test'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = false
+end
+
+
+task default: :test

data/config/initializers/inflections.rb

@@ -0,0 +1,3 @@
+ActiveSupport::Inflector.inflections(:en) do |inflect|
+  inflect.irregular 'cache', 'caches'
+end

data/db/migrate/1_add_nitro_cache_tables.rb

@@ -0,0 +1,33 @@
+ class AddNitroCacheTables < ActiveRecord::Migration
+  def change
+    create_table :nitro_caches do |t|
+      t.text :key
+      t.text :nitro_cached_value
+
+      t.references :nitro_cacheable, polymorphic: true, index: { name: :index_nitro_cacheable_relations }
+      t.references :nitro_partial, index: true
+
+      # we don't need index here IF we never expire cache! also
+      # since we use cron job to remove expired indexes, when index starts to cost lot we may omit
+      t.datetime :viewed_at, index: true
+    end
+
+    add_index :nitro_caches, [:nitro_cacheable_id, :nitro_cacheable_type, :key], name: :merged_nitro_cacheable_index, unique: true
+    add_index :nitro_caches, :nitro_cache_key, where: 'nitro_cacheable_id = NULL AND nitro_cacheable_type = NULL'
+
+    create_table :nitro_partials do |t|
+      t.text :partial, index: true
+      t.boolean :prerender
+      t.string :expires
+      t.integer :record_limit, limit: 8
+      t.string :partial_hash, index: true
+      t.string :render_as
+      t.column :cache_keys, :jsonb, default: {},  null: false
+
+      t.timestamps null: false
+    end
+
+    add_index :nitro_partials, :cache_keys, using: :gin
+
+  end
+end

data/lib/models/nitro_cache.rb

@@ -0,0 +1,24 @@
+# == Schema Information
+#
+# Table name: nitro_caches
+#
+#  id                   :integer          not null, primary key
+#  nitro_cache_key      :text
+#  nitro_cached_value   :text
+#  nitro_cacheable_id   :integer
+#  nitro_cacheable_type :string
+#  nitro_partial_id     :integer
+#  viewed_at            :datetime
+#
+# Indexes
+#
+#  index_db_cache_partials_relations      (nitro_cacheable_type,nitro_cacheable_id)
+#  index_nitro_caches_on_nitro_cache_key  (nitro_cache_key)
+#  index_nitro_caches_on_viewed_at        (viewed_at)
+#  merged_nitro_cacheable_index              (nitro_cacheable_id,nitro_cacheable_type,nitro_cache_key) UNIQUE
+#
+
+class NitroCache < ActiveRecord::Base
+  belongs_to :nitro_cacheable, polymorphic: true
+  belongs_to :nitro_partial
+end

data/lib/models/nitro_partial.rb

@@ -0,0 +1,184 @@
+# == Schema Information
+#
+# Table name: nitro_partials
+#
+#  id           :integer          not null, primary key
+#  partial      :text
+#  prerender    :boolean
+#  expires      :string
+#  record_limit :integer
+#  partial_hash :string
+#  cache_keys   :jsonb            default({}), not null
+#  created_at   :datetime         not null
+#  updated_at   :datetime         not null
+#  render_as    :string
+#
+# Indexes
+#
+#  index_nitro_partials_on_cache_keys    (cache_keys)
+#  index_nitro_partials_on_partial       (partial)
+#  index_nitro_partials_on_partial_hash  (partial_hash)
+#
+
+# cache_keys has very special structure:
+# { locals: { some_keys_combination } } then hash stored in cache_keys column will have this structure:
+# { some_keys_combination.to_nitro_cache_key => some_keys_combination } assuming this:
+# cache_keys.keys is the Array of all cache_keys for selected partial.
+#
+#
+class NitroPartial < ActiveRecord::Base
+  PRERENDER_BATCH = 1000
+  EXPIRES_REGEX = /^\d+\.(day|days|week|weeks|month|months|year|years)\.from_now$/
+
+  has_many :nitro_caches, dependent: :delete_all
+  @@partials_cache = nil
+  @@partials_scopes = {}
+
+  scope :prerender, ->() { where(prerender: true) }
+
+  class << self
+
+    # вытягивает из БД все в переменную класса, чтобы лишний раз не вставать. в процессе этого проверяет не поменялось
+    # ли что-нибудь внутри файлов
+    def partials_cache
+      if @@partials_cache.nil?
+        all.each do |cp|
+          # file was removed
+          if File.exist?("#{Rails.root}/#{cp.partial_path}")
+            # file hash changed
+            if cp.partial_cache_invalid?
+              # we are not update_caches even in prerender. cache updates in special rake
+              cp.remove_caches
+              cp.update_attributes( partial_hash: partial_hash(cp.partial) )
+            end
+          else
+            cp.destroy
+          end
+        end
+      end
+
+      @@partials_cache ||= all.reload.map{ |cp| [cp.partial, cp] }.to_h
+    end
+
+    # scopes for prerender
+    def partials_scopes
+      @@partials_scopes
+    end
+
+    def all_key_combinations( all_locals, partial )
+      return { {partial: partial}.to_nitro_cache_key => {} } if all_locals.blank?
+      # Example for code below:
+      # locals = {:role=>[:user, :admin], :public=>[true, false]}
+      #
+      # transforms into 4 combinations of possible keys:
+      #
+      # key_combinations = [{:public=>true, :role=>:user},
+      #                     {:public=>true, :role=>:admin},
+      #                     {:public=>false, :role=>:user},
+      #                     {:public=>false, :role=>:admin}]
+      #
+      # i.e. we can now do
+      # key_combinations.each do |kc|
+      #    render partial: partial, locals: { record_as: record_as }.merge!( kc )  }
+      # end
+      key_combinations = all_locals.keys.map{|key| (all_locals[key].is_a?(Array) ? all_locals[key]: [all_locals[key]]).map{|val| { key => val } }  }
+      key_combinations = key_combinations.pop.product(*key_combinations)
+      key_combinations.map!{|key_arr| key_arr.inject({}){|memo, curr| memo.merge(curr) } }
+      key_combinations.map{|locals_set| [locals_set.merge(partial: partial).to_nitro_cache_key, locals_set ]}.to_h
+    end
+
+    # prerender will not start with rails, because it may need large amount of time
+    def add_prerendered_partial( options )
+      existing_partial = partials_cache[options[:partial]] || where( partial: options[:partial] ).first
+      key_combinations = options[:key_combinations] || all_key_combinations( options[:all_locals], options[:partial] )
+      partials_scopes[options[:partial]] = options[:scope]
+
+      raise( ArgumentError, 'expires params must be in form: N.(day[s]|week[s]|month[s]|year[s]).from_now' ) if !options[:expires].blank? || EXPIRES_REGEX === options[:expires].to_s
+      raise( ArgumentError, 'must have scope for prerendering' ) unless options[:scope]
+
+      if existing_partial
+        # all non existed now key combination will be deleted
+        existing_partial.nitro_caches.where.not( nitro_cache_key: key_combinations.keys ).delete_all
+
+        existing_partial.update_attributes(
+            render_as: options[:as],
+            cache_keys: key_combinations,
+            expires: options[:expires].to_s,
+            prerender: true )
+
+        existing_partial
+      else
+        partials_cache[options[:partial]] = create(
+            cache_keys: key_combinations,
+            expires: options[:expires].to_s,
+            prerender: true,
+            render_as: options[:as],
+            partial: options[:partial],
+            partial_hash: partial_hash( options[:partial] ) )
+      end
+
+    end
+
+    # получить паршиал или создать ( для обычных кешей без пререндеринга, для пререндеринга, надо вызывать
+    # add_prerendered_partial в модели которой пререндеринг прикрепляется )
+    def get_partial( partial_name, options )
+      # we need where first because rails can be run in parallels so it could be created already elsewhere
+      partials_cache[partial_name] ||= where( partial: partial_name ).first || create( options.with_indifferent_access
+                                                 .merge(
+                                                     partial: partial_name,
+                                                     render_as: options[:as],
+                                                     partial_hash: partial_hash( partial_name ) )
+                                                 .slice(*NitroPartial.column_names) )
+    end
+
+    def partial_hash( partial )
+      Digest::SHA512.file( "#{Rails.root}/#{partial_path(partial)}" ).hexdigest
+    end
+
+
+    def partial_path(partial)
+      # extract partial file name
+      rg = /[^\/]*$/
+      "app/views/#{partial.gsub( partial[rg], "_#{partial[rg]}" )}"
+    end
+
+  end
+
+  def get_scope
+    self.class.partials_scopes[partial]
+  end
+
+  # append_view_path
+  def partial_cache_invalid?
+    self.class.partial_hash(partial) != partial_hash
+  end
+
+  def remove_caches
+    nitro_caches.delete_all
+  end
+
+  def update_caches( progress = nil )
+    (get_scope.count/PRERENDER_BATCH + 1).times do |i|
+      update_cache_for_collection( get_scope.limit(PRERENDER_BATCH).offset(i*PRERENDER_BATCH), progress )
+    end
+  end
+
+  def update_cache_for_collection( collection, progress = nil )
+    cache_keys.values.each do |locals|
+      progress.try(:inc)
+      ApplicationController.render( assigns: {
+                                        locals: locals,
+                                        partial: partial,
+                                        render_as: render_as,
+                                        rel: collection },
+                                    inline: '<% db_cache_collection( straight_cache: false, collection: @rel, partial: @partial, as: @render_as, locals: @locals )%>' )
+    end
+  end
+
+  def partial_path
+    self.class.partial_path(partial)
+  end
+
+  #на старте системы сохраняем все кеши в локальную структуру.
+  partials_cache
+end

data/lib/nitro_pg_cache.rb

@@ -0,0 +1,24 @@
+require 'nitro_pg_cache/engine'
+
+require 'nitro_pg_cache/model_ext'
+require 'nitro_pg_cache/viewer_ext'
+require 'nitro_pg_cache/acts_as_nitro_cacheable'
+
+ActiveSupport.on_load(:active_record) do
+  extend NitroPgCache::NitroCacheable # adds act_as_nitro_cachable
+end
+
+ActiveSupport.on_load(:action_view) do
+  include NitroPgCache::ViewerExt
+end
+
+class Hash
+  # little lazy hackery, retrieve_cache_key - private, so technically it's wrong, but why the heck it's private?
+  # retrieve_cache_key doesn't respect order so I force key sorting
+  def to_nitro_cache_key
+    "#{self[:partial]}_#{ActiveSupport::Cache.send( :retrieve_cache_key, self[:cache_by] )}_#{ self[:locals] && self[:locals].keys.sort.map{|key| ActiveSupport::Cache.send( :retrieve_cache_key, self[:locals][key] ) }.join("_")}"
+  end
+end
+
+require_dependency 'models/nitro_cache'
+require_dependency 'models/nitro_partial'

data/lib/nitro_pg_cache/acts_as_nitro_cacheable.rb

@@ -0,0 +1,8 @@
+module NitroPgCache
+  module NitroCacheable
+    def acts_as_nitro_cacheable
+      include NitroPgCache::ModelExt
+      has_many :nitro_caches, as: :nitro_cacheable
+    end
+  end
+end

data/lib/nitro_pg_cache/engine.rb

@@ -0,0 +1,5 @@
+module NitroPgCache
+  class Engine < ::Rails::Engine
+    #isolate_namespace NitroPgCache
+  end
+end

data/lib/nitro_pg_cache/model_ext.rb

@@ -0,0 +1,90 @@
+module NitroPgCache
+  module ModelExt
+    extend ActiveSupport::Concern
+
+    included do
+      #
+      after_save  :clear_nitro_cache
+      after_touch :clear_nitro_cache
+
+    end
+
+    module ClassMethods
+      # since it will be wrapped in scoping we can implement it as model class method not the relation methods
+      def aggregate_collection(locals_key)
+        # we can't use NitroCache.where( nitro_cache_key: nitro_cache_key, nitro_cacheable: self )
+        # because we will lose collection order!
+        # why use connection.execute instead of doing self.select also because of an order. if you using some order on your scope
+        # than columns you using to order must appear in the GROUP BY clause or be used in an aggregate function or you will get an error
+        connection.execute( <<AGGREGATE_STR
+          SELECT string_agg( nitro_cached_value, '') as str_agg,
+                 bool_or( nitro_cached_value is null ) as has_nulls
+            FROM (#{self.select_nitro_cache.outer_join_partials(locals_key).to_sql}) as db_cache
+AGGREGATE_STR
+        )[0]
+      end
+
+      def select_all_if_empty
+        all.select_values.blank? ? select( "#{table_name}.*" ) : all
+      end
+
+      def nitro_cache_bulk_insert( options )
+        return if options[:caches].blank?
+        # "nitro_cache_key", "nitro_cacheable_type", "viewed_at" - all same for entire collection
+        last_tail = "'#{options[:nitro_cache_key]}', '#{self}', '#{Time.now}', '#{options[:nitro_partial_id]}'"
+        tail = ", #{last_tail} ), ("
+        # this is practically Values String without last tail and external enclosing brackets
+        values = options[:caches].map{ |id_value| "#{id_value[0]}, $$#{id_value[1]}$$" }.join( tail )
+        sql = <<INSERT
+        INSERT INTO nitro_caches ("nitro_cacheable_id", "nitro_cached_value", "nitro_cache_key", "nitro_cacheable_type", "viewed_at", "nitro_partial_id")
+        VALUES ( #{values}, #{last_tail}  )
+        ON CONFLICT (nitro_cacheable_id, nitro_cacheable_type, nitro_cache_key)
+        DO UPDATE SET nitro_cached_value = EXCLUDED.nitro_cached_value
+INSERT
+        ActiveRecord::Base.connection.execute( sql )
+      end
+
+      def select_nitro_cache
+        select( ['nitro_caches.nitro_cached_value as nitro_cached_value'] )
+      end
+
+      #prepare for aggregation
+      def outer_join_partials(cache_key)
+        joins(<<JOIN
+              LEFT OUTER JOIN "nitro_caches"
+                   ON "nitro_caches"."nitro_cacheable_id" = "#{table_name}"."id"
+                   AND "nitro_caches"."nitro_cacheable_type" = '#{base_class.to_s}'
+                   AND "nitro_caches"."nitro_cache_key" = '#{cache_key}'
+JOIN
+        )
+      end
+
+      # add partial to prendering
+      # options: { partial: , all_locals:, record_as: , partial: , scope:  }
+      # partial: path to partial from Rails.root
+      # all_locals: array of hashes of possible cache_keys|locals_name, {locals_name: [value1, value2], locals_name: [ value3, value4 ]}  see example below
+      # prerender: true/false, flag that indicates does or doesn't this partial will be prerendered when a record changes, it's
+      # expires: [/^\d+\.(day|days|week|weeks|month|months|year|years)\.from_now$/] as string N.(day[s]|week[s]|month[s]|year[s]).from_now
+      # record_as: :symbol , if we prerendering than we pass locals
+      # scope: scope wich is used for prerendering purpose, you may want to add some includes to it, same as includes in your controller action
+      #
+      # Example:
+      # prerender_cache_partial(
+      #   partial: 'app/views/products/product'
+      #   locals: {:role=>[:user, :admin], :public=>[true, false]},
+      #   scope: Model.where(created_at: -6.month.from_now..Time.now)
+      # )
+      #todo перед eval(expires) все равно сделать проверку. а то иначе можно положить исполняемую строку в БД и потом вынудить исполнится на прогоне )
+
+      def add_prerender_partial(options)
+        p_partial = NitroPartial.add_prerendered_partial( { scope: all }.merge(options) )
+        after_commit { p_partial.update_cache_for_collection([self]) }
+      end
+
+    end
+
+    def clear_nitro_cache
+      NitroCache.where(nitro_cacheable: self).delete_all
+    end
+  end
+end

data/lib/nitro_pg_cache/version.rb

@@ -0,0 +1,3 @@
+module NitroPgCache
+  VERSION = '0.1.rc1'
+end

data/lib/nitro_pg_cache/viewer_ext.rb

@@ -0,0 +1,164 @@
+module NitroPgCache
+  module ViewerExt
+    def db_cache( item )
+      if @current_cache_aggregator[:reverse] || !item.try(:nitro_cached_value)
+        @current_cache_aggregator[:caches] << [item.id, yield]
+      else
+        safe_concat( item.nitro_cached_value )
+      end
+    end
+
+    # I decided to keep both solutions reverse and straight. reverse is faster,
+    # but straight is more srtaightforward :) and may be more stable, especially with DB sharding
+    # also when using prerendering speed is the same and stability is preferable
+    def db_cache_collection(options)
+
+      if options[:collection].is_a?(ActiveRecord::Relation)
+
+        whole_cache_key = options[:collection].try(:cache_key)
+        cached_result = NitroCache.where( nitro_cache_key: whole_cache_key, nitro_cacheable_id: nil, nitro_cacheable_type: nil).first
+
+        if cached_result
+          cached_result.update_attributes(viewed_at: Time.now)
+          return cached_result.try(:nitro_cached_value).try(:html_safe)
+        end
+
+        render_result = options[:straight_cache] ? db_cache_collection_s( options ) : db_cache_collection_r( options )
+
+        # why not NitroCache.create( nitro_cached_value: render_result, nitro_cache_key: whole_cache_key, nitro_cacheable_id: nil, nitro_cacheable_type: nil) &
+        # because on large collections raw insert is 1.2 faster, i.e. same speed as memcache.
+        NitroCache.connection.execute( <<INSERT_STR
+          INSERT INTO "nitro_caches" ("nitro_cached_value", "nitro_cache_key", "nitro_partial_id", "viewed_at" )
+           VALUES ('#{render_result}', '#{whole_cache_key}', '#{@current_cache_aggregator[:nitro_partial_id]}', '#{Time.now}')
+INSERT_STR
+        )
+        render_result
+      else
+        db_cache_array( options )
+      end
+    end
+
+    # It's used ONLY for prerender purpose of single element collection: [elem]
+    def db_cache_array( options )
+      collection = options[:collection]
+      # nitro_cache_key - same across all collection
+      nitro_cache_key = options.to_nitro_cache_key
+
+      # this is place where NitroPartial creates new partials info in DB
+      @current_cache_aggregator = { nitro_partial_id: NitroPartial.get_partial( options[:partial], options ).id,
+                                    nitro_cache_key: nitro_cache_key,
+                                    reverse: false,
+                                    caches: [] }
+
+      result = render( partial: options[:partial],
+                       collection: collection,
+                       as: options[:as],
+                       locals: {
+                           locals: options[:locals]
+                       }
+      )
+      (collection.try(:first) ? collection.try(:first).class : collection.klass).nitro_cache_bulk_insert( @current_cache_aggregator )
+
+      NitroCache.where( nitro_cacheable: collection, nitro_cache_key: nitro_cache_key ).update_all(viewed_at: Time.now)
+      result
+    end
+
+    # cache_key generated with cache_by and locals
+    # straight cache. same logic as usual cache.
+    def db_cache_collection_s( options )
+      collection = options[:collection]
+      # nitro_cache_key - same across all collection
+      nitro_cache_key = options.to_nitro_cache_key
+      result = ""
+
+      aggr_result = collection.aggregate_collection( nitro_cache_key )
+      if aggr_result['has_nulls'] == 't'
+        # this is place where NitroPartial creates new partials info in DB
+        @current_cache_aggregator = { nitro_partial_id: NitroPartial.get_partial( options[:partial], options ).id,
+                                      nitro_cache_key: nitro_cache_key,
+                                      reverse: false,
+                                      caches: [] }
+
+        result = render( partial: options[:partial],
+                         #because of select nitro_cached_value we need to add select( 'all.*' )
+                         collection: collection.select_all_if_empty
+                                         .select_nitro_cache
+                                         .outer_join_partials(nitro_cache_key),
+                         as: options[:as],
+                         locals: {
+                             locals: options[:locals]
+                         }
+        )
+        # Нужно массив все таки переделать в хеш на случай повторений в коллекции
+        collection.klass.nitro_cache_bulk_insert( @current_cache_aggregator )
+
+      else
+        result = aggr_result['str_agg'].try(:html_safe)
+      end
+
+      #NitroCache.where( nitro_cacheable: collection, nitro_cache_key: nitro_cache_key) breaks on complex collections
+      NitroCache.where( nitro_cacheable_type: collection.base_class,
+                        nitro_cacheable_id: collection.base_class
+                                                .from( "(#{collection.to_sql }) #{collection.table_name}" ).select(:id),
+                        nitro_cache_key: nitro_cache_key )
+          .update_all(viewed_at: Time.now)
+
+      # alternative way to
+      #ActiveRecord::Base.connection.execute( <<UPDATE_SQL
+      #          UPDATE "nitro_cahes"
+      #          SET "viewed_at" = '#{Time.now}'
+      #          WHERE "nitro_partials"."id" IN (
+      #             SELECT "nitro_caches"."id" FROM (#{collection.outer_join_partials(nitro_cache_key).unscope(:select).select('"nitro_caches"."id"').to_sql}) as db_cache_partials )
+      # UPDATE_SQL
+      #       )
+
+      result
+    end
+
+
+    # 'reverse' cache: we first getting only noncached records, renders them, cache, and after that
+    # aggregate whole collection from DB
+
+    # вариант с кеш реверсом, сначала достаем те которые не отрисованы/закешированы,
+    # отрисовываем их, и после этого делаем без всяких извратов аггрегацию
+    def db_cache_collection_r( options )
+      collection = options[:collection]
+      # nitro_cache_key - same across all collection
+      nitro_cache_key = options.to_nitro_cache_key
+
+      @current_cache_aggregator = { nitro_partial_id: NitroPartial.get_partial( options[:partial], options ).id,
+                                    nitro_cache_key: nitro_cache_key,
+                                    reverse: true,
+                                    caches: [] }
+      # some how rails can't manage it through collection, so we downgrade it to collection.base_class
+      # but it must go unscoped, default_scopes will be added from original collection
+      render_collection = collection.base_class.unscoped
+      collection.values.slice(:joins, :references, :includes).each{|key, value| render_collection = render_collection.send("#{key}", value) }
+
+      render( partial: options[:partial],
+              collection: render_collection.from( "(#{collection.outer_join_partials(nitro_cache_key)
+                                                          .select_all_if_empty
+                                                          .select_nitro_cache.to_sql }) #{collection.table_name}" )
+                              .where(nitro_cached_value: nil),
+              as: options[:as],
+              locals: {
+                  locals: options[:locals]
+              }
+      )
+
+      collection.klass.nitro_cache_bulk_insert( @current_cache_aggregator ) unless @current_cache_aggregator[:caches].blank?
+
+      # todo SHARD!
+      # if @current_cache_aggregator[:caches].blank? than we can ask any shard, else only master shard
+
+      #NitroCache.where( nitro_cacheable: collection, nitro_cache_key: nitro_cache_key ) - breaks :(
+      NitroCache.where( nitro_cacheable_type: collection.base_class,
+                        nitro_cacheable_id: collection.base_class.unscoped
+                                                .from( "(#{collection.to_sql }) #{collection.table_name}" ).select(:id),
+                        nitro_cache_key: nitro_cache_key ).update_all(viewed_at: Time.now)
+
+      collection.aggregate_collection( nitro_cache_key )['str_agg'].try(:html_safe)
+    end
+
+  end
+end

metadata

@@ -0,0 +1,117 @@
+--- !ruby/object:Gem::Specification
+name: nitro_pg_cache
+version: !ruby/object:Gem::Version
+  version: 0.1.rc1
+platform: ruby
+authors:
+- alekseyl
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-11-16 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '4.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '4.1'
+- !ruby/object:Gem::Dependency
+  name: pg
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rails_select_on_includes
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: pg_cache_key
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: "PostgreSQL fast cache. Faster than memcache+dalli on same machine.\n
+  \                         Features: 'instant' reordering cached collection and subcollection
+  rendering, prerendering, 2-3 faster rendering of partially cached collection "
+email:
+- leshchuk@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- MIT-LICENSE
+- README.md
+- Rakefile
+- config/initializers/inflections.rb
+- db/migrate/1_add_nitro_cache_tables.rb
+- lib/models/nitro_cache.rb
+- lib/models/nitro_partial.rb
+- lib/nitro_pg_cache.rb
+- lib/nitro_pg_cache/acts_as_nitro_cacheable.rb
+- lib/nitro_pg_cache/engine.rb
+- lib/nitro_pg_cache/model_ext.rb
+- lib/nitro_pg_cache/version.rb
+- lib/nitro_pg_cache/viewer_ext.rb
+homepage: ''
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">"
+    - !ruby/object:Gem::Version
+      version: 1.3.1
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.5.1
+signing_key: 
+specification_version: 4
+summary: 'PostgreSQL fast cache. Faster than memcache+dalli on same machine. Features:
+  ''instant'' reordering cached collection and subcollection rendering, prerendering,
+  2-3 faster rendering of partially cached collection'
+test_files: []