pgrel 0.1.1 → 0.3.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 9b99f0c11a5e624145d178ed3bdb97dd9345ccad
-  data.tar.gz: 7db4f0a1086111e10ded6e6f9af923179ddc2012
+SHA256:
+  metadata.gz: 686f59a1c868b3ee3268ab06137c35dcd2f8e9fed9136bbbec2a27622401d301
+  data.tar.gz: a381b46c2a07d0193a5764d099e25f731ac90c17f2f9bef11ca600ac08f10c1c
 SHA512:
-  metadata.gz: 4ef4b9230787c49c3ccb1b24d68113cf90b57c0ae8281e6814eb6d01c01925fc04031ee3f02e1cc09abf60386b2d3c12f6b2f46674f6b75ccc27cd34d3a08619
-  data.tar.gz: 8aaeaab12dd78aac0ad21a49b68af1a5efb83aeb261e0cfd431f24662b5f8b0dc88dcc4b93c8115b3a0d4999ddf3ca842c32d75f92270ebab7113eac31b71acf
+  metadata.gz: 92b7300c636eb9f985a7a9b5b9467d1480b92ca38997d73cce0105915f1f2d50f7df5724b5b9e0c5c36e32dd5ea3999803145caa0b51a0561ba40d17603606f8
+  data.tar.gz: 7b7153c935e88f6084463e58639e9c297fb44dcc1d8c538a8e17e5cb3f6f836837ca7a8dbefd479dbf22ac5f4fd8e9a3400d47985a9c35b30f65238821cd0bc8

data/CHANGELOG.md

@@ -0,0 +1,31 @@
+# Change log
+
+## master
+
+## 0.3.1 (2020-12-18)
+
+- Update internal query building for Rails 6.1 compatibility. ([@zokioki][])
+
+## 0.3.0 (2019-28-01)
+
+- Rename `#value` method to `#overlap_values`.
+- Rename `#values` method to `#contains_values`.
+- Improve `#contains_values` method:
+	eliminate multiple `avals` calls for Hstore and multiple `array_agg` calls for Jsonb.
+
+  See https://github.com/palkan/pgrel/pull/9. ([@StanisLove][])
+
+- Quote store name in queries. ([@palkan][])
+
+  Previously, we didn't quote store name in queries which could led
+  to ambiguity conflicts when joining tables.
+  Now it fixed.
+
+## 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/{MIT-LICENSE → LICENSE.txt}

@@ -1,4 +1,4 @@
-Copyright 2015 palkan
+Copyright 2015-2020 palkan
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

data/README.md

