pgrel 0.1.3 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 291e1ba18186a87e551768d2a8fcee684e7a3e10ad146e27fdb7ffc060c072dc
-  data.tar.gz: 16bdf8ac60f413c6cde49868b7741d91b76cad8e6c38bd02e94127f9b4b580a3
+  metadata.gz: 43d4c6d3c7078b0823c3da86d1749db92e7b86f9759fb17326b3065780290649
+  data.tar.gz: ebf600d3ccb22d4bed4dc4f6a479c7f3c1aa65e300edebbcaaded0da9e8698cc
 SHA512:
-  metadata.gz: f69f2ec3caa4f59553c728bc1ad27728ecc10c497a83136772ed194b545a273ea85dd9fd4af54dd8d69bba4ec0bd44e6c04b4874118d68d29c131590c543c78b
-  data.tar.gz: 0fa1716133ca109594d50598575083bdf651846ea80db5da902256542f121d46b5391823bac35cca503481533db54b0d3844fc39f82121732cf9295f7fd4159f
+  metadata.gz: c7a7c10c700279fbc1943d44e478ddbc096fe35af24d1733b4cc95bf564322580c177abbc56c3e76f2ffcd69053229badab34b5e9cc53b496e1d8a638118f662
+  data.tar.gz: b8381c2b638a70e58c9159b3a8ab2a3ecd2261a305d376fa2346f91dc7130ff163caafbe237bfe4f0c3c503f51c28be15dbb95e7e20421478187f4bc29c4792e

data/.travis.yml

@@ -2,7 +2,7 @@ language: ruby
 cache: bundler
 
 addons:
-  postgresql: "9.4"
+  postgresql: "9.6"
 
 before_script:
   - createdb pgrel

data/CHANGELOG.md

@@ -0,0 +1,12 @@
+# Change log
+
+## master
+
+## 0.2.0 (2018-06-15)
+
+- Add `#update_store` methods. ([@StanisLove][])
+
+  See https://github.com/palkan/pgrel/pull/5.
+
+[@palkan]: https://github.com/palkan
+[@StanisLove]: https://github.com/StanisLove

data/README.md

@@ -6,21 +6,21 @@ ActiveRecord extension for querying hstore, array and jsonb.
 
 Compatible with **Rails** >= 4.2.
 
-### General
-
-The functionality is based on ActiveRecord `WhereChain`. 
-To start querying call `where(:store_name)` and chain it with store-specific call (see below).
-
 #### Install
 
 In your Gemfile:
 
 ```ruby
-gem "pgrel", "~>0.1"
+gem "pgrel", "~> 0.2"
 ```
 
 ### HStore
 
+#### Querying
+
+The functionality is based on ActiveRecord `WhereChain`. 
+To start querying call `where(:store_name)` and chain it with store-specific call (see below).
+
 Query by key value:
 
 ```ruby
@@ -29,6 +29,12 @@ Hstore.where.store(:tags, a: 1, b: 2)
 
 Hstore.where.store(:tags, a: [1, 2])
 #=> select * from hstores where (tags @> '"a"=>"1"' or tags @> '"a"=>"2"')
+
+Hstore.where.store(:tags, :a)
+#=> select * from hstores where (tags @> '"a"=>NULL')
+
+Hstore.where.store(:tags, { a: 1 }, { b: 2 })
+#=> select * from hstores where (tags @> '"a"=>"1" or tags @> "b"=>"2"')
 ```
 
 Keys existence:
@@ -47,6 +53,18 @@ Hstore.where.store(:tags).any('a', 'b')
 #=> select * from hstores where tags ?| array['a', 'b']
 ```
 
+Values existence:
+
+```ruby
+# Retrieve items that have value '1' OR '2'
+Hstore.where.store(:tags).value(1, 2)
+#=> select * from hstores where (avals(tags) @> ARRAY['1'] OR avals(tags) @> ARRAY['2'] )
+
+# Retrieve items that have values '1' AND '2'
+Hstore.where.store(:tags).values(1, 2)
+#=> select * from hstores where (avals(tags) @> ARRAY['1', '2'])
+```
+
 Containment:
 
 ```ruby
