associate_jsonb 0.0.7 → 6.1.4.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f0832e64c43e22ba206a98d0603c0e231c1606b17315f715a4050e19a1fdb21b
-  data.tar.gz: ff37b2777adf131f20ad9a95076d8797ecf30dc2ddeaa86913de5a457cf9fed4
+  metadata.gz: f26470e30b277fe8ef0189ca4bef7eacf8cf7d4fa22008a879f5c1b187f9c476
+  data.tar.gz: 28ca2bd98358795e4e9d6a59e14738536e7a2696e0b4eacb11612e5bc33840a6
 SHA512:
-  metadata.gz: 00fbd32bc9e66fa8bd85fcf9cab51850bc65443a99f66dbc3bcff5ca5d05e855624c62ac9a0aa7bcbed330a2650dbe149806c49bc3bb40ecd3aa6cdf002fde19
-  data.tar.gz: b134266f93576482f3558be28840081b803982ce369bd75497af2d9d2d2db30e3c27364247485ef2a4712705fb01183d80b812f6fa28f18d8f7db37db555bb88
+  metadata.gz: 6475d5e18d9c67d1b4b13a4770640ba79031357317dd185d77b8c959b8fdf1f59b52d6ee12fe1bed2e18652ed36747ce22c33af390bd63a3dbb87249c81479d2
+  data.tar.gz: 300b6fb1c2385bab73823765ee42d27e2b0a047efcf10b58727ad5e2973672910ca07a57ae76b64ff4ab32f006bf934d6376ddd975b9380600404d6264860955

data/README.md