@@ -1,34 +1,41 @@
-[![Build Status](https://travis-ci.org/palkan/pgrel.svg?branch=master)](https://travis-ci.org/palkan/pgrel)
+[![Gem Version](https://badge.fury.io/rb/pgrel.svg)](https://rubygems.org/gems/pgrel)
+![Build](https://github.com/palkan/pgrel/workflows/Build/badge.svg)
 
 ## Pgrel
 
 ActiveRecord extension for querying hstore, array and jsonb.
 
-Compatible with **Rails** >= 4.0 (and even with upcoming **Rails 5**!).
-
-### General
-
-The functionality is based on ActiveRecord `WhereChain`. 
-To start querying call `where(:store_name)` and chain it with store-specific call (see below).
+Compatible with **Rails** >= 4.2 (including **Rails 6**).
 
 #### Install
 
 In your Gemfile:
 
 ```ruby
-gem "pgrel", "~>0.1"
+gem "pgrel", "~> 0.3"
 ```
 
 ### 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
 Hstore.where.store(:tags, a: 1, b: 2)
-#=> select * from hstores where tags->'a' = '1' and tags->'b' = '2'
+#=> select * from hstores where tags @> '"a"=>"1","b"=>"2"'
 
 Hstore.where.store(:tags, a: [1, 2])
-#=> select * from hstores where tags->'a' in ('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 +54,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).overlap_values(1, 2)
+#=> select * from hstores where (avals(tags) && ARRAY['1', '2'])
+
+# Retrieve items that have values '1' AND '2'
+Hstore.where.store(:tags).contains_values(1, 2)
+#=> select * from hstores where (avals(tags) @> ARRAY['1', '2'])
+```
+
 Containment:
 
 ```ruby
@@ -57,18 +76,42 @@ 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 `IN (...)` statement. 
+**NOTE**. Querying by array value always resolves to `(... or ...)` statement.
 Thus it's impossible to query json array value, e.g.:
 
 ```ruby
 Model.create!(tags: {main: ['a', 'b']})
 
 Model.where.store(:tags, main: ['a', 'b']).empty? == true
-#=> select * from models where  tags->'main' in ('a', 'b')
+#=> select * from models where  (tags @> '{\"main\":\"a\"}' or tags @> '{\"main\":\"b\"}')
 ```
 
 Path query:

data/lib/pgrel.rb

@@ -1,2 +1,4 @@
-require 'pgrel/version'
-require 'pgrel/active_record'
+# frozen_string_literal: true
+
+require "pgrel/version"
+require "pgrel/active_record"

data/lib/pgrel/active_record.rb

@@ -1,2 +1,9 @@
-require 'active_record'
-require 'pgrel/active_record/query_methods'
+# 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/query_methods.rb

@@ -1,8 +1,10 @@
-require 'active_record/relation'
-require 'pgrel/active_record/store_chain'
-require 'pgrel/active_record/store_chain/array_chain'
-require 'pgrel/active_record/store_chain/hstore_chain'
-require 'pgrel/active_record/store_chain/jsonb_chain'
+# frozen_string_literal: true
+
+require "active_record/relation"
+require "pgrel/active_record/store_chain"
+require "pgrel/active_record/store_chain/array_chain"
+require "pgrel/active_record/store_chain/hstore_chain"
+require "pgrel/active_record/store_chain/jsonb_chain"
 
 module ActiveRecord
   module QueryMethods

data/lib/pgrel/active_record/querying.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+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 = +"#{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

@@ -1,5 +1,4 @@
-# Check rails version
-RAILS_5 = ActiveRecord.version.release >= Gem::Version.new("5")
+# frozen_string_literal: true
 
 module ActiveRecord
   module QueryMethods
@@ -7,10 +6,13 @@ module ActiveRecord
     # Provides _containment_ queries methods.
     # Provides basic methods.
     class StoreChain
+      attr_reader :store_name, :quoted_store_name
+
       def initialize(scope, store_name)
         @scope = scope
         @store_name = store_name
         @inverted = false
+        @quoted_store_name = "#{@scope.klass.quoted_table_name}.#{@scope.klass.connection.quote_column_name(store_name)}"
       end
 
       # Whether the store contains provided store
@@ -22,7 +24,7 @@ module ActiveRecord
       #   data = {a: 1}
       #   Model.store(:store).contains(data).all #=> [Model(name: 'first', ...)]
       def contains(opts)
-        update_scope "#{@store_name} @> #{type_cast(opts)}"
+        update_scope contains_clause(opts)
       end
 
       # Whether the store is contained within provided store
@@ -34,7 +36,7 @@ module ActiveRecord
       #   data = {b: 1, c: 2}
       #   Model.store(:store).contains(data).all #=> [Model(name: 'first', ...)]
       def contained(opts)
-        update_scope "#{@store_name} <@ #{type_cast(opts)}"
+        update_scope "#{quoted_store_name} <@ #{type_cast(opts)}"
       end
 
       # Add negation to condition.
@@ -52,37 +54,56 @@ module ActiveRecord
         self
       end
 
-      if RAILS_5
-        protected
+      # Query by store values.
+      # Supports array values.
+      #
+      # NOTE: This method uses "@>" (contains) operator with logic (AND/OR)
+      # and not uses "->" (value-by-key). The use of "contains" operator allows us to
+      # use GIN index effectively.
+      #
+      # Example
+      #   Model.create!(name: 'first', store: {b: 1, c: 2})
+      #   Model.create!(name: 'second', store: {b: 2, c: 3})
+      #
+      #   Model.store(:store, c: 2).all #=> [Model(name: 'first', ...)]
+      #   #=> (SQL) select * from ... where store @> '"c"=>"2"'::hstore
+      #
+      #   Model.store(:store, b: [1, 2]).size #=> 2
+      #   #=> (SQL) select * from ... where (store @> '"c"=>"1"'::hstore) or
+      #                                     (store @> '"c"=>"2"'::hstore)
+      def where(*opts)
+        opts.map! { |opt| opt.is_a?(Hash) ? opt : [opt] }
+
+        update_scope(
+          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
+
+      protected
 
+      if ActiveRecord.version.release >= Gem::Version.new("5")
         def update_scope(*opts)
-          where_clause = @scope.send(:where_clause_factory).build(opts, {})
+          where_clause = build_where_clause(opts)
           @scope.where_clause += @inverted ? where_clause.invert : where_clause
           @scope
         end
 
         def type_cast(value)
           ActiveRecord::Base.connection.quote(
-            @scope.table.type_cast_for_database(@store_name, value)
+            @scope.klass.type_caster.type_cast_for_database(@store_name, value)
           )
         end
-
-        def where_with_prefix(prefix, opts)
-          where_clause = @scope.send(:where_clause_factory).build(opts, {})
-          predicates = where_clause.ast.children.map do |rel|
-            rel.left = to_sql_literal(prefix, rel.left)
-            rel
-          end
-          where_clause = ActiveRecord::Relation::WhereClause.new(
-            predicates,
-            where_clause.binds
-          )
-          @scope.where_clause += @inverted ? where_clause.invert : where_clause
-          @scope
-        end
       else
-        protected
-
         def update_scope(*opts)
           where_clause = @scope.send(:build_where, opts).map do |rel|
             @inverted ? invert_arel(rel) : rel
@@ -98,15 +119,6 @@ module ActiveRecord
           )
         end
 
-        def where_with_prefix(prefix, opts)
-          where_value = @scope.send(:build_where, opts).map do |rel|
-            rel.left = to_sql_literal(prefix, rel.left)
-            @inverted ? invert_arel(rel) : rel
-          end
-          @scope.where_values += where_value
-          @scope
-        end
-
         def invert_arel(rel)
           case rel
           when Arel::Nodes::In
@@ -120,6 +132,24 @@ module ActiveRecord
           end
         end
       end
+
+      private
+
+      def contains_clause(opts)
+        "#{quoted_store_name} @> #{type_cast(opts)}"
+      end
+
+      def build_or_contains(k, vals)
+        vals.map { |v| contains_clause(k => v) }.join(" or ")
+      end
+
+      def build_where_clause(opts)
+        if ActiveRecord.version.release >= Gem::Version.new("6.1.0")
+          @scope.send(:build_where_clause, opts)
+        else
+          @scope.send(:where_clause_factory).build(opts, [])
+        end
+      end
     end
 
     # Base class for key-value types of stores (hstore, jsonb)
@@ -133,7 +163,7 @@ module ActiveRecord
       #   # Get all records which have key 'a' in store 'store'
       #   Model.store(:store).key('a').all #=> [Model(name: 'first', ...)]
       def key(key)
-        update_scope "#{@store_name} ? :key", key: key.to_s
+        update_scope "#{quoted_store_name} ? :key", key: key.to_s
       end
 
       # Several keys existence
@@ -145,7 +175,7 @@ module ActiveRecord
       #   Model.store(:store).keys('a','b').all #=> [Model(name: 'first', ...)]
       def keys(*keys)
         update_scope(
-          "#{@store_name} ?& ARRAY[:keys]",
+          "#{quoted_store_name} ?& ARRAY[:keys]",
           keys: keys.flatten.map(&:to_s)
         )
       end
@@ -159,7 +189,7 @@ module ActiveRecord
       #   Model.store(:store).keys('a','b').count #=> 2
       def any(*keys)
         update_scope(
-          "#{@store_name} ?| ARRAY[:keys]",
+          "#{quoted_store_name} ?| ARRAY[:keys]",
           keys: keys.flatten.map(&:to_s)
         )
       end
@@ -171,6 +201,48 @@ module ActiveRecord
           "#{prefix}'#{node.name}'"
         )
       end
+
+      if ActiveRecord.version.release >= Gem::Version.new("5")
+        def where_with_prefix(prefix, opts)
+          where_clause = build_where_clause(opts)
+          where_clause_ast = where_clause.ast
+
+          # Converting `HomogenousIn` node to `In` type allows us to set its `left`
+          # to sql literal as with other node types (`HomogenousIn` does not support this).
+          if defined?(Arel::Nodes::HomogeneousIn) && where_clause_ast.is_a?(Arel::Nodes::HomogeneousIn)
+            where_clause_ast = Arel::Nodes::In.new(where_clause_ast.left, where_clause_ast.right)
+          end
+
+          predicates = if where_clause_ast.is_a?(Arel::Nodes::And)
+            where_clause.ast.children.map do |rel|
+              rel.left = to_sql_literal(prefix, rel.left)
+              rel
+            end
+          else
+            where_clause_ast.left = to_sql_literal(prefix, where_clause_ast.left)
+            [where_clause_ast]
+          end
+
+          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
+      else
+        def where_with_prefix(prefix, opts)
+          where_value = @scope.send(:build_where, opts).map do |rel|
+            rel.left = to_sql_literal(prefix, rel.left)
+            @inverted ? invert_arel(rel) : rel
+          end
+          @scope.where_values += where_value
+          @scope
+        end
+      end
     end
   end
 end