@@ -57,9 +75,33 @@ Hstore.where.store(:tags).contained(a: 1, b: 2)
 #=> select * from hstores where tags <@ '\"a\"=>\"1\", \"b\"=>\"2\"'
 ```
 
+#### Update
+
+Is implemented through `ActiveRecord::Store::FlexibleHstore` and `ActiveRecord::Store::FlexibleJsonb`
+objects. You can get them by sending `update_store(store_name)` to relation or class.
+
+Add key, value pairs:
+
+```ruby
+Hstore.update_store(:tags).merge(new_key: 1, one_more: 2)
+Hstore.update_store(:tags).merge([[:new_key, 1], [:one_more, 2]])
+```
+
+Delete keys:
+
+```ruby
+Hstore.update_store(:tags).delete_keys(:a, :b)
+```
+
+Delete key, value pairs:
+
+```ruby
+Hstore.update_store(:tags).delete_pairs(a: 1, b: 2)
+```
+
 ### JSONB
 
-All queries for Hstore also available for JSONB.
+All queries and updates for Hstore also available for JSONB.
 
 **NOTE**. Querying by array value always resolves to `(... or ...)` statement. 
 Thus it's impossible to query json array value, e.g.:

data/lib/pgrel/active_record.rb

@@ -1,4 +1,9 @@
 # frozen_string_literal: true
 
 require 'active_record'
+require 'pgrel/active_record/relation'
+require 'pgrel/active_record/store/flexible_store'
+require 'pgrel/active_record/store/flexible_hstore'
+require 'pgrel/active_record/store/flexible_jsonb'
+require 'pgrel/active_record/querying'
 require 'pgrel/active_record/query_methods'

data/lib/pgrel/active_record/querying.rb

@@ -0,0 +1,5 @@
+module ActiveRecord
+  module Querying
+    delegate :update_store, to: :all
+  end
+end

data/lib/pgrel/active_record/relation.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  class Relation
+    def update_store(store_name)
+      raise ArgumentError, "Empty store name to update" if store_name.blank?
+      type = type_for_attribute(store_name.to_s).type
+      raise TypeConflictError, store_type_error_msg(type) if %i(hstore jsonb).exclude?(type)
+      klass = "ActiveRecord::Store::Flexible#{type.capitalize}".constantize
+      klass.new(self, store_name)
+    end
+
+    private
+
+    def store_type_error_msg(type)
+      "Column type is not a known store: #{type}"
+    end
+  end
+end

data/lib/pgrel/active_record/store/flexible_hstore.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module Store
+    class FlexibleHstore < ActiveRecord::Store::FlexibleStore
+      def delete_keys(*keys)
+        keys = keys.flatten.map(&:to_s)
+        relation.update_all(["#{store_name} = delete(#{store_name}, ARRAY[:keys])", keys: keys])
+      end
+
+      def merge(pairs)
+        relation.update_all(["#{store_name} = hstore(#{store_name}) || hstore(ARRAY[:keys])",
+                            keys: pairs.to_a.flatten.map(&:to_s)])
+      end
+
+      def delete_pairs(pairs)
+        relation.update_all(
+          ["#{store_name} = delete(#{store_name}, hstore(ARRAY[:keys], ARRAY[:values]))",
+           keys: pairs.keys.map(&:to_s), values: pairs.values.map(&:to_s)]
+        )
+      end
+    end
+  end
+end

data/lib/pgrel/active_record/store/flexible_jsonb.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module Store
+    class FlexibleJsonb < ActiveRecord::Store::FlexibleStore
+      def delete_keys(*keys)
+        keys.flatten!
+        query = String.new "#{store_name} = #{store_name}"
+        keys.length.times { query.concat(' - ?') }
+        relation.update_all([query, *keys])
+      end
+
+      def merge(pairs)
+        relation.update_all(["#{store_name} = #{store_name} || ?::jsonb", pairs.to_json])
+      end
+
+      def delete_pairs(pairs)
+        keys = pairs.keys
+        pairs = pairs.map { |k,v| { k => v } }
+        @relation = relation.where.store(store_name, *pairs)
+        delete_keys(keys)
+      end
+    end
+  end
+end

data/lib/pgrel/active_record/store/flexible_store.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module Store
+    class FlexibleStore
+      attr_reader :relation, :store_name
+
+      def initialize(relation, store_name)
+        @relation, @store_name = relation, store_name
+      end
+    end
+  end
+end

data/lib/pgrel/active_record/store_chain.rb

@@ -68,16 +68,20 @@ module ActiveRecord
       #   Model.store(:store, b: [1, 2]).size #=> 2
       #   #=> (SQL) select * from ... where (store @> '"c"=>"1"'::hstore) or
       #                                     (store @> '"c"=>"2"'::hstore)
-      def where(opts)
+      def where(*opts)
+        opts.map! { |opt| opt.is_a?(Hash) ? opt : [opt] }
+
         update_scope(
-          opts.map do |k, v|
-            case v
-            when Array
-              "(#{build_or_contains(k, v)})"
-            else
-              contains_clause(k => v)
-            end
-          end.join(' and ')
+          opts.map do |opt|
+            opt.map do |k, v|
+              case v
+              when Array
+                "(#{build_or_contains(k, v)})"
+              else
+                contains_clause(k => v)
+              end
+            end.join(' and ')
+          end.join(' or ')
         )
         @scope
       end
@@ -196,10 +200,14 @@ module ActiveRecord
             rel.left = to_sql_literal(prefix, rel.left)
             rel
           end
-          where_clause = ActiveRecord::Relation::WhereClause.new(
-            predicates,
-            where_clause.binds
-          )
+
+          params = if ActiveRecord.version.release >= Gem::Version.new("5.2.0")
+                     [predicates]
+                   else
+                     [predicates, where_clause.binds]
+                   end
+
+          where_clause = ActiveRecord::Relation::WhereClause.new(*params)
           @scope.where_clause += @inverted ? where_clause.invert : where_clause
           @scope
         end

data/lib/pgrel/active_record/store_chain/hstore_chain.rb

@@ -4,6 +4,33 @@ module ActiveRecord
   module QueryMethods
     # Store chain for hstore columns.
     class HstoreChain < KeyStoreChain
+      # Value existence
+      #
+      # Example
+      #   Model.create!(name: 'first', store: {a: 1, b: 2})
+      #   Model.create!(name: 'second', store: {b: 1, c: 3})
+      #
+      #   Model.store(:store).value(1, 2).all
+      #   #=>[Model(name: 'first', ...), Model(name: 'second')]
+      def value(*values)
+        query = String.new
+        values.length.times do |n|
+          query.concat("avals(#{@store_name}) @> ARRAY[?]")
+          query.concat(' OR ') if n < values.length - 1
+        end
+        update_scope(query, *values.map(&:to_s))
+      end
+
+      # Values existence
+      #
+      # Example
+      #   Model.create!(name: 'first', store: {a: 1, b: 2})
+      #   Model.create!(name: 'second', store: {b: 1, c: 3})
+      #
+      #   Model.store(:store).values(1, 2).all #=> [Model(name: 'first', ...)]
+      def values(*values)
+        update_scope("avals(#{@store_name}) @> ARRAY[?]", values.map(&:to_s))
+      end
     end
   end
 end

data/lib/pgrel/active_record/store_chain/jsonb_chain.rb

@@ -33,6 +33,51 @@ module ActiveRecord
         where_with_prefix "#{@store_name}#{op}", path => val
       end
 
+      # Value existence
+      #
+      # Example
+      #   Model.create!(name: 'first', store: {a: 1, b: 2})
+      #   Model.create!(name: 'second', store: {b: 1, c: 3})
+      #
+      #   Model.store(:store).values(1, 2).all
+      #   #=>[Model(name: 'first', ...), Model(name: 'second')]
+      def value(*values)
+        query = String.new
+        values = values.map do |v|
+          case v
+          when Hash, Array, String
+            v.to_json
+          else
+            v.to_s
+          end
+        end
+
+        values.length.times do |n|
+          query.concat(value_existence_query)
+          query.concat(' OR ') if n < values.length - 1
+        end
+        update_scope(query, *values)
+      end
+
+      # Values existence
+      #
+      # Example
+      #   Model.create!(name: 'first', store: {a: 1, b: 2})
+      #   Model.create!(name: 'second', store: {b: 1, c: 3})
+      #
+      #   Model.store(:store).values(1, 2).all #=> [Model(name: 'first', ...)]
+      def values(*values)
+        values = values.map do |v|
+          case v
+          when Hash, Array, String
+            v.to_json
+          else
+            v.to_s
+          end
+        end
+        update_scope(value_existence_query, values)
+      end
+
       private
 
       def flatten_hash(hash)
@@ -45,6 +90,10 @@ module ActiveRecord
           hash
         end
       end
+
+      def value_existence_query
+        "(SELECT array_agg(value) FROM jsonb_each(#{@store_name})) @> ARRAY[?]::jsonb[]"
+      end
     end
   end
 end

data/lib/pgrel/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Pgrel # :nodoc:
-  VERSION = "0.1.3"
+  VERSION = "0.2.0"
 end

data/spec/pgrel/hstore_spec.rb

@@ -24,7 +24,9 @@ describe Hstore do
     Hstore.create!(name: 'c', tags: { f: true, d: 'b' })
     Hstore.create!(name: 'd', tags: { f: false })
     Hstore.create!(name: 'e', tags: { a: 2, c: 'x', d: 'c', g: 'c' })
+    Hstore.create!(name: 'f', tags: { i: [1, 2, { a: 1 }], j: { a: 1, b: [1], f: false } } )
     Hstore.create!(tags: { 1 => 2 })
+    Hstore.create!(name: 'z', tags: { z: nil })
   end
 
   context '#where' do
@@ -61,6 +63,21 @@ describe Hstore do
           ).size
         ).to eq 2
     end
+
+    it 'lonely keys' do
+      records = Hstore.where.store(:tags, [:z])
+      expect(records.size).to eq 1
+      expect(records.first.name).to eq 'z'
+    end
+
+    it 'many hashes' do
+      expect(Hstore.where.store(:tags, { a: 2 }, { b: 2 }).size).to eq 3
+    end
+
+    it 'many hashes and lonely keys' do
+      expect(Hstore.where.store(:tags, { a: 1 }, :z).size).to eq 2
+      expect(Hstore.where.store(:tags, { a: 1 }, [:z]).size).to eq 2
+    end
   end
 
   it '#key' do
@@ -82,6 +99,26 @@ describe Hstore do
     expect(records.first.name).to eq 'e'
   end
 
+  it '#value' do
+    records = Hstore.where.store(:tags).value(1, false, [1, 2, { a: 1 }])
+    expect(records.size).to eq 3
+  end
+
+  it '#values' do
+    records = Hstore.where.store(:tags).values(1)
+    expect(records.size).to eq 1
+    expect(records.first.name).to eq 'a'
+
+    records = Hstore.where.store(:tags).values('2', 'b')
+    expect(records.size).to eq 2
+
+    records = Hstore.where.store(:tags).values(true)
+    expect(records.size).to eq 2
+
+    records = Hstore.where.store(:tags).values([1, 2, { a: 1 }], { a: 1, b: [1], f: false })
+    expect(records.size).to eq 1
+  end
+
   it '#any' do
     records = Hstore.where.store(:tags).any('b', 'f')
     expect(records.size).to eq 3
@@ -116,16 +153,56 @@ describe Hstore do
 
   context '#not' do
     it '#where' do
-      expect(Hstore.where.store(:tags).not(a: 2).size).to eq 4
-      expect(Hstore.where.store(:tags).not(a: 1, g: 'c').size).to eq 6
+      expect(Hstore.where.store(:tags).not(a: 2).size).to eq 6
+      expect(Hstore.where.store(:tags).not(a: 1, g: 'c').size).to eq 8
     end
 
     it '#any' do
-      expect(Hstore.where.store(:tags).not.any('a', 'f').size).to eq 1
+      expect(Hstore.where.store(:tags).not.any('a', 'f').size).to eq 3
     end
 
     it '#keys' do
-      expect(Hstore.where.store(:tags).not.keys('a', 'f').size).to eq 5
+      expect(Hstore.where.store(:tags).not.keys('a', 'f').size).to eq 7
+    end
+  end
+
+  context "#update_store" do
+    let(:store) { :tags }
+
+    subject { Hstore.update_store(store) }
+
+    it "works on relation" do
+      Hstore.where.store(store).keys(:a).update_store(store).delete_keys(:a)
+      expect(Hstore.where.store(store).keys(:a)).to_not exist
+    end
+
+    it "#delete_keys" do
+      subject.delete_keys(:i)
+      expect(Hstore.where.store(store).keys(:i)).to_not exist
+
+      subject.delete_keys(:a, :b)
+      expect(Hstore.where.store(store).keys(:a)).to_not exist
+      expect(Hstore.where.store(store).keys(:b)).to_not exist
+
+      subject.delete_keys([:c, :d])
+      expect(Hstore.where.store(store).keys(:c)).to_not exist
+      expect(Hstore.where.store(store).keys(:d)).to_not exist
+    end
+
+    it "#merge" do
+      subject.merge(new_key: 1)
+      expect(Hstore.where.store(store).keys(:new_key).count).to be_eql Hstore.count
+
+      subject.merge([['new_key2', 'a'], ['new_key3', 'b']])
+      expect(Hstore.where.store(store).keys(:new_key2, :new_key3).count).to be_eql Hstore.count
+    end
+
+    it "#delete_pairs" do
+      subject.delete_pairs(f: true, a: 1)
+      expect(Hstore.where.store(store, f: true)).to_not exist
+      expect(Hstore.where.store(store, a: 1)).to_not exist
+      expect(Hstore.where.store(store, f: false)).to exist
+      expect(Hstore.where.store(store, a: 2)).to exist
     end
   end
 end

data/spec/pgrel/jsonb_spec.rb

@@ -25,6 +25,8 @@ describe Jsonb do
     Jsonb.create!(name: 'd', tags: { a: 1, b: { c: 'd', e: true } })
     Jsonb.create!(name: 'e', tags: { b: 2, c: 'e' })
     Jsonb.create!(name: 'f', tags: { d: { e: 1, f: { h: { k: 'a', s: 2 } } } })
+    Jsonb.create!(name: 'g', tags: { f: false, g: { a: 1, b: '1' }, h: [1, '1'] })
+    Jsonb.create!(name: 'z', tags: { z: nil } )
   end
 
   context '#where' do
@@ -44,6 +46,21 @@ describe Jsonb do
     it 'arrays (as IN)' do
       expect(Jsonb.where.store(:tags, a: [1, 2, 3]).size).to eq 3
     end
+
+    it 'lonely keys' do
+      records = Jsonb.where.store(:tags, [:z])
+      expect(records.size).to eq 1
+      expect(records.first.name).to eq 'z'
+    end
+
+    it 'many hashes' do
+      expect(Jsonb.where.store(:tags, { a: 2 }, { b: 2 }).size).to eq 2
+    end
+
+    it 'many hashes and lonely keys' do
+      expect(Jsonb.where.store(:tags, { a: 2 }, :z).size).to eq 2
+      expect(Jsonb.where.store(:tags, { a: 2 }, [:z]).size).to eq 2
+    end
   end
 
   context '#path' do
@@ -91,6 +108,26 @@ describe Jsonb do
     expect(records.first.name).to eq 'e'
   end
 
+  it '#value' do
+    records = Jsonb.where.store(:tags).value(1, false, { e: 2 })
+    expect(records.size).to eq 3
+  end
+
+  it '#values' do
+    records = Jsonb.where.store(:tags).values(1)
+    expect(records.size).to eq 2
+
+    records = Jsonb.where.store(:tags).values(2, 'e')
+    expect(records.size).to eq 1
+    expect(records.first.name).to eq 'e'
+
+    records = Jsonb.where.store(:tags).values(e: 1, f: { h: { k: 'a', s: 2 } })
+    expect(records.size).to eq 1
+
+    records = Jsonb.where.store(:tags).values(false, { a: 1, b: '1' }, [1, '1'])
+    expect(records.size).to eq 1
+  end
+
   it '#any' do
     records = Jsonb.where.store(:tags).any('a', 'b')
     expect(records.size).to eq 4
@@ -134,4 +171,34 @@ describe Jsonb do
       ).to eq 0
     end
   end
+
+  context "#update_store" do
+    let(:store) { :tags }
+
+    subject { Jsonb.update_store(store) }
+
+    it "#delete_keys" do
+      subject.delete_keys(:e)
+      expect(Jsonb.where.store(store).keys(:i)).to_not exist
+
+      subject.delete_keys(:a, :b)
+      expect(Jsonb.where.store(store).keys(:a)).to_not exist
+      expect(Jsonb.where.store(store).keys(:b)).to_not exist
+
+      subject.delete_keys([:c, :d])
+      expect(Jsonb.where.store(store).keys(:c)).to_not exist
+      expect(Jsonb.where.store(store).keys(:d)).to_not exist
+    end
+
+    it "#merge" do
+      subject.merge(new_key: 1)
+      expect(Jsonb.where.store(store).keys(:new_key).count).to be_eql Jsonb.count
+    end
+
+    it "#delete_pairs" do
+      subject.delete_pairs(a: 1, d: { e: 2 })
+      expect(Jsonb.where.store(store, a: 1)).to_not exist
+      expect(Jsonb.where.store(store, d: { e: 2 })).to_not exist
+    end
+  end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: pgrel
 version: !ruby/object:Gem::Version
-  version: 0.1.3
+  version: 0.2.0
 platform: ruby
 authors:
 - palkan
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-02-16 00:00:00.000000000 Z
+date: 2018-06-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -104,6 +104,7 @@ files:
 - ".gitignore"
 - ".rubocop.yml"
 - ".travis.yml"
+- CHANGELOG.md
 - Gemfile
 - MIT-LICENSE
 - README.md
@@ -113,6 +114,11 @@ files:
 - lib/pgrel.rb
 - lib/pgrel/active_record.rb
 - lib/pgrel/active_record/query_methods.rb
+- lib/pgrel/active_record/querying.rb
+- lib/pgrel/active_record/relation.rb
+- lib/pgrel/active_record/store/flexible_hstore.rb
+- lib/pgrel/active_record/store/flexible_jsonb.rb
+- lib/pgrel/active_record/store/flexible_store.rb
 - lib/pgrel/active_record/store_chain.rb
 - lib/pgrel/active_record/store_chain/array_chain.rb
 - lib/pgrel/active_record/store_chain/hstore_chain.rb
@@ -146,7 +152,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.7.4
+rubygems_version: 2.7.6
 signing_key: 
 specification_version: 4
 summary: ActiveRecord extension for querying hstore and jsonb.