@@ -2,97 +2,98 @@
 
 [![Gem Version](https://badge.fury.io/rb/associate_jsonb.svg)](https://badge.fury.io/rb/associate_jsonb)
 
-#### PostgreSQL JSONB extensions including:
-  - Basic ActiveRecord Associations using PostgreSQL JSONB columns, with built-in accessors and column indexes
-  - Thread-Safe JSONB updates (well, as safe as they can be) using a custom nested version of `jsonb_set` (`jsonb_nested_set`)
+#### Easy PostgreSQL JSONB extensions
+**including:**
+
+- Basic ActiveRecord Associations using PostgreSQL JSONB columns, with built-in accessors and column indexes
+- Thread-Safe JSONB updates (well, as safe as they can be) using a custom nested version of `jsonb_set` (`jsonb_nested_set`)
 
 **Requirements:**
 
 - PostgreSQL (>= 12)
 - Rails 6.0.3.2
 
-## Usage
+## Installation
 
-### Jsonb Associations
+Add this line to your application's Gemfile:
 
+```ruby
+gem 'associate_jsonb'
+```
 
-### jsonb_set based hash updates
+And then execute:
 
-When enabled, *only* keys present in the updated hash and with values changed in memory will be updated.
-To completely delete a key, value pair from an enabled attribute, set the key's value to `nil`.
+```bash
+$ bundle install
+```
 
-e.g.
-```ruby
-# given: instance#data == { "key_1"=>1,
-#                           "key_2"=>2,
-#                           "key_3"=> { "key_4"=>7,
-#                                       "key_5"=>8,
-#                                       "key_6"=>9 } }
+## Usage
 
-instance.update({ key_1: "asdf", a: 1, key_2: nil, key_3: { key_5: nil }})
-# instance#data => { "key_1"=>"asdf",
-#                    "a"=>"asdf",
-#                    "key_3"=> { "key_4"=>7,
-#                                "key_6"=>9 } }
+### Jsonb Associations
 
-```
+#### One-to-One and One-to-Many associations
+
+To set up your jsonb column, you can use the built in `add_reference`/`table.references` function. This will only add a new store column if it doesn't already exist
 
-#### enabling/adding attribute types
-first, create the sql function
 ```bash
-rails g migration add_jsonb_nested_set_function
+rails g migration add_foreign_key_store_to_my_table
 ```
 ```ruby
-class CreateState < ActiveRecord::Migration[6.0]
-  def up
-    add_jsonb_nested_set_function
+class AddForeignKeyStoreToMyTable < ActiveRecord::Migration[6.0]
+  def change
+    add_reference :my_table, :user, store: :extra # => store created
+    add_reference :my_table, :label, store: :extra, null: false # => store already exists, NOT NULL check constraint added to `store->'label_id'`
+    # NOTE: you can also use a `change_table(:my_table) block`
   end
 end
 ```
 
-then in an initializer, enable key based updates:
+and
+
 ```ruby
-# config/initializers/associate_jsonb.rb
-AssociateJsonb.enable_jsonb_set
+class CreateMyTable < ActiveRecord::Migration[6.0]
+  def change
+    create_table(:my_table) do |t|
+      t.references :user, store: :extra
+      t.references :label, store: :extra, null: false
+    end
+  end
+end
 ```
 
-Key based updates rely on inheritance for allowed attribute types. Any attributes that respond true to `attr_type.is_a?(GivenClass)` for any enabled type classes will use `jsonb_nested_set`
-
-To add classes to the enabled list, pass them as arguments to `AssociateJsonb.add_hash_type(*klasses)`. Any arguments passed to `AssociateJsonb.enable_jsonb_set` are forwarded to `AssociateJsonb.add_hash_type`
-
-By default, calling `AssociateJsonb.enable_jsonb_set(*klasses)` without arguments, and no classes previously added, adds `ActiveRecord::ConnectionAdapters::PostgreSQL::OID::Jsonb` to the allowed classes list
+If you add the `jsonb_foreign_key` function to your database, you can also create a foreign_key **check** constraint by using the same built-in `:foreign_key` option used in normal reference definitions.
 
-#### disabling/removing attribute types
-by default `jsonb_nested_set` updates are disabled.
-
-if you've enabled them and need to disable, use: `AssociateJsonb.disable_jsonb_set`
-
-To remove a class from the allowed list while leaving nested set updates enabled, use `AssociateJsonb.remove_hash_type(*klasses)`.
-Any arguments passed to `AssociateJsonb.disable_jsonb_set` are forwarded to `AssociateJsonb.remove_hash_type`
-
-### Automatically delete nil value hash keys
-
-When jsonb_set updates are disabled, jsonb columns are replaced with the current document (i.e. default rails behavior)
+**NOTE**: true foreign key references are not possible with jsonb attributes. This will instead create a CHECK constraint that looks for the referenced column using an `EXISTS` statement
 
-You are also given the option to automatically clear nil/null values from the hash automatically
-
-in an initializer, enable stripping nil values:
+```bash
+rails g migration add_jsonb_foreign_key_function
+```
 ```ruby
-# config/initializers/associate_jsonb.rb
-AssociateJsonb.jsonb_delete_nil = true
+class AddJsonbForeignKeyFunction < ActiveRecord::Migration[6.0]
+  def up
+    add_jsonb_foreign_key_function
+  end
+end
+```
+```ruby
+class CreateMyTable < ActiveRecord::Migration[6.0]
+  def change
+    create_table(:my_table) do |t|
+      t.references :user, store: :extra, foreign_key: true, null: false
+    end
+  end
+end
+```
+```ruby
+class CreateMyTable < ActiveRecord::Migration[6.0]
+  def change
+    create_table(:my_table) do |t|
+      t.references :person, store: :extra, foreign_key: { to_table: :users }, null: false
+    end
+  end
+end
 ```
 
-Rules for classes to with this applies are the same as for `jsonb_nested_set`; add and remove classes through `AssociateJsonb.(add|remove)_hash_type(*klasses)`
-
-<!-- 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:
 
@@ -115,49 +116,87 @@ class User < ActiveRecord::Base
 end
 ```
 
-Foreign keys for association on one model have to be unique, even if they use different store column.
+### Many-to-Many associations
 
-You can also use `add_references` in your migration to add JSONB column and index for it (if `index: true` option is set):
+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
+
+### jsonb_set based hash updates
+
+When enabled, *only* keys present in the updated hash and with values changed in memory will be updated.
+To completely delete a `key/value` pair from an enabled attribute, set the key's value to `nil`.
+
+e.g.
 
 ```ruby
-add_reference :profiles, :users, store: :extra, index: true
+# given: instance#data == { "key_1"=>1,
+#                           "key_2"=>2,
+#                           "key_3"=> { "key_4"=>7,
+#                                       "key_5"=>8,
+#                                       "key_6"=>9 } }
+
+instance.update({ key_1: "asdf", a: 1, key_2: nil, key_3: { key_5: nil }})
+
+# instance#data => { "key_1"=>"asdf",
+#                    "a"=>"asdf",
+#                    "key_3"=> { "key_4"=>7,
+#                                "key_6"=>9 } }
 ```
 
-### Many-to-many associations
+#### enabling/adding attribute types
 
-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
+first, create the sql function
+
+```bash
+rails g migration add_jsonb_nested_set_function
+```
+```ruby
+class AddJsonbNestedSetFunction < ActiveRecord::Migration[6.0]
+  def up
+    add_jsonb_nested_set_function
+  end
+end
+```
 
-#### Performance
+then in an initializer, enable key based updates:
 
-Compared to regular associations, fetching models associated via JSONB column has no drops in performance.
+```ruby
+# config/initializers/associate_jsonb.rb
+AssociateJsonb.enable_jsonb_set
+```
 
-Getting the count of connected records is ~35% faster with associations via JSONB (tested on associations with up to 10 000 connections).
+- Key based updates rely on inheritance for allowed attribute types. Any attributes that respond true to `attr_type.is_a?(GivenClass)` for any enabled type classes will use `jsonb_nested_set`
 
-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:
+- To add classes to the enabled list, pass them as arguments to `AssociateJsonb.add_hash_type(*klasses)`. Any arguments passed to `AssociateJsonb.enable_jsonb_set` are forwarded to `AssociateJsonb.add_hash_type`
 
-<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">
+- By default, calling `AssociateJsonb.enable_jsonb_set(*klasses)` without arguments, and no classes previously added, adds `ActiveRecord::ConnectionAdapters::PostgreSQL::OID::Jsonb` to the allowed classes list
 
-On the other hand, unassociating models from a big amount of associated models if faster with JSONB HABTM as the associations count grows:
+#### disabling/removing attribute types
 
-<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">
+- by default `jsonb_nested_set` updates are disabled.
 
-## Installation
+- if you've enabled them and need to disable, use: `AssociateJsonb.disable_jsonb_set`
 
-Add this line to your application's Gemfile:
+- To remove a class from the allowed list while leaving nested set updates enabled, use `AssociateJsonb.remove_hash_type(*klasses)`.
+Any arguments passed to `AssociateJsonb.disable_jsonb_set` are forwarded to `AssociateJsonb.remove_hash_type`
 
-```ruby
-gem 'associate_jsonb'
-```
+### Automatically delete nil value hash keys
 
-And then execute:
+When jsonb_set updates are disabled, jsonb columns are replaced with the current document (i.e. default rails behavior)
 
-```bash
-$ bundle install
+You are also given the option to automatically clear nil/null values from the hash automatically when jsonb_set is disabled
+
+in an initializer:
+
+```ruby
+# config/initializers/associate_jsonb.rb
+AssociateJsonb.jsonb_delete_nil = true
 ```
 
+Rules for classes to which this applies are the same as for `jsonb_nested_set`; add and remove classes through `AssociateJsonb.(add|remove)_hash_type(*klasses)`
+
 ## Developing
 
-To setup development environment, just run:
+To setup development environment, run:
 
 ```bash
 $ bin/setup
@@ -169,11 +208,6 @@ To run specs:
 $ 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

@@ -4,13 +4,11 @@ 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.title    = 'AssociateJsonb'
   rdoc.options << '--line-numbers'
   rdoc.rdoc_files.include('README.md')
   rdoc.rdoc_files.include('lib/**/*.rb')

data/lib/associate_jsonb/arel_nodes/sql_casted_equality.rb

@@ -1,28 +1,6 @@
 # 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
-
-
-# encoding: utf-8
-# frozen_string_literal: true
-
 module AssociateJsonb
   module ArelNodes
     class SqlCastedEquality < AssociateJsonb::ArelNodes::SqlCastedBinary

data/lib/associate_jsonb/associations/alias_tracker.rb

@@ -5,8 +5,8 @@ require "active_support/core_ext/string/conversions"
 module AssociateJsonb
   module Associations
     module AliasTracker # :nodoc:
-      def aliased_table_for(table_name, aliased_name, type_caster, store_tracker = nil)
-        super(table_name, aliased_name, type_caster).with_store_tracker(store_tracker)
+      def aliased_table_for(arel_table, table_name = nil, store_tracker: nil)
+        super(arel_table, table_name).with_store_tracker(store_tracker)
       end
     end
   end

data/lib/associate_jsonb/associations/association.rb

@@ -12,28 +12,14 @@ module AssociateJsonb
         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
+          attributes[reflection.foreign_key.to_s] = attributes.delete(reflection.foreign_store_key.to_s)
         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

@@ -4,17 +4,13 @@
 module AssociateJsonb
   module Associations
     module AssociationScope #:nodoc:
-
       def get_chain(reflection, association, tracker)
         name = reflection.name
         chain = [ActiveRecord::Reflection::RuntimeReflection.new(reflection, association)]
         reflection.chain.drop(1).each do |refl|
-          aliased_table = tracker.aliased_table_for(
-            refl.table_name,
-            refl.alias_candidate(name),
-            refl.klass.type_caster,
-            refl.klass.store_column_attribute_tracker
-          )
+          aliased_table = tracker.aliased_table_for(refl.klass.arel_table, store_tracker: refl.klass.store_column_attribute_tracker) do
+            refl.alias_candidate(name)
+          end
           chain << ActiveRecord::Associations::AssociationScope::ReflectionProxy.new(refl, aliased_table)
         end
         chain
@@ -25,18 +21,19 @@ module AssociateJsonb
         reflection = owner_reflection.instance_variable_get(:@reflection)
         return super unless reflection&.foreign_store?
 
+        primary_key = reflection.join_primary_key
+        foreign_key = reflection.join_foreign_key
+        store_key = reflection.foreign_store_key || primary_key
 
-        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])
+        value = transform_value(owner[foreign_key])
 
         apply_jsonb_equality(
           scope,
           table,
           reflection.foreign_store_attr,
-          key.to_s,
-          join_keys.foreign_key,
+          store_key.to_s,
+          owner_reflection.join_foreign_key,
           value,
           reflection.active_record
         )

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

@@ -5,6 +5,29 @@ module AssociateJsonb
   module Associations
     module Builder
       module BelongsTo #:nodoc:
+        # Maybe convert to builder callbacks here in next iteration
+        # def define_callbacks(model, reflection)
+        #   super
+        #   add_after_jsonb_initialize_callbacks(model, reflection) if reflection.jsonb_store?
+        #   add_after_foreign_store_initialize_callbacks(model, reflection) if reflection.foreign_store?
+        # end
+        #
+        # def add_after_jsonb_initialize_callbacks(model, reflection)
+        #   model.after_initialize lambda {|record|
+        #     association = association(reflection.name)
+        #     p model, reflection.join_primary_key, reflection.join_foreign_key, reflection.options
+        #     p record.attributes
+        #     # record.attributes._write_attribute()
+        #   }
+        # end
+        #
+        # def add_after_foreign_store_initialize_callbacks(model, reflection)
+        #   model.after_initialize lambda {|record|
+        #     association = association(reflection.name)
+        #     # record.attributes._write_attribute()
+        #   }
+        # end
+
         def valid_options(options)
           super + %i[ store store_key ]
         end
@@ -18,7 +41,7 @@ module AssociateJsonb
         end
 
         def add_association_accessor_methods(mixin, reflection)
-          foreign_key = reflection.foreign_key.to_s
+          foreign_key = reflection.join_foreign_key.to_s
           key = (reflection.jsonb_store_key || foreign_key).to_s
           store = reflection.jsonb_store_attr
 
@@ -35,8 +58,8 @@ module AssociateJsonb
           foreign_type = :integer
           sql_type = "numeric"
           begin
-            primary_key = reflection.active_record_primary_key.to_s
-            primary_column = reflection.klass.columns.find {|col| col.name == primary_key }
+            primary_key = reflection.join_primary_key.to_s
+            primary_column = reflection.klass.columns_hash[primary_key]
 
             if primary_column
               foreign_type = primary_column.type

data/lib/associate_jsonb/associations/foreign_association.rb

@@ -0,0 +1,23 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
+module AssociateJsonb
+  module Associations
+    module ForeignAssociation # :nodoc:
+      private
+        # Sets the owner attributes on the given record
+        def set_owner_attributes(record)
+          return if options[:through]
+          return super unless reflection.foreign_store?
+
+          jsonb_store = reflection.foreign_store_attr.to_s
+          value = record._read_attribute(jsonb_store).presence || {}
+          fk_value = owner._read_attribute(reflection.join_foreign_key)
+          value[reflection.foreign_store_key] = fk_value
+
+          record._write_attribute(reflection.join_primary_key, fk_value)
+          record._write_attribute(jsonb_store, value)
+        end
+    end
+  end
+end

data/lib/associate_jsonb/associations/join_dependency.rb

@@ -6,15 +6,28 @@ module AssociateJsonb
   module Associations
     module JoinDependency # :nodoc:
       private
-        def table_aliases_for(parent, node)
-          node.reflection.chain.map { |reflection|
-            alias_tracker.aliased_table_for(
-              reflection.table_name,
-              table_alias_for(reflection, parent, reflection != node.reflection),
-              reflection.klass.type_caster,
-              reflection.klass.store_column_attribute_tracker
-            )
-          }
+        def make_constraints(parent, child, join_type)
+          foreign_table = parent.table
+          foreign_klass = parent.base_klass
+          child.join_constraints(foreign_table, foreign_klass, join_type, alias_tracker) do |reflection|
+            table, terminated = @joined_tables[reflection]
+            root = reflection == child.reflection
+
+            if table && (!root || !terminated)
+              @joined_tables[reflection] = [table, root] if root
+              next table, true
+            end
+
+            table_name = @references[reflection.name.to_sym]&.to_s
+
+            table = alias_tracker.aliased_table_for(reflection.klass.arel_table, table_name, store_tracker: reflection.klass.store_column_attribute_tracker) do
+              name = reflection.alias_candidate(parent.table_name)
+              root ? name : "#{name}_join"
+            end
+
+            @joined_tables[reflection] ||= [table, root] if join_type == Arel::Nodes::OuterJoin
+            table
+          end.concat child.children.flat_map { |c| make_constraints(child, c, join_type) }
         end
     end
   end

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

@@ -18,6 +18,30 @@ module AssociateJsonb
             ).intersects_with(ids)
           )
         end
+
+        private
+          def load_records
+            return super unless reflection.foreign_store?
+            # owners can be duplicated when a relation has a collection association join
+            # #compare_by_identity makes such owners different hash keys
+            @records_by_owner = {}.compare_by_identity
+            raw_records = owner_keys.empty? ? [] : records_for(owner_keys)
+
+            @preloaded_records = raw_records.select do |record|
+              assignments = false
+
+              owners_by_key[convert_key(record[association_key_name])].each do |owner|
+                entries = (@records_by_owner[owner] ||= [])
+
+                if reflection.collection? || entries.empty?
+                  entries << record
+                  assignments = true
+                end
+              end
+
+              assignments
+            end
+          end
       end
     end
   end

data/lib/associate_jsonb/attribute_methods.rb

@@ -11,8 +11,8 @@ module AssociateJsonb
 
     private
       def attributes_with_info(attribute_names)
-        attribute_names.each_with_object({}) do |name, attrs|
-          attrs[name] = _fetch_attribute(name)
+        attribute_names.index_with do |name|
+          _fetch_attribute(name)
         end
       end
   end

data/lib/associate_jsonb/connection_adapters/schema_creation.rb

@@ -30,7 +30,7 @@ module AssociateJsonb
           end
 
           create_sql << "(#{statements.join(', ')})" if statements.present?
-          add_table_options!(create_sql, table_options(o))
+          add_table_options!(create_sql, o)
           create_sql << " AS #{to_sql(o.as)}" if o.as
           create_sql
         end
@@ -89,11 +89,16 @@ module AssociateJsonb
             DECLARE
               does_exist BOOLEAN;
             BEGIN
-              IF store->key IS NULL
+              IF store->>key IS NULL
               THEN
                 return nullable;
               END IF;
 
+              IF store->>key = ''
+              THEN
+                return FALSE;
+              END IF;
+
               EXECUTE FORMAT('SELECT EXISTS (SELECT 1 FROM %1$I WHERE %1$I.%2$I = CAST($1 AS ' || type || '))', table_name, foreign_key)
               INTO does_exist
               USING store->>key;
@@ -151,8 +156,9 @@ module AssociateJsonb
         def add_column_options!(sql, opts)
           super
 
-          if opts[:constraint]
-            sql << " #{accept(ConstraintDefinition.new(**opts[:constraint]))}"
+          if constraint_opts = opts[:constraint]
+            constraint_opts = { value: constraint_opts } unless constraint_opts.is_a?(Hash)
+            sql << " #{accept(ConstraintDefinition.new(**constraint_opts))}"
           end
 
           sql

data/lib/associate_jsonb/connection_adapters/schema_definitions/reference_definition.rb

@@ -60,11 +60,25 @@ module AssociateJsonb
               deferrable: true
             )
           end
+        elsif !nullable
+          columns.each do |col_name, *|
+            value = <<-SQL.squish
+              #{store}->>'#{col_name}' IS NOT NULL
+              AND
+              #{store}->>'#{col_name}' <> ''
+            SQL
+            table.constraint(
+              name: "#{table.name}_#{col_name}_not_null",
+              value: value,
+              not_valid: false,
+              deferrable: true
+            )
+          end
         end
 
         return unless index
 
-        columns.each do |col_name, type, opts|
+        columns.each do |col_name, type, *|
           type = :text if type == :string
           table.index(
             "CAST (\"#{store}\"->>'#{col_name}' AS #{type || :bigint})",

data/lib/associate_jsonb/connection_adapters/schema_statements.rb

@@ -12,38 +12,43 @@ module AssociateJsonb
         execute schema_creation.accept(AddJsonbForeignKeyFunction.new)
       end
 
-      def create_table(table_name, **options)
-        td = create_table_definition(table_name, **options)
+      def create_table(table_name, id: :primary_key, primary_key: nil, force: nil, **options)
+        td = create_table_definition(table_name, **extract_table_options!(options))
 
-        if options[:id] != false && !options[:as]
-          pk = options.fetch(:primary_key) do
-            ActiveRecord::Base.get_primary_key table_name.to_s.singularize
+        if id && !td.as
+          pk = primary_key || ActiveRecord::Base.get_primary_key(table_name.to_s.singularize)
+
+          if id.is_a?(Hash)
+            options.merge!(id.except(:type))
+            id = id.fetch(:type, :primary_key)
           end
 
           if pk.is_a?(Array)
             td.primary_keys pk
           else
-            td.primary_key pk, options.fetch(:id, :primary_key), **options.except(:comment)
+            td.primary_key pk, id, **options
           end
         end
 
         yield td if block_given?
 
-        if options[:force]
-          drop_table(table_name, **options, if_exists: true)
+        if force
+          drop_table(table_name, force: force, if_exists: true)
+        else
+          schema_cache.clear_data_source_cache!(table_name.to_s)
         end
 
         result = execute schema_creation.accept td
 
         td.indexes.each do |column_name, index_options|
-          add_index(table_name, column_name, index_options)
+          add_index(table_name, column_name, **index_options, if_not_exists: td.if_not_exists)
         end
 
         td.constraints.each do |ct|
           add_constraint(table_name, **ct)
         end
 
-        if table_comment = options[:comment].presence
+        if table_comment = td.comment.presence
           change_table_comment(table_name, table_comment)
         end
 

data/lib/associate_jsonb/reflection.rb

@@ -18,7 +18,7 @@ module AssociateJsonb
     end
 
     def jsonb_store_key
-      options[:store_key].presence || join_keys.foreign_key
+      options[:store_key].presence || join_foreign_key
     end
 
     def foreign_store?
@@ -36,7 +36,7 @@ module AssociateJsonb
     end
 
     def foreign_store_key
-      options[:foreign_store_key].presence || join_keys.key
+      options[:foreign_store_key].presence || join_primary_key
     end
 
     def join_scope(table, foreign_table, foreign_klass)
@@ -52,8 +52,8 @@ module AssociateJsonb
 
       scope_chain_items.inject(klass_scope, &:merge!)
 
-      key         = join_keys.key
-      foreign_key = join_keys.foreign_key
+      key         = join_primary_key
+      foreign_key = join_foreign_key
 
       if foreign_store?
         klass_scope.where!(

data/lib/associate_jsonb/relation/where_clause.rb

@@ -4,36 +4,14 @@
 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|
+      def to_h(table_name = nil, equality_only: false)
+        equalities(predicates, equality_only).each_with_object({}) do |node, hash|
+          next if table_name&.!= node.original_left.relation.name
           name = node.original_left.name.to_s
           value = extract_node_value(node.right)
-          [name, value]
-        }.to_h
-      end
-
-      private
-        def equalities(predicates)
-          equalities = []
-
-          predicates.each do |node|
-            case node
-            when Arel::Nodes::Equality, Arel::Nodes::SqlCastedEquality
-              equalities << node
-            when Arel::Nodes::And
-              equalities.concat equalities(node.children)
-            end
-          end
-
-          equalities
+          hash[name] = value
         end
+      end
     end
   end
 end

data/lib/associate_jsonb/supported_rails_version.rb

@@ -2,5 +2,5 @@
 # frozen_string_literal: true
 
 module AssociateJsonb
-  SUPPORTED_RAILS_VERSION = "6.0.3.2"
+  SUPPORTED_RAILS_VERSION = "6.1.4.1"
 end

data/lib/associate_jsonb/version.rb

@@ -2,5 +2,5 @@
 # frozen_string_literal: true
 
 module AssociateJsonb
-  VERSION = "0.0.7"
+  VERSION = "6.1.4.1.1"
 end

data/lib/associate_jsonb/with_store_attribute.rb

@@ -99,15 +99,15 @@ module AssociateJsonb
       end
 
       def store_column_attribute(store, attr, cast_type = ActiveRecord::Type::Value.new, sql_type: nil, key: nil, **attribute_opts)
-        store = store.to_sym
-        attr = attr.to_sym
+        store = store.to_s
+        attr = attr.to_s
         key ||= attr
         key = key.to_s
         array = attribute_opts[:array]
         attribute attr, cast_type, **attribute_opts
 
         instance_eval <<~CODE, __FILE__, __LINE__ + 1
-          add_store_column_attribute_name("#{attr}", :#{store}, "#{key}", { sql_type: sql_type, type: cast_type, opts: attribute_opts })
+          add_store_column_attribute_name(attr, store, key, { sql_type: sql_type, type: cast_type, opts: attribute_opts })
         CODE
 
         include WithStoreAttribute::InstanceMethodsOnActivation.new(self, store, attr, key, array)
@@ -120,9 +120,9 @@ module AssociateJsonb
 
         array_or_attr = ->(value) {
           is_array \
-           ? %Q(Array(#{value})) \
-           : %Q(#{value})
-         }
+            ? %Q(Array(#{value})) \
+            : %Q(#{value})
+        }
 
         on_store_change = "_write_attribute(:#{attribute}, #{array_or_attr.call %Q(#{store}["#{key}"])})"
         on_attr_change = "super(#{array_or_attr.call %Q(given)})"

data/lib/associate_jsonb.rb

@@ -20,64 +20,106 @@ loader.collapse("#{__dir__}/associate_jsonb/connection_adapters/schema_definitio
 loader.setup # ready!
 
 module AssociateJsonb
-  mattr_accessor :jsonb_hash_types, default: []
-  mattr_accessor :jsonb_set_removed, default: []
+  mattr_accessor :jsonb_hash_types,  default: []
+  mattr_accessor :jsonb_set_added,   default: [] # :nodoc:
+  mattr_accessor :jsonb_set_removed, default: [] # :nodoc:
   mattr_accessor :jsonb_set_enabled, default: false
-  mattr_accessor :jsonb_delete_nil, default: false
+  mattr_accessor :jsonb_delete_nil,  default: false
   private_class_method :jsonb_hash_types=
   private_class_method :jsonb_set_enabled=
 
+  def self.jsonb_oid_class # :nodoc:
+    :default
+  end
+  private_class_method :jsonb_oid_class
+
+  ##
+  # Enables the use of `jsonb_nested_set` for hash updates
+  #
+  # if passed a class, or a list of classes, those classes will be added to
+  # the enabled classes. if no argument is given, and the enabled class list is
+  # empty, `ActiveRecord::ConnectionAdapters::PostgreSQL::OID::Jsonb` is added
+  # to the list of enabled classes
   def self.enable_jsonb_set(klass = nil, *classes)
-    add_hash_type(*Array(klass), *classes) unless klass.nil?
+    if klass.nil?
+      add_hash_type jsonb_oid_class if jsonb_hash_types.empty?
+    else
+      add_hash_type(*Array(klass), *classes)
+    end
     self.jsonb_set_enabled = true
   end
 
+  ##
+  # Disables the use of `jsonb_nested_set` for hash updates
+  #
+  # if passed a class, or a list of classes, those classes will be removed from
+  # the list of enabled classes
   def self.disable_jsonb_set(klass = nil, *classes)
     remove_hash_type(*Array(klass), *classes) unless klass.nil?
     self.jsonb_set_enabled = false
   end
 
+  ##
+  # Add class(es) to the list of classes that are able to be upated when
+  # `jsonb_set_enabled` is true
   def self.add_hash_type(*classes)
-    self.jsonb_hash_types |= classes.flatten
+    self.jsonb_set_added |= classes.flatten
   end
 
+  ##
+  # Remove class(es) from the list of classes that are able to be upated when
+  # `jsonb_set_enabled` is true
   def self.remove_hash_type(*classes)
     self.jsonb_set_removed |= classes.flatten
   end
 
-  def self.merge_hash?(v)
-    return false unless jsonb_set_enabled && v
-    self.jsonb_hash_types.any? { |type| v.is_a?(type) }
+  ##
+  # Returns true if `jsonb_set_enabled` is true and the value is an enabled hash
+  # type
+  def self.merge_hash?(value)
+    !!jsonb_set_enabled && is_hash?(value)
   end
 
-  def self.is_hash?(v)
-    self.jsonb_hash_types.any? { |type| v.is_a?(type) }
+  ##
+  # Returns true if the given value is a descendant of any of the classes
+  # in `jsonb_hash_types`
+  def self.is_hash?(value)
+    !!value && self.jsonb_hash_types.any? { |type| value.is_a?(type) }
   end
 end
 
-
 # rubocop:disable Metrics/BlockLength
 ActiveSupport.on_load :active_record do
   loader.eager_load
-  AssociateJsonb.class_eval do
-    def self.enable_jsonb_set(klass = nil, *classes)
-      if klass.nil?
-        add_hash_type ActiveRecord::ConnectionAdapters::PostgreSQL::OID::Jsonb if jsonb_hash_types.empty?
-      else
-        add_hash_type |= [*Array(klass), *classes].flatten
+  AssociateJsonb.module_eval do
+    redefine_method = proc {|name, hide = false, &block|
+      method(name).owner.remove_method name
+      if block
+        define_singleton_method(name, &block)
+        private_class_method name if hide
       end
-      self.jsonb_set_enabled = true
+    }
+
+    redefine_method.call(:jsonb_oid_class, true) do
+      ActiveRecord::ConnectionAdapters::PostgreSQL::OID::Jsonb
     end
 
-    self.enable_jsonb_set if jsonb_set_enabled
+    redefine_method.call(:add_hash_type) do |*classes|
+      self.jsonb_hash_types |= classes.flatten
+    end
 
-    def self.remove_hash_type(*classes)
+    redefine_method.call(:remove_hash_type) do |*classes|
       self.jsonb_hash_types -= classes.flatten
     end
-    removed = jsonb_set_removed
-    self.remove_hash_type removed
-    self.send :remove_method, :jsonb_set_removed
-    self.send :remove_method, :jsonb_set_removed=
+
+    self.add_hash_type jsonb_set_added.map {|k| (k == :default) ? self.jsonb_oid_class : k}
+    self.remove_hash_type jsonb_set_removed
+
+    redefine_method.call(:jsonb_set_added)
+    redefine_method.call(:jsonb_set_added=)
+    redefine_method.call(:jsonb_set_removed)
+    redefine_method.call(:jsonb_set_removed=)
+    redefine_method = nil
   end
 
 
@@ -145,9 +187,10 @@ ActiveSupport.on_load :active_record do
     AssociateJsonb::Associations::Preloader::Association
   )
 
-  # ActiveRecord::Associations::Preloader::HasMany.prepend(
-  #   AssociateJsonb::Associations::Preloader::HasMany
-  # )
+  ActiveRecord::Associations::ForeignAssociation.prepend(
+    AssociateJsonb::Associations::ForeignAssociation
+  )
+
   %i[
     AlterTable
     ConstraintDefinition

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: associate_jsonb
 version: !ruby/object:Gem::Version
-  version: 0.0.7
+  version: 6.1.4.1.1
 platform: ruby
 authors:
 - Sampson Crowley
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2020-08-04 00:00:00.000000000 Z
+date: 2021-09-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -16,20 +16,20 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 6.0.3
+        version: 6.1.4
     - - ">="
       - !ruby/object:Gem::Version
-        version: 6.0.3.2
+        version: 6.1.4.1
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 6.0.3
+        version: 6.1.4
     - - ">="
       - !ruby/object:Gem::Version
-        version: 6.0.3.2
+        version: 6.1.4.1
 - !ruby/object:Gem::Dependency
   name: pg
   requirement: !ruby/object:Gem::Requirement
@@ -96,14 +96,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 3.7.0
+        version: '3.9'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 3.7.0
+        version: '3.9'
 description: |
   This gem extends ActiveRecord to add additional functionality to JSONB
 
@@ -149,6 +149,7 @@ files:
 - 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/foreign_association.rb
 - lib/associate_jsonb/associations/has_many_association.rb
 - lib/associate_jsonb/associations/join_dependency.rb
 - lib/associate_jsonb/associations/preloader/association.rb
@@ -190,7 +191,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.1.3
+rubygems_version: 3.1.6
 signing_key:
 specification_version: 4
 summary: Store database references in PostgreSQL Jsonb columns