associate_jsonb 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: ad94cc18f8d5f87d25f2ebe9d0b75309fb43a3f22fc1438266e05ce39c2a3064
+  data.tar.gz: 016ce6443d9fdca1155d4b63fc18e6f6aaa18ef8887f73fe22312ee876d65f5d
+SHA512:
+  metadata.gz: 7534ab4739036cff3691d4da6ac3d612cb6149c948088a3b7c24095e10bafce0d98e4bd96b7276c1ce84fd5e1017f039af48d59ed7d29f42827e90379a5e277d
+  data.tar.gz: 97e169f1942e48131f7de7be8dc99551c525fbdec7914a3de26abe3738614f1ae838bbd3edf2fb8828097c60ae32a47546638053f447510b4ad3792677dd639b

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,99 @@
+# associate_jsonb
+
+[![Gem Version](https://badge.fury.io/rb/associate_jsonb.svg)](https://badge.fury.io/rb/associate_jsonb)
+
+Basic ActiveRecord Associations using PostgreSQL JSONB columns, with built-in accessors and column indexes
+
+<!-- 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
+
+Due to the ease of getting out-of-sync, and the complexity needed to build it, HABTM relation functionality has not been implemented through JSONB
+
+#### 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/associate_jsonb/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/associate_jsonb/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 'associate_jsonb'
+```
+
+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    = 'AssociateJsonb::Associations'
+  rdoc.options << '--line-numbers'
+  rdoc.rdoc_files.include('README.md')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+require 'bundler/gem_tasks'

data/lib/associate_jsonb.rb

@@ -0,0 +1,74 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
+require "active_record"
+require "arel"
+require "active_support/core_ext"
+require "active_support/lazy_load_hooks"
+require "active_support/concern"
+require "pg"
+require "active_record/connection_adapters/postgresql_adapter"
+require "mutex_m"
+
+require "zeitwerk"
+loader = Zeitwerk::Loader.for_gem
+loader.setup # ready!
+
+module AssociateJsonb
+end
+
+
+# rubocop:disable Metrics/BlockLength
+ActiveSupport.on_load :active_record do
+  loader.eager_load
+
+  ActiveRecord::Base.include AssociateJsonb::WithStoreAttribute
+  ActiveRecord::Base.include AssociateJsonb::Associations
+
+  Arel::Nodes.include AssociateJsonb::ArelNodes
+  Arel::Nodes::Binary.include AssociateJsonb::ArelNodeExtensions::Binary
+
+  ActiveRecord::Associations::Builder::BelongsTo.extend(
+    AssociateJsonb::Associations::Builder::BelongsTo
+  )
+
+  ActiveRecord::Associations::Builder::HasOne.extend(
+    AssociateJsonb::Associations::Builder::HasOne
+  )
+
+  ActiveRecord::Associations::Builder::HasMany.extend(
+    AssociateJsonb::Associations::Builder::HasMany
+  )
+
+  ActiveRecord::Associations::Association.prepend(
+    AssociateJsonb::Associations::Association
+  )
+
+  ActiveRecord::Associations::BelongsToAssociation.prepend(
+    AssociateJsonb::Associations::BelongsToAssociation
+  )
+
+  ActiveRecord::Associations::HasManyAssociation.prepend(
+    AssociateJsonb::Associations::HasManyAssociation
+  )
+
+  ActiveRecord::Associations::AssociationScope.prepend(
+    AssociateJsonb::Associations::AssociationScope
+  )
+
+  ActiveRecord::Associations::Preloader::Association.prepend(
+    AssociateJsonb::Associations::Preloader::Association
+  )
+
+  # ActiveRecord::Associations::Preloader::HasMany.prepend(
+  #   AssociateJsonb::Associations::Preloader::HasMany
+  # )
+
+  ActiveRecord::Reflection::AbstractReflection.prepend AssociateJsonb::Reflection
+  ActiveRecord::Relation::WhereClause.prepend AssociateJsonb::Relation::WhereClause
+
+  ActiveRecord::ConnectionAdapters::ReferenceDefinition.prepend(
+    AssociateJsonb::ConnectionAdapters::ReferenceDefinition
+  )
+end
+# rubocop:enable Metrics/BlockLength

data/lib/associate_jsonb/arel_node_extensions/binary.rb

@@ -0,0 +1,12 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
+module AssociateJsonb
+  module ArelNodeExtensions
+    module Binary
+      def original_left
+        left
+      end
+    end
+  end
+end

data/lib/associate_jsonb/arel_nodes/jsonb/at_arrow.rb

@@ -0,0 +1,14 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
+module AssociateJsonb
+  module ArelNodes
+    module Jsonb
+      class AtArrow < AssociateJsonb::ArelNodes::Jsonb::BindableOperator
+        def operator
+          '@>'
+        end
+      end
+    end
+  end
+end

data/lib/associate_jsonb/arel_nodes/jsonb/bindable_operator.rb

@@ -0,0 +1,17 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
+module AssociateJsonb
+  module ArelNodes
+    module Jsonb
+      class BindableOperator < AssociateJsonb::ArelNodes::Jsonb::Operator
+        def right_side
+          return name if name.is_a?(::Arel::Nodes::BindParam) ||
+                         name.is_a?(::Arel::Nodes::SqlLiteral)
+
+          ::Arel::Nodes::SqlLiteral.new("'#{name.as_json}'")
+        end
+      end
+    end
+  end
+end

data/lib/associate_jsonb/arel_nodes/jsonb/dash_arrow.rb

@@ -0,0 +1,14 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
+module AssociateJsonb
+  module ArelNodes
+    module Jsonb
+      class DashArrow < AssociateJsonb::ArelNodes::Jsonb::Operator #:nodoc:
+        def operator
+          '->'
+        end
+      end
+    end
+  end
+end

data/lib/associate_jsonb/arel_nodes/jsonb/dash_double_arrow.rb

@@ -0,0 +1,14 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
+module AssociateJsonb
+  module ArelNodes
+    module Jsonb
+      class DashDoubleArrow < AssociateJsonb::ArelNodes::Jsonb::Operator #:nodoc:
+        def operator
+          '->>'
+        end
+      end
+    end
+  end
+end

data/lib/associate_jsonb/arel_nodes/jsonb/double_pipe.rb

@@ -0,0 +1,14 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
+module AssociateJsonb
+  module ArelNodes
+    module Jsonb
+      class DoublePipe < AssociateJsonb::ArelNodes::Jsonb::BindableOperator #:nodoc:
+        def operator
+          '||'
+        end
+      end
+    end
+  end
+end

data/lib/associate_jsonb/arel_nodes/jsonb/hash_arrow.rb

@@ -0,0 +1,33 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
+module AssociateJsonb
+  module ArelNodes
+    module Jsonb
+      class HashArrow < AssociateJsonb::ArelNodes::Jsonb::Operator #:nodoc:
+        def operator
+          '#>'
+        end
+
+        def right_side
+          ::Arel::Nodes::SqlLiteral.new("'{#{name}}'")
+        end
+
+        def contains(value)
+          ArelNodes::Jsonb::AtArrow.new(relation, self, value)
+        end
+
+        def intersects_with(array)
+          ::Arel::Nodes::InfixOperation.new(
+            '>',
+            ::Arel::Nodes::NamedFunction.new(
+              'jsonb_array_length',
+              [ ArelNodes::Jsonb::DoublePipe.new(relation, self, array) ]
+            ),
+            0
+          )
+        end
+      end
+    end
+  end
+end

data/lib/associate_jsonb/arel_nodes/jsonb/operator.rb

@@ -0,0 +1,26 @@
+module AssociateJsonb
+  module ArelNodes
+    module Jsonb
+      class Operator < ::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
+end

data/lib/associate_jsonb/arel_nodes/sql_casted_equality.rb

@@ -0,0 +1,20 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
+module AssociateJsonb
+  module ArelNodes
+    class SqlCastedEquality < ::Arel::Nodes::Equality
+      attr_reader :original_left
+      def initialize(left, cast_as, right)
+        @original_left = left
+        super(
+          ::Arel::Nodes::NamedFunction.new(
+            "CAST",
+            [ left.as(cast_as) ]
+          ),
+          right
+        )
+      end
+    end
+  end
+end

data/lib/associate_jsonb/associations/association.rb

@@ -0,0 +1,39 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
+module AssociateJsonb
+  module Associations
+    module Association #:nodoc:
+      def initialize_attributes(record, except_from_scope_attributes = nil) #:nodoc:
+        super unless reflection.foreign_store? && reflection.foreign_store_key?(reflection.foreign_key)
+
+        except_from_scope_attributes ||= {}
+        skip_assign = [reflection.foreign_key, reflection.type, reflection.foreign_store_key].compact
+        assigned_keys = record.changed_attribute_names_to_save
+        assigned_keys += except_from_scope_attributes.keys.map(&:to_s)
+        attributes = scope_for_create.except!(*(assigned_keys - skip_assign))
+        if attributes.key?(reflection.foreign_store_key.to_s)
+          v = attributes.delete(reflection.foreign_store_key.to_s)
+          attributes[reflection.foreign_key.to_s] = v
+        end
+        record.send(:_assign_attributes, attributes) if attributes.any?
+        set_inverse_instance(record)
+      end
+
+      private
+        def creation_attributes
+          return super if reflection.belongs_to?
+          return super unless reflection.foreign_store?
+
+          attributes = {}
+
+          jsonb_store = reflection.foreign_store_attr
+          attributes[jsonb_store] ||= {}
+          attributes[jsonb_store][reflection.foreign_store_key] =
+            owner[reflection.active_record_primary_key]
+
+          attributes
+        end
+    end
+  end
+end

data/lib/associate_jsonb/associations/association_scope.rb

@@ -0,0 +1,100 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
+module AssociateJsonb
+  module Associations
+    module AssociationScope #:nodoc:
+      # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
+      def last_chain_scope(scope, owner_reflection, owner)
+        reflection = owner_reflection.instance_variable_get(:@reflection)
+        return super unless reflection&.foreign_store?
+
+
+        join_keys = owner_reflection.join_keys
+        table = owner_reflection.aliased_table
+        key = reflection.foreign_store_key || join_keys.key
+        value = transform_value(owner[join_keys.foreign_key])
+
+        apply_jsonb_equality(
+          scope,
+          table,
+          reflection.foreign_store_attr,
+          key.to_s,
+          join_keys.foreign_key,
+          value,
+          reflection.active_record
+        )
+      end
+      # rubocop:enable Metrics/MethodLength, Metrics/AbcSize
+
+      def apply_jsonb_equality(scope, table, jsonb_column, store_key, foreign_key, value, foreign_klass)
+        sql_type = type = node_klass = nil
+        begin
+          type = foreign_klass.attribute_types[foreign_key.to_s]
+          raise "type not found" unless type.present?
+          sql_type = foreign_klass.columns_hash[foreign_key.to_s]
+          raise "not a column" unless sql_type.present?
+          sql_type = sql_type.sql_type
+          node_klass = Arel::Nodes::Jsonb::DashArrow
+        rescue
+          type = ActiveModel::Type::String.new
+          sql_type = "text"
+          node_klass = Arel::Nodes::Jsonb::DashDoubleArrow
+        end
+
+        # scope.where!(
+        #   Arel::Nodes::HashableNamedFunction.new(
+        #     "CAST",
+        #     [
+        #       node_klass.
+        #         new(table, table[jsonb_column], store_key).
+        #         as(sql_type)
+        #     ]
+        #   ).eq(
+        #     Arel::Nodes::BindParam.new(
+        #       ActiveRecord::Relation::QueryAttribute.new(
+        #         store_key, value, type
+        #       )
+        #     )
+        #   )
+        # )
+
+        scope.where!(
+          Arel::Nodes::SqlCastedEquality.new(
+            node_klass.new(table, table[jsonb_column], store_key),
+            sql_type,
+            Arel::Nodes::BindParam.new(
+              ActiveRecord::Relation::QueryAttribute.new(
+                store_key, value, type
+              )
+            )
+          )
+        )
+
+        # scope.where!(
+        #   Arel::Nodes::Jsonb::DashDoubleArrow.
+        #     new(table, table[jsonb_column], store_key).
+        #     eq(
+        #       Arel::Nodes::BindParam.new(
+        #         ActiveRecord::Relation::QueryAttribute.new(
+        #           store_key, value, ActiveModel::Type::String.new
+        #         )
+        #       )
+        #     )
+        # )
+
+        # scope.where!(
+        #   node_klass.new(
+        #     table, table[jsonb_column], store_key
+        #   ).eq(
+        #     Arel::Nodes::BindParam.new(
+        #       ActiveRecord::Relation::QueryAttribute.new(
+        #         store_key, value, type
+        #       )
+        #     )
+        #   )
+        # )
+      end
+    end
+  end
+end

data/lib/associate_jsonb/associations/belongs_to_association.rb

@@ -0,0 +1,17 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
+module AssociateJsonb
+  module Associations
+    module BelongsToAssociation #:nodoc:
+      def replace_keys(record)
+        return super unless reflection.options.key?(:store)
+
+        owner[reflection.foreign_key] =
+          record._read_attribute(
+            reflection.association_primary_key(record.class)
+          )
+      end
+    end
+  end
+end

data/lib/associate_jsonb/associations/builder/belongs_to.rb

@@ -0,0 +1,59 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
+module AssociateJsonb
+  module Associations
+    module Builder
+      module BelongsTo #:nodoc:
+        def valid_options(options)
+          super + %i[ store store_key ]
+        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)
+          foreign_key = reflection.foreign_key.to_s
+          key = (reflection.jsonb_store_key || foreign_key).to_s
+          store = reflection.jsonb_store_attr
+
+          mixin.instance_eval <<-CODE, __FILE__, __LINE__ + 1
+            if attribute_names.include?(foreign_key)
+              raise AssociateJsonb::Associations::
+                      ConflictingAssociation,
+                        "Association with foreign key :#{foreign_key} already "\
+                        "exists on #{reflection.active_record.name}"
+            end
+          CODE
+
+          opts = {}
+          foreign_type = :integer
+          begin
+            primary_key = reflection.active_record_primary_key.to_s
+            primary_column = reflection.klass.columns.find {|col| col.name == primary_key }
+
+            if primary_column
+              foreign_type = primary_column.type
+              sql_data = primary_column.sql_type_metadata.as_json
+              %i[ limit precision scale ].each do |k|
+                opts[k] = sql_data[k.to_s] if sql_data[k.to_s]
+              end
+            end
+          rescue
+            opts = { limit: 8 }
+            foreign_type = :integer
+          end
+
+          mixin.instance_eval <<-CODE, __FILE__, __LINE__ + 1
+            store_column_attribute(:#{store}, :#{foreign_key}, :#{foreign_type}, key: "#{key}", **opts)
+          CODE
+        end
+      end
+    end
+  end
+end

data/lib/associate_jsonb/associations/builder/has_many.rb

@@ -0,0 +1,14 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
+module AssociateJsonb
+  module Associations
+    module Builder
+      module HasMany #:nodoc:
+        def valid_options(options)
+          super + %i[ foreign_store foreign_store_key ]
+        end
+      end
+    end
+  end
+end

data/lib/associate_jsonb/associations/builder/has_one.rb

@@ -0,0 +1,14 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
+module AssociateJsonb
+  module Associations
+    module Builder
+      module HasOne #:nodoc:
+        def valid_options(options)
+          super + %i[ foreign_store foreign_store_key ]
+        end
+      end
+    end
+  end
+end

data/lib/associate_jsonb/associations/conflicting_association.rb

@@ -0,0 +1,8 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
+module AssociateJsonb
+  module Associations
+    class ConflictingAssociation < StandardError; end
+  end
+end

data/lib/associate_jsonb/associations/has_many_association.rb

@@ -0,0 +1,17 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
+module AssociateJsonb
+  module Associations
+    module HasManyAssociation #:nodoc:
+      # rubocop:disable Metrics/AbcSize
+      def delete_count(method, scope)
+        return super if method == :delete_all
+        return super unless store = reflection.foreign_store_attr
+
+        scope.update_all("#{store} = #{store} #- '{#{reflection.foreign_store_key}}'")
+      end
+      # rubocop:enable Metrics/AbcSize
+    end
+  end
+end

data/lib/associate_jsonb/associations/preloader/association.rb

@@ -0,0 +1,24 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
+module AssociateJsonb
+  module Associations
+    module Preloader
+      module Association #:nodoc:
+        def records_for(ids)
+          return super if reflection.belongs_to?
+          return super unless reflection.foreign_store?
+
+          table = reflection.klass.arel_table
+          scope.where(
+            Arel::Nodes::Jsonb::HashArrow.new(
+              table,
+              table[reflection.foreign_store_attr],
+              reflection.foreign_store_key
+            ).intersects_with(ids)
+          )
+        end
+      end
+    end
+  end
+end

data/lib/associate_jsonb/connection_adapters.rb

@@ -0,0 +1,7 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
+module AssociateJsonb
+  module ConnectionAdapters
+  end
+end

data/lib/associate_jsonb/connection_adapters/reference_definition.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module AssociateJsonb
+  module ConnectionAdapters
+    module ReferenceDefinition #:nodoc:
+      # rubocop:disable Metrics/ParameterLists
+      def initialize(
+        name,
+        store: false,
+        **options
+      )
+        @store = store && store.to_sym
+
+        super(name, **options)
+      end
+      # rubocop:enable Metrics/ParameterLists
+
+      def add_to(table)
+        return super unless store
+
+        should_add_col = false
+        if table.respond_to? :column_exists?
+          should_add_col = !table.column_exists?(store)
+        elsif table.respond_to? :columns
+          should_add_col = table.columns.none? {|col| col.name.to_sym == store}
+        end
+
+        table.column(store, :jsonb, null: false, default: {}) if should_add_col
+
+        return unless index
+
+        # should_add_idx = false
+        # if table.respond_to? :index_exists?
+        #   should_add_idx = !table.index_exists?([ store ], using: :gin)
+        # elsif table.respond_to? :indexes
+        #   should_add_idx = table.indexes.none? do |idx, opts|
+        #     (idx == [ store ]) \
+        #     && (opts == { using: :gin })
+        #   end
+        # end
+        #
+        # table.index([ store ], using: :gin) if should_add_idx
+
+        column_names.each do |column_name|
+          table.index(
+            "CAST (\"#{store}\"->'#{column_name}' AS #{@type || :bigint})",
+            using: :btree,
+            name: "index_#{table.name}_on_#{store}_#{column_name}"
+          )
+
+          table.index(
+            "(#{store}->>'#{column_name}')",
+            using: :btree,
+            name: "index_#{table.name}_on_#{store}_#{column_name}_text"
+          )
+        end
+      end
+
+      protected
+
+      attr_reader :store
+    end
+  end
+end

data/lib/associate_jsonb/reflection.rb

@@ -0,0 +1,103 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
+module AssociateJsonb
+  module Reflection
+    def jsonb_store?
+      options.key?(:store) && jsonb_store_attr.present?
+    end
+
+    def jsonb_store_key?(fk = nil)
+      options.key?(:store_key) \
+      && options[:store_key].present? \
+      && (!fk || (jsonb_store_key.to_s != fk.to_s))
+    end
+
+    def jsonb_store_attr
+      options[:store]
+    end
+
+    def jsonb_store_key
+      options[:store_key].presence || join_keys.foreign_key
+    end
+
+    def foreign_store?
+      options.key?(:foreign_store) && options[:foreign_store].present?
+    end
+
+    def foreign_store_key?(fk = nil)
+      options.key?(:foreign_store_key) \
+      && options[:foreign_store_key].present? \
+      && (!fk || (foreign_store_key.to_s != fk.to_s))
+    end
+
+    def foreign_store_attr
+      options[:foreign_store]
+    end
+
+    def foreign_store_key
+      options[:foreign_store_key].presence || join_keys.key
+    end
+
+    def join_scope(table, foreign_table, foreign_klass)
+      return super unless jsonb_store? || foreign_store?
+
+      predicate_builder = predicate_builder(table)
+      scope_chain_items = join_scopes(table, predicate_builder)
+      klass_scope       = klass_join_scope(table, predicate_builder)
+
+      if type
+        klass_scope.where!(type => foreign_klass.polymorphic_name)
+      end
+
+      scope_chain_items.inject(klass_scope, &:merge!)
+
+      key         = join_keys.key
+      foreign_key = join_keys.foreign_key
+
+      if foreign_store?
+        klass_scope.where!(
+          Arel::Nodes::NamedFunction.new(
+            "CAST",
+            [
+              Arel::Nodes::Jsonb::DashArrow.
+                new(table, table[foreign_store_attr], foreign_store_key || key).
+                as(foreign_klass.columns_hash[foreign_key.to_s].sql_type)
+            ]
+          ).eq(
+            ::Arel::Nodes::SqlLiteral.
+              new("#{foreign_table.name}.#{foreign_key}")
+          )
+        )
+
+        # klass_scope.where!(
+        #   Arel::Nodes::Jsonb::DashDoubleArrow.
+        #     new(table, table[foreign_store_attr], foreign_store_key || key).
+        #     eq(
+        #       ::Arel::Nodes::SqlLiteral.
+        #         new("#{foreign_table.name}.#{foreign_key}::text")
+        #     )
+        # )
+      elsif jsonb_store?
+        klass_scope.where!(
+          Arel::Nodes::NamedFunction.new(
+            "CAST",
+            [
+              Arel::Nodes::Jsonb::DashArrow.
+                new(foreign_table, foreign_table[jsonb_store_attr], jsonb_store_key || foreign_key).
+                as(klass.columns_hash[key.to_s].sql_type)
+            ]
+          ).eq(
+            ::Arel::Nodes::SqlLiteral.new("#{table.name}.#{key}")
+          )
+        )
+      end
+
+      if klass.finder_needs_type_condition?
+        klass_scope.where!(klass.send(:type_condition, table))
+      end
+
+      klass_scope
+    end
+  end
+end

data/lib/associate_jsonb/relation/where_clause.rb

@@ -0,0 +1,20 @@
+module AssociateJsonb
+  module Relation
+    module WhereClause
+      def to_h(table_name = nil)
+        equalities = equalities(predicates)
+        if table_name
+          equalities = equalities.select do |node|
+            node.original_left.relation.name == table_name
+          end
+        end
+
+        equalities.map { |node|
+          name = node.original_left.name.to_s
+          value = extract_node_value(node.right)
+          [name, value]
+        }.to_h
+      end
+    end
+  end
+end

data/lib/associate_jsonb/version.rb

@@ -0,0 +1,6 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
+module AssociateJsonb
+  VERSION = "0.0.1"
+end

data/lib/associate_jsonb/with_store_attribute.rb

@@ -0,0 +1,156 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
+module AssociateJsonb
+  module WithStoreAttribute
+    extend ActiveSupport::Concern
+
+    class StoreColumnAttributeTracker < Module #:nodoc:
+      include Mutex_m
+
+      def names_list
+        @names_list ||= {}
+      end
+
+      def add_name(name, store, key)
+        @names_list ||= {}
+        @names_list[name.to_s.freeze] = { store: store, key: key }
+      end
+
+      def has_name?(name)
+        names_list.key? name.to_s
+      end
+    end
+
+    included do
+      instance_eval <<-CODE, __FILE__, __LINE__ + 1
+        initialize_store_column_attribute_tracker
+
+        after_initialize &set_store_column_attribute_values_on_init
+        after_commit &set_store_column_attribute_values_on_init
+      CODE
+    end
+
+    module ClassMethods
+      def inherited(child)
+        child.initialize_store_column_attribute_tracker
+        super
+      end
+
+      def initialize_store_column_attribute_tracker
+        @store_column_attribute_tracker = const_set(:StoreColumnAttributeTracker, StoreColumnAttributeTracker.new)
+        private_constant :StoreColumnAttributeTracker
+
+        store_column_attribute_tracker
+      end
+
+      def store_column_attribute_tracker
+        @store_column_attribute_tracker ||= initialize_store_column_attribute_tracker
+      end
+
+      def store_column_attribute_names
+        store_column_attribute_tracker.synchronize do
+          current_store_col_names = {}
+          current_store_col_names.merge!(super) if defined? super
+          current_store_col_names.merge!(store_column_attribute_tracker.names_list)
+        end
+      end
+
+      def add_store_column_attribute_name(name, store, key)
+        store_column_attribute_tracker.synchronize do
+          store_column_attribute_tracker.add_name(name, store, key)
+        end
+      end
+
+      def is_store_column_attribute?(name)
+        store_column_attribute_tracker.synchronize do
+          store_column_attribute_tracker.has_name?(name)
+        end
+      end
+
+      def set_store_column_attribute_values_on_init
+        lambda do
+          self.class.store_column_attribute_names.each do |attr, opts|
+            _write_attribute(attr, _read_attribute(opts[:store])[opts[:key]])
+            clear_attribute_change(attr) if persisted?
+          end
+        rescue
+          nil
+        end
+      end
+
+      def data_column_attribute(*args, **opts)
+        store_column_attribute :data, *args, **opts
+      end
+
+      def store_column_attribute(store, attr, *opts, key: nil, **attribute_opts)
+        store = store.to_sym
+        attr = attr.to_sym
+        key ||= attr
+        key = key.to_s
+        array = attribute_opts[:array]
+        attribute attr, *opts, **attribute_opts
+
+        instance_eval <<-CODE, __FILE__, __LINE__ + 1
+          add_store_column_attribute_name("#{attr}", :#{store}, "#{key}")
+        CODE
+
+        include WithStoreAttribute::InstanceMethodsOnActivation.new(self, store, attr, key, array)
+      end
+    end
+
+    class InstanceMethodsOnActivation < Module
+      def initialize(mixin, store, attribute, key, is_array)
+        is_array = !!(is_array && attribute.to_s =~ /_ids$/)
+        on_attr_change =
+           is_array \
+            ? "write_attribute(:#{attribute}, Array(given))" \
+            : "super(given)"
+        if is_array
+          mixin.class_eval <<-CODE, __FILE__, __LINE__ + 1
+            def #{attribute}
+              _read_attribute(:#{attribute}) || []
+            end
+          CODE
+        end
+
+        mixin.class_eval <<-CODE, __FILE__, __LINE__ + 1
+          def #{store}=(given)
+            given = super((given || {}).with_indifferent_access)
+            write_attribute(:#{attribute}, given["#{key}"])
+            given["#{key}"] = #{attribute} unless #{attribute}.nil?
+            super(given)
+          end
+
+          def #{attribute}=(given)
+            #{on_attr_change}
+            value = #{store}["#{key}"] = #{attribute}
+            #{store}.delete("#{key}") if value.nil?
+            _write_attribute(:#{store}, #{store})
+            value
+          end
+        CODE
+      end
+    end
+
+    def is_store_column_attribute?(name)
+      self.class.is_store_column_attribute?(name)
+    end
+
+    def [](k)
+      if is_store_column_attribute?(k)
+        self.public_send(k)
+      else
+        super
+      end
+    end
+
+    def []=(k, v)
+      if is_store_column_attribute?(k)
+        self.public_send(:"#{k}=", v)
+      else
+        super
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,172 @@
+--- !ruby/object:Gem::Specification
+name: associate_jsonb
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Sampson Crowley
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2020-07-14 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '6'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 6.0.3.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '6'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 6.0.3.1
+- !ruby/object:Gem::Dependency
+  name: pg
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.1'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.1.2
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.1'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.1.2
+- !ruby/object:Gem::Dependency
+  name: zeitwerk
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.2.2
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.2.2
+- !ruby/object:Gem::Dependency
+  name: mutex_m
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.1'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.1.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.1'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.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: |2
+      This gem extends ActiveRecord to let you use PostgreSQL JSONB data for associations
+
+      Inspired by activerecord-jsonb-associations, but for use in Rails 6+ and
+      ruby 2.7+ and with some unnecessary options and features (HABTM) removed
+
+      BONUS: extended `table#references` for easy migrations and indexes
+      (NOTE: real foreign key constraints are not possible with PostgreSQL JSONB)
+email:
+- sampsonsprojects@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- MIT-LICENSE
+- README.md
+- Rakefile
+- lib/associate_jsonb.rb
+- lib/associate_jsonb/arel_node_extensions/binary.rb
+- lib/associate_jsonb/arel_nodes/jsonb/at_arrow.rb
+- lib/associate_jsonb/arel_nodes/jsonb/bindable_operator.rb
+- lib/associate_jsonb/arel_nodes/jsonb/dash_arrow.rb
+- lib/associate_jsonb/arel_nodes/jsonb/dash_double_arrow.rb
+- lib/associate_jsonb/arel_nodes/jsonb/double_pipe.rb
+- lib/associate_jsonb/arel_nodes/jsonb/hash_arrow.rb
+- lib/associate_jsonb/arel_nodes/jsonb/operator.rb
+- lib/associate_jsonb/arel_nodes/sql_casted_equality.rb
+- lib/associate_jsonb/associations/association.rb
+- lib/associate_jsonb/associations/association_scope.rb
+- lib/associate_jsonb/associations/belongs_to_association.rb
+- lib/associate_jsonb/associations/builder/belongs_to.rb
+- lib/associate_jsonb/associations/builder/has_many.rb
+- lib/associate_jsonb/associations/builder/has_one.rb
+- lib/associate_jsonb/associations/conflicting_association.rb
+- lib/associate_jsonb/associations/has_many_association.rb
+- lib/associate_jsonb/associations/preloader/association.rb
+- lib/associate_jsonb/connection_adapters.rb
+- lib/associate_jsonb/connection_adapters/reference_definition.rb
+- lib/associate_jsonb/reflection.rb
+- lib/associate_jsonb/relation/where_clause.rb
+- lib/associate_jsonb/version.rb
+- lib/associate_jsonb/with_store_attribute.rb
+homepage: https://github.com/SampsonCrowley/associate_jsonb
+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.7'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.1.3
+signing_key:
+specification_version: 4
+summary: Store database references in PostgreSQL Jsonb columns
+test_files: []