associate_jsonb 0.0.7 → 0.0.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f0832e64c43e22ba206a98d0603c0e231c1606b17315f715a4050e19a1fdb21b
-  data.tar.gz: ff37b2777adf131f20ad9a95076d8797ecf30dc2ddeaa86913de5a457cf9fed4
+  metadata.gz: 9d9a2ca078138c49415e16c98a42191a1545502f41033ab7ec73494352fda01c
+  data.tar.gz: 312f1fa2f579903c190ec72a875a000f44f32cdb9df0e218e5b276a902bb4a92
 SHA512:
-  metadata.gz: 00fbd32bc9e66fa8bd85fcf9cab51850bc65443a99f66dbc3bcff5ca5d05e855624c62ac9a0aa7bcbed330a2650dbe149806c49bc3bb40ecd3aa6cdf002fde19
-  data.tar.gz: b134266f93576482f3558be28840081b803982ce369bd75497af2d9d2d2db30e3c27364247485ef2a4712705fb01183d80b812f6fa28f18d8f7db37db555bb88
+  metadata.gz: 524b2455ff9c493b76605d232af61e4dcb576b1262814d13c200db7a686026230be11f837230eb6116be1c0c8d6043360cf2f22c14209ce323d8fc7875760316
+  data.tar.gz: a76a0db4c95e3be203c397290f95110a5b8dce02a65c0fe6097df293be149e47e0d3252bf07482f679b562755f271e462f314635f3ce69ac5178a096de64965e

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/connection_adapters/schema_creation.rb

@@ -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;

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/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: associate_jsonb
 version: !ruby/object:Gem::Version
-  version: 0.0.7
+  version: 0.0.8
 platform: ruby
 authors:
 - Sampson Crowley
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2020-08-04 00:00:00.000000000 Z
+date: 2020-08-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails