activerecord-jsonb-associations 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: c81885988f07c3229320ba64f85c6f2cb31f9467
+  data.tar.gz: 697fdde245ae31c5f568a7d7ee130c297c418fcc
+SHA512:
+  metadata.gz: e790b5b644fa87e1628377fed0a45fd10f8201d2e65b7396e5274a822f3da222e26343bc353c38896e56e68280f5fd7aa39b64ef032d44cd26bca16980ac15af
+  data.tar.gz: 62d99c36a88e8dad04ac17984b2755da343676577078c4b831ee3cbf84b5167c15792c24fe7baf50860481bda69cef760ed6f3c926bf75cb74227d137f926a7a

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright 2017 Yury Lebedev
+
+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,109 @@
+# activerecord-json-associations
+
+Use PostgreSQL JSONB fields to store association information of your models.
+
+This gem was created as a solution to this [task](http://cultofmartians.com/tasks/active-record-jsonb-associations.html) from [EvilMartians](http://evilmartians.com).
+
+**Requirements:**
+
+- PostgreSQL (>= 9.6)
+
+## Usage
+
+### One-to-one and One-to-many associations
+
+You can store all foreign keys of your model in one JSONB column, without having to create multiple columns:
+
+```ruby
+class Profile < ActiveRecord::Base
+  # Setting additional :store option on :belongs_to association
+  # enables saving of foreign ids in :extra JSONB column 
+  belongs_to :user, store: :extra
+end
+
+class SocialProfile < ActiveRecord::Base
+  belongs_to :user, store: :extra
+end
+
+class User < ActiveRecord::Base
+  # Parent model association needs to specify :foreign_store
+  # for associations with JSONB storage
+  has_one :profile, foreign_store: :extra
+  has_many :social_profiles, foreign_store: :extra
+end
+```
+
+Foreign keys for association on one model have to be unique, even if they use different store column.
+
+You can also use `add_references` in your migration to add JSONB column and index for it (if `index: true` option is set):
+
+```ruby
+add_reference :profiles, :users, store: :extra, index: true
+```
+
+### Many-to-many associations
+
+You can also use JSONB columns on 2 sides of a HABTM association. This way you won't have to create a join table.
+
+```ruby
+class Label < ActiveRecord::Base
+  # extra['user_ids'] will store associated user ids
+  has_and_belongs_to_many :users, store: :extra
+end
+
+class User < ActiveRecord::Base
+  # extra['label_ids'] will store associated label ids
+  has_and_belongs_to_many :labels, store: :extra
+end
+```
+
+#### Performance
+
+Compared to regular associations, fetching models associated via JSONB column has no drops in performance.
+
+Getting the count of connected records is ~35% faster with associations via JSONB (tested on associations with up to 10 000 connections).
+
+Adding new connections is slightly faster with JSONB, for scopes up to 500 records connected to another record (total count of records in the table does not matter that much. If you have more then ~500 records connected to one record on average, and you want to add new records to the scope, JSONB associations will be slower then traditional:
+
+<img src="https://github.com/lebedev-yury/activerecord-jsonb-associations/blob/master/doc/images/adding-associations.png?raw=true | width=500" alt="JSONB HAMTB is slower on adding associations" width="600">
+
+On the other hand, unassociating models from a big amount of associated models if faster with JSONB HABTM as the associations count grows:
+
+<img src="https://github.com/lebedev-yury/activerecord-jsonb-associations/blob/master/doc/images/deleting-associations.png?raw=true | width=500" alt="JSONB HAMTB is faster on removing associations" width="600">
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'activerecord-jsonb-associations'
+```
+
+And then execute:
+
+```bash
+$ bundle install
+```
+
+## Developing
+
+To setup development environment, just run:
+
+```bash
+$ bin/setup
+```
+
+To run specs:
+
+```bash
+$ bundle exec rspec
+```
+
+To run benchmarks (that will take a while):
+
+```bash
+$ bundle exec rake benchmarks:habtm
+```
+
+## 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,19 @@
+begin
+  require 'bundler/setup'
+rescue LoadError
+  puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
+end
+
+Rake.add_rakelib 'benchmarks'
+
+require 'rdoc/task'
+
+RDoc::Task.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'ActiveRecord::JSONB::Associations'
+  rdoc.options << '--line-numbers'
+  rdoc.rdoc_files.include('README.md')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+require 'bundler/gem_tasks'

data/lib/activerecord/jsonb/associations.rb

@@ -0,0 +1,75 @@
+require 'active_record'
+
+require 'arel/nodes/jsonb_operators'
+require 'activerecord/jsonb/associations/class_methods'
+require 'activerecord/jsonb/associations/builder/belongs_to'
+require 'activerecord/jsonb/associations/builder/has_one'
+require 'activerecord/jsonb/associations/builder/has_many'
+require 'activerecord/jsonb/associations/belongs_to_association'
+require 'activerecord/jsonb/associations/association'
+require 'activerecord/jsonb/associations/has_many_association'
+require 'activerecord/jsonb/associations/association_scope'
+require 'activerecord/jsonb/associations/preloader/association'
+require 'activerecord/jsonb/associations/preloader/has_many'
+require 'activerecord/jsonb/associations/join_dependency/join_association'
+require 'activerecord/jsonb/connection_adapters/reference_definition'
+
+module ActiveRecord #:nodoc:
+  module JSONB #:nodoc:
+    module Associations #:nodoc:
+      class ConflictingAssociation < StandardError; end
+    end
+  end
+end
+
+# rubocop:disable Metrics/BlockLength
+ActiveSupport.on_load :active_record do
+  ::ActiveRecord::Base.extend(
+    ActiveRecord::JSONB::Associations::ClassMethods
+  )
+
+  ::ActiveRecord::Associations::Builder::BelongsTo.extend(
+    ActiveRecord::JSONB::Associations::Builder::BelongsTo
+  )
+
+  ::ActiveRecord::Associations::Builder::HasOne.extend(
+    ActiveRecord::JSONB::Associations::Builder::HasOne
+  )
+
+  ::ActiveRecord::Associations::Builder::HasMany.extend(
+    ActiveRecord::JSONB::Associations::Builder::HasMany
+  )
+
+  ::ActiveRecord::Associations::Association.prepend(
+    ActiveRecord::JSONB::Associations::Association
+  )
+
+  ::ActiveRecord::Associations::BelongsToAssociation.prepend(
+    ActiveRecord::JSONB::Associations::BelongsToAssociation
+  )
+
+  ::ActiveRecord::Associations::HasManyAssociation.prepend(
+    ActiveRecord::JSONB::Associations::HasManyAssociation
+  )
+
+  ::ActiveRecord::Associations::AssociationScope.prepend(
+    ActiveRecord::JSONB::Associations::AssociationScope
+  )
+
+  ::ActiveRecord::Associations::Preloader::Association.prepend(
+    ActiveRecord::JSONB::Associations::Preloader::Association
+  )
+
+  ::ActiveRecord::Associations::Preloader::HasMany.prepend(
+    ActiveRecord::JSONB::Associations::Preloader::HasMany
+  )
+
+  ::ActiveRecord::Associations::JoinDependency::JoinAssociation.prepend(
+    ActiveRecord::JSONB::Associations::JoinDependency::JoinAssociation
+  )
+
+  ::ActiveRecord::ConnectionAdapters::ReferenceDefinition.prepend(
+    ActiveRecord::JSONB::ConnectionAdapters::ReferenceDefinition
+  )
+end
+# rubocop:enable Metrics/BlockLength

data/lib/activerecord/jsonb/associations/association.rb

@@ -0,0 +1,30 @@
+module ActiveRecord
+  module JSONB
+    module Associations
+      module Association #:nodoc:
+        def creation_attributes
+          return super unless reflection.options.key?(:foreign_store)
+
+          attributes = {}
+          jsonb_store = reflection.options[:foreign_store]
+          attributes[jsonb_store] ||= {}
+          attributes[jsonb_store][reflection.foreign_key] =
+            owner[reflection.active_record_primary_key]
+
+          attributes
+        end
+
+        # rubocop:disable Metrics/AbcSize
+        def create_scope
+          super.tap do |scope|
+            next unless options.key?(:foreign_store)
+            scope[options[:foreign_store].to_s] ||= {}
+            scope[options[:foreign_store].to_s][reflection.foreign_key] =
+              owner[reflection.active_record_primary_key]
+          end
+        end
+        # rubocop:enable Metrics/AbcSize
+      end
+    end
+  end
+end

data/lib/activerecord/jsonb/associations/association_scope.rb

@@ -0,0 +1,58 @@
+module ActiveRecord
+  module JSONB
+    module Associations
+      module AssociationScope #:nodoc:
+        # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
+        def last_chain_scope(scope, table, owner_reflection, owner)
+          reflection = owner_reflection.instance_variable_get(:@reflection)
+          return super unless reflection
+
+          join_keys = reflection.join_keys
+          key = join_keys.key
+          value = transform_value(owner[reflection.join_keys.foreign_key])
+
+          if reflection.options.key?(:foreign_store)
+            apply_jsonb_scope(
+              scope,
+              jsonb_equality(table, reflection.options[:foreign_store], key),
+              key, value
+            )
+          elsif reflection && reflection.options.key?(:store)
+            pluralized_key = key.pluralize
+
+            apply_jsonb_scope(
+              scope,
+              jsonb_containment(
+                table, reflection.options[:store], pluralized_key
+              ),
+              pluralized_key, value
+            )
+          else
+            super
+          end
+        end
+        # rubocop:enable Metrics/MethodLength, Metrics/AbcSize
+
+        def apply_jsonb_scope(scope, predicate, key, value)
+          scope.where!(predicate).tap do |arel_scope|
+            arel_scope.where_clause.binds << Relation::QueryAttribute.new(
+              key.to_s, value, ActiveModel::Type::String.new
+            )
+          end
+        end
+
+        def jsonb_equality(table, jsonb_column, key)
+          Arel::Nodes::JSONBDashDoubleArrow.new(
+            table, table[jsonb_column], key
+          ).eq(Arel::Nodes::BindParam.new)
+        end
+
+        def jsonb_containment(table, jsonb_column, key)
+          Arel::Nodes::JSONBHashArrow.new(
+            table, table[jsonb_column], key
+          ).contains(Arel::Nodes::BindParam.new)
+        end
+      end
+    end
+  end
+end

data/lib/activerecord/jsonb/associations/belongs_to_association.rb

@@ -0,0 +1,16 @@
+module ActiveRecord
+  module JSONB
+    module Associations
+      module BelongsToAssociation #:nodoc:
+        def replace_keys(record)
+          return super unless reflection.options.key?(:store)
+
+          owner[reflection.options[:store]][reflection.foreign_key] =
+            record._read_attribute(
+              reflection.association_primary_key(record.class)
+            )
+        end
+      end
+    end
+  end
+end

data/lib/activerecord/jsonb/associations/builder/belongs_to.rb

@@ -0,0 +1,53 @@
+module ActiveRecord
+  module JSONB
+    module Associations
+      module Builder
+        module BelongsTo #:nodoc:
+          def valid_options(options)
+            super + [:store]
+          end
+
+          def define_accessors(mixin, reflection)
+            if reflection.options.key?(:store)
+              mixin.attribute reflection.foreign_key, :integer
+              add_association_accessor_methods(mixin, reflection)
+            end
+
+            super
+          end
+
+          def add_association_accessor_methods(mixin, reflection)
+            foreign_key = reflection.foreign_key.to_s
+
+            mixin.class_eval <<-CODE, __FILE__, __LINE__ + 1
+              if method_defined?(foreign_key)
+                raise ActiveRecord::JSONB::Associations::
+                        ConflictingAssociation,
+                          "Association with foreign key :#{foreign_key} already "\
+                          "exists on #{reflection.active_record.name}"
+              end
+
+              def #{foreign_key}=(value)
+                #{reflection.options[:store]}['#{foreign_key}'] = value
+              end
+
+              def #{foreign_key}
+                #{reflection.options[:store]}['#{foreign_key}']
+              end
+
+              def [](key)
+                key = key.to_s
+                if key.ends_with?('_id') &&
+                    #{reflection.options[:store]}.keys.include?(key)
+                  #{reflection.options[:store]}[key]
+                else
+                  super
+                end
+              end
+            CODE
+          end
+        end
+      end
+    end
+  end
+end

data/lib/activerecord/jsonb/associations/builder/has_many.rb

@@ -0,0 +1,35 @@
+module ActiveRecord
+  module JSONB
+    module Associations
+      module Builder
+        module HasMany #:nodoc:
+          def valid_options(options)
+            super + %i[store foreign_store]
+          end
+
+          def define_accessors(mixin, reflection)
+            if reflection.options.key?(:store)
+              add_association_accessor_methods(mixin, reflection)
+            end
+
+            super
+          end
+
+          def add_association_accessor_methods(mixin, reflection)
+            mixin.class_eval <<-CODE, __FILE__, __LINE__ + 1
+              def [](key)
+                key = key.to_s
+                if key.ends_with?('_ids') &&
+                    #{reflection.options[:store]}.keys.include?(key)
+                  #{reflection.options[:store]}[key]
+                else
+                  super
+                end
+              end
+            CODE
+          end
+        end
+      end
+    end
+  end
+end

data/lib/activerecord/jsonb/associations/builder/has_one.rb

@@ -0,0 +1,13 @@
+module ActiveRecord
+  module JSONB
+    module Associations
+      module Builder
+        module HasOne #:nodoc:
+          def valid_options(options)
+            super + [:foreign_store]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/activerecord/jsonb/associations/class_methods.rb

@@ -0,0 +1,14 @@
+module ActiveRecord
+  module JSONB
+    module Associations
+      module ClassMethods #:nodoc:
+        # rubocop:disable Naming/PredicateName
+        def has_and_belongs_to_many(name, scope = nil, **options, &extension)
+          return super unless options.key?(:store)
+          has_many(name, scope, **options, &extension)
+        end
+        # rubocop:enable Naming/PredicateName
+      end
+    end
+  end
+end

data/lib/activerecord/jsonb/associations/has_many_association.rb

@@ -0,0 +1,134 @@
+module ActiveRecord
+  module JSONB
+    module Associations
+      module HasManyAssociation #:nodoc:
+        def ids_reader
+          return super unless reflection.options.key?(:store)
+
+          Array(
+            owner[reflection.options[:store]][
+              "#{reflection.name.to_s.singularize}_ids"
+            ]
+          )
+        end
+
+        # rubocop:disable Naming/AccessorMethodName
+        def set_owner_attributes(record)
+          return super unless reflection.options.key?(:store)
+
+          creation_attributes.each do |key, value|
+            if key == reflection.options[:store]
+              set_store_attributes(record, key, value)
+            else
+              record[key] = value
+            end
+          end
+        end
+        # rubocop:enable Naming/AccessorMethodName
+
+        def set_store_attributes(record, store_column, attributes)
+          attributes.each do |key, value|
+            if value.is_a?(Array)
+              record[store_column][key] ||= []
+              record[store_column][key] =
+                record[store_column][key].concat(value).uniq
+            else
+              record[store_column] = value
+            end
+          end
+        end
+
+        # rubocop:disable Metrics/AbcSize
+        def creation_attributes
+          return super unless reflection.options.key?(:store)
+
+          attributes = {}
+          jsonb_store = reflection.options[:store]
+          attributes[jsonb_store] ||= {}
+          attributes[jsonb_store][reflection.foreign_key.pluralize] = []
+          attributes[jsonb_store][reflection.foreign_key.pluralize] <<
+            owner[reflection.active_record_primary_key]
+
+          attributes
+        end
+        # rubocop:enable Metrics/AbcSize
+
+        # rubocop:disable Metrics/AbcSize
+        def create_scope
+          super.tap do |scope|
+            next unless options.key?(:store)
+
+            key = reflection.foreign_key.pluralize
+            scope[options[:store].to_s] ||= {}
+            scope[options[:store].to_s][key] ||= []
+            scope[options[:store].to_s][key] << owner[
+              reflection.active_record_primary_key
+            ]
+          end
+        end
+        # rubocop:enable Metrics/AbcSize
+
+        # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
+        def insert_record(record, validate = true, raise = false)
+          super.tap do |super_result|
+            next unless options.key?(:store)
+            next unless super_result
+
+            key = "#{record.model_name.singular}_ids"
+            jsonb_column = options[:store]
+
+            owner.class.where(
+              owner.class.primary_key => owner[owner.class.primary_key]
+            ).update_all(%(
+              #{jsonb_column} = jsonb_set(#{jsonb_column}, '{#{key}}',
+              coalesce(#{jsonb_column}->'#{key}', '[]'::jsonb) ||
+              '[#{record[klass.primary_key]}]'::jsonb)
+            ))
+          end
+        end
+        # rubocop:enable Metrics/MethodLength, Metrics/AbcSize
+
+        def delete_records(records, method)
+          return super unless options.key?(:store)
+          super(records, :delete)
+        end
+
+        # rubocop:disable Metrics/AbcSize
+        def delete_count(method, scope)
+          store = reflection.options[:foreign_store] ||
+                  reflection.options[:store]
+          return super if method == :delete_all || !store
+
+          if reflection.options.key?(:foreign_store)
+            remove_jsonb_foreign_id_on_belongs_to(store, reflection.foreign_key)
+          else
+            remove_jsonb_foreign_id_on_habtm(
+              store, reflection.foreign_key.pluralize, owner.id
+            )
+          end
+        end
+        # rubocop:enable Metrics/AbcSize
+
+        def remove_jsonb_foreign_id_on_belongs_to(store, foreign_key)
+          scope.update_all("#{store} = #{store} #- '{#{foreign_key}}'")
+        end
+
+        def remove_jsonb_foreign_id_on_habtm(store, foreign_key, owner_id)
+          # PostgreSQL can only delete jsonb array elements by text or index.
+          # Therefore we have to convert the jsonb array to PostgreSQl array,
+          # remove the element, and convert it back
+          scope.update_all(
+            %(
+              #{store} = jsonb_set(#{store}, '{#{foreign_key}}',
+                to_jsonb(
+                  array_remove(
+                    array(select * from jsonb_array_elements(
+                      (#{store}->'#{foreign_key}'))),
+                    '#{owner_id}')))
+            )
+          )
+        end
+      end
+    end
+  end
+end

data/lib/activerecord/jsonb/associations/join_dependency/join_association.rb

@@ -0,0 +1,47 @@
+module ActiveRecord
+  module JSONB
+    module Associations
+      module JoinDependency
+        module JoinAssociation #:nodoc:
+          # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
+          def build_constraint(klass, table, key, foreign_table, foreign_key)
+            if reflection.options.key?(:foreign_store)
+              build_eq_constraint(
+                table, table[reflection.options[:foreign_store]],
+                key, foreign_table, foreign_key
+              )
+            elsif reflection.options.key?(:store)
+              build_contains_constraint(
+                table, table[reflection.options[:store]],
+                key.pluralize, foreign_table, foreign_key
+              )
+            else
+              super
+            end
+          end
+          # rubocop:enable Metrics/AbcSize, Metrics/MethodLength
+
+          def build_eq_constraint(
+            table, jsonb_column, key, foreign_table, foreign_key
+          )
+            Arel::Nodes::JSONBDashDoubleArrow.new(table, jsonb_column, key).eq(
+              ::Arel::Nodes::SqlLiteral.new(
+                "CAST(#{foreign_table.name}.#{foreign_key} AS text)"
+              )
+            )
+          end
+
+          def build_contains_constraint(
+            table, jsonb_column, key, foreign_table, foreign_key
+          )
+            Arel::Nodes::JSONBHashArrow.new(table, jsonb_column, key).contains(
+              ::Arel::Nodes::SqlLiteral.new(
+                "jsonb_build_array(#{foreign_table.name}.#{foreign_key})"
+              )
+            )
+          end
+        end
+      end
+    end
+  end
+end

data/lib/activerecord/jsonb/associations/preloader/association.rb

@@ -0,0 +1,21 @@
+module ActiveRecord
+  module JSONB
+    module Associations
+      module Preloader
+        module Association #:nodoc:
+          def records_for(ids)
+            return super unless reflection.options.key?(:foreign_store)
+
+            scope.where(
+              Arel::Nodes::JSONBHashArrow.new(
+                table,
+                table[reflection.options[:foreign_store]],
+                association_key_name
+              ).intersects_with(ids)
+            )
+          end
+        end
+      end
+    end
+  end
+end

data/lib/activerecord/jsonb/associations/preloader/has_many.rb

@@ -0,0 +1,62 @@
+module ActiveRecord
+  module JSONB
+    module Associations
+      module Preloader
+        module HasMany #:nodoc:
+          # rubocop:disable Metrics/AbcSize
+          def records_for(ids)
+            return super unless reflection.options.key?(:store)
+
+            scope.where(
+              Arel::Nodes::JSONBHashArrow.new(
+                table,
+                table[reflection.options[:store]],
+                association_key_name.pluralize
+              ).intersects_with(ids)
+            )
+          end
+          # rubocop:enable Metrics/AbcSize
+
+          def association_key_name
+            super_value = super
+            return super_value unless reflection.options.key?(:store)
+            super_value.pluralize
+          end
+
+          # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
+          def associated_records_by_owner(preloader)
+            return super unless reflection.options.key?(:store)
+
+            records = load_records do |record|
+              record[association_key_name].each do |owner_key|
+                owner = owners_by_key[convert_key(owner_key)]
+                association = owner.association(reflection.name)
+                association.set_inverse_instance(record)
+              end
+            end
+
+            owners.each_with_object({}) do |owner, result|
+              result[owner] = records[convert_key(owner[owner_key_name])] || []
+            end
+          end
+          # rubocop:enable Metrics/AbcSize, Metrics/MethodLength
+
+          # rubocop:disable Metrics/AbcSize
+          def load_records(&block)
+            return super unless reflection.options.key?(:store)
+
+            return {} if owner_keys.empty?
+            @preloaded_records = records_for(owner_keys).load(&block)
+            @preloaded_records.each_with_object({}) do |record, result|
+              record[association_key_name].each do |owner_key|
+                result[convert_key(owner_key)] ||= []
+                result[convert_key(owner_key)] << record
+              end
+            end
+          end
+          # rubocop:enable Metrics/AbcSize
+        end
+      end
+    end
+  end
+end

data/lib/activerecord/jsonb/associations/version.rb

@@ -0,0 +1,7 @@
+module ActiveRecord
+  module JSONB
+    module Associations
+      VERSION = '0.1.0'.freeze
+    end
+  end
+end

data/lib/activerecord/jsonb/connection_adapters/reference_definition.rb

@@ -0,0 +1,50 @@
+module ActiveRecord
+  module JSONB
+    module ConnectionAdapters
+      module ReferenceDefinition #:nodoc:
+        # rubocop:disable Lint/UnusedMethodArgument, Metrics/ParameterLists
+        def initialize(
+          name,
+          polymorphic: false,
+          index: true,
+          foreign_key: false,
+          type: :bigint,
+          store: false,
+          **options
+        )
+          @store = store
+
+          super(
+            name,
+            polymorphic: false,
+            index: true,
+            foreign_key: false,
+            type: :bigint,
+            **options
+          )
+        end
+        # rubocop:enable Lint/UnusedMethodArgument, Metrics/ParameterLists
+
+        def add_to(table)
+          return super unless store
+
+          table.column(store, :jsonb, null: false, default: {})
+
+          return unless index
+
+          column_names.each do |column_name|
+            table.index(
+              "(#{store}->>'#{column_name}')",
+              using: :hash,
+              name: "index_#{table.name}_on_#{store}_#{column_name}"
+            )
+          end
+        end
+
+        protected
+
+        attr_reader :store
+      end
+    end
+  end
+end

data/lib/arel/nodes/jsonb_at_arrow.rb

@@ -0,0 +1,16 @@
+module Arel
+  module Nodes
+    class JSONBAtArrow < JSONBOperator #:nodoc:
+      def operator
+        '@>'
+      end
+
+      def right_side
+        return name if name.is_a?(::Arel::Nodes::BindParam) ||
+                       name.is_a?(::Arel::Nodes::SqlLiteral)
+
+        ::Arel::Nodes::SqlLiteral.new("'#{name.to_json}'")
+      end
+    end
+  end
+end

data/lib/arel/nodes/jsonb_dash_double_arrow.rb

@@ -0,0 +1,9 @@
+module Arel
+  module Nodes
+    class JSONBDashDoubleArrow < JSONBOperator #:nodoc:
+      def operator
+        '->>'
+      end
+    end
+  end
+end

data/lib/arel/nodes/jsonb_double_pipe.rb

@@ -0,0 +1,14 @@
+module Arel
+  module Nodes
+    class JSONBDoublePipe < JSONBOperator #:nodoc:
+      def operator
+        '||'
+      end
+
+      def right_side
+        return name if name.is_a?(::Arel::Nodes::BindParam)
+        ::Arel::Nodes::SqlLiteral.new("'#{name.to_json}'")
+      end
+    end
+  end
+end

data/lib/arel/nodes/jsonb_hash_arrow.rb

@@ -0,0 +1,28 @@
+module Arel
+  module Nodes
+    class JSONBHashArrow < Arel::Nodes::JSONBOperator #:nodoc:
+      def operator
+        '#>'
+      end
+
+      def right_side
+        ::Arel::Nodes::SqlLiteral.new("'{#{name}}'")
+      end
+
+      def contains(value)
+        Arel::Nodes::JSONBAtArrow.new(relation, self, value)
+      end
+
+      def intersects_with(array)
+        ::Arel::Nodes::InfixOperation.new(
+          '>',
+          ::Arel::Nodes::NamedFunction.new(
+            'jsonb_array_length',
+            [Arel::Nodes::JSONBDoublePipe.new(relation, self, array)]
+          ),
+          0
+        )
+      end
+    end
+  end
+end

data/lib/arel/nodes/jsonb_operator.rb

@@ -0,0 +1,24 @@
+module Arel
+  module Nodes
+    class JSONBOperator < ::Arel::Nodes::InfixOperation #:nodoc:
+      attr_reader :relation
+      attr_reader :name
+
+      def initialize(relation, left_side, key)
+        @relation = relation
+        @name = key
+
+        super(operator, left_side, right_side)
+      end
+
+      def right_side
+        ::Arel::Nodes::SqlLiteral.new("'#{name}'")
+      end
+
+      def operator
+        raise NotImplementedError,
+              'Subclasses must implement an #operator method'
+      end
+    end
+  end
+end

data/lib/arel/nodes/jsonb_operators.rb

@@ -0,0 +1,5 @@
+require 'arel/nodes/jsonb_operator'
+require 'arel/nodes/jsonb_dash_double_arrow'
+require 'arel/nodes/jsonb_at_arrow'
+require 'arel/nodes/jsonb_double_pipe'
+require 'arel/nodes/jsonb_hash_arrow'

metadata

@@ -0,0 +1,96 @@
+--- !ruby/object:Gem::Specification
+name: activerecord-jsonb-associations
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Yury Lebedev
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2017-11-22 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 5.1.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 5.1.0
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.7.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.7.0
+description: Use PostgreSQL JSONB fields to store association information of your
+  models
+email:
+- lebedev.yurii@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- MIT-LICENSE
+- README.md
+- Rakefile
+- lib/activerecord/jsonb/associations.rb
+- lib/activerecord/jsonb/associations/association.rb
+- lib/activerecord/jsonb/associations/association_scope.rb
+- lib/activerecord/jsonb/associations/belongs_to_association.rb
+- lib/activerecord/jsonb/associations/builder/belongs_to.rb
+- lib/activerecord/jsonb/associations/builder/has_many.rb
+- lib/activerecord/jsonb/associations/builder/has_one.rb
+- lib/activerecord/jsonb/associations/class_methods.rb
+- lib/activerecord/jsonb/associations/has_many_association.rb
+- lib/activerecord/jsonb/associations/join_dependency/join_association.rb
+- lib/activerecord/jsonb/associations/preloader/association.rb
+- lib/activerecord/jsonb/associations/preloader/has_many.rb
+- lib/activerecord/jsonb/associations/version.rb
+- lib/activerecord/jsonb/connection_adapters/reference_definition.rb
+- lib/arel/nodes/jsonb_at_arrow.rb
+- lib/arel/nodes/jsonb_dash_double_arrow.rb
+- lib/arel/nodes/jsonb_double_pipe.rb
+- lib/arel/nodes/jsonb_hash_arrow.rb
+- lib/arel/nodes/jsonb_operator.rb
+- lib/arel/nodes/jsonb_operators.rb
+homepage: https://github.com/lebedev-yury/activerecord-jsonb-associations
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - "~>"
+    - !ruby/object:Gem::Version
+      version: '2.0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.6.11
+signing_key: 
+specification_version: 4
+summary: Gem for storing association information using PostgreSQL JSONB columns
+test_files: []