pg_tags_on 0.1.4 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: aac909ac252ee49fd469857036866fb22fbc78db87e19f84f8448637a780af6c
-  data.tar.gz: 4ba45da54dc2782a11ce1cb67b5e61077447f544fcac29c0620c4e261d572ee0
+  metadata.gz: 01ed743033dfd067912e4ffe4878cf719e87d920220c656318eb4a780c4f9196
+  data.tar.gz: 03f9ea30352f7ced5e6c5b87d343c410a8d6522d7475ee34685c53870a9952f3
 SHA512:
-  metadata.gz: 19090081b0fe790204a5384bc85c9e90d29ea824eeb0ace2b103e6a68010379f65fd05e0deef79474a7bbfaa6fdb01b59aaf62d151af2f48317f502a70b43a4c
-  data.tar.gz: 0d2da6a30730fc639b915ceaf88a47bc6219d9ef111188a8f935f39aae936f6afbb36afbbef624ba6fb4b7f35eede5c89c3d0b3b917e526794c73cc16fa988a0
+  metadata.gz: 118f18d7f3dc1e5e7809b03ec03a107499b8be1e66f225b3b40d819f55e95e98e7deaf469fe4f8ad29cd790962082b2a314081ac266009d1d4bc65cf9fd94d86
+  data.tar.gz: 7771926231fc5013bce1e01938aeef247e9b602b6308dbfbfdf29d10b6d111bb8743a4fbc0bd97c6d0ad4daf773bb9efc0edcedcaa166e74ea7b8096d32cca12

data/CHANGELOG.md

@@ -1,3 +1,17 @@
+## 0.2.0 ( 2020-09-02)
+
+* Added support for multiple tags creation and deletion
+* Optimizations
+* Updated specs and documentation
+
+## 0.1.4 ( 2020-04-12)
+
+* Added support for returning columns after create,update or delete tags operations
+* Updated specs
+* Updated documentation
+
+
 ## 0.1.0 ( 2020-03-11 ) ##
 
-* First release
+* First release
+

data/README.md

@@ -1,6 +1,6 @@
 # PgTagsOn
 
-```pg_tags_on``` is a gem that makes working with tags stored in a Postgresql column easy. Supported column types are: ```character varying[]```, ```text[]```, ```integer[]``` and ```jsonb[]```.
+```pg_tags_on``` - keep tags in a column. Supported column types are: ```character varying[]```, ```text[]```, ```integer[]``` and ```jsonb[]```.
 
 
 Requirements:
@@ -15,7 +15,7 @@ Note: this gem is in early stage of development.
 - [Installation](#installation)
 - [Usage](#usage)
   - [ActiveRecord model setup](#activerecord-model-setup)
-  - [Records queries](#records-queries)
+  - [Records queries](#queries)
   - [Tags](#tags)
   - [Set record's tags](#set-records-tags)
   - [Configuration](#configuration)
@@ -140,20 +140,22 @@ Entity.tags.taggings
   => [#<PgTagsOn::Tag name: "alpha", entity_id: 1>, #<PgTagsOn::Tag name: "beta", entity_id: 1>, #<PgTagsOn::Tag name: "alpha", entity_id: 2>, ... ]
 ```
 
-Create, update and delete methods are using, for performance reasons, Postgresql functions to manipulate the arrays, so ActiveRecord models are not instantiated. A frequent problem is to ensure uniqueness of the tags for a record, but this can be achieved at the database level by creating a before create/update row trigger.
+Create, update and delete methods are using, for performance reasons, Postgresql functions to manipulate the arrays, so ActiveRecord models are not instantiated. A frequent problem is to ensure uniqueness of the tags for a record, and this can be achieved at the database level by creating a before create/update row trigger.
 
 ```ruby
 # create
-Entity.tags.create('alpha')             # add tag to all records
-Entity.where(...).tags.create('alpha')  # add tag to filtered records
+Entity.tags.create('alpha')              # add tag to all records
+Entity.tags.create(%w[alpha beta gamma]) # add many tags to all records
+Entity.where(...).tags.create('alpha')   # add tag to filtered records
 
 # update
 Entity.tags.update('alpha', 'a')             # rename tag for all records
 Entity.where(...).tags.update('alpha', 'a')  # rename tag for filtered records
 
 # delete
-Entity.tags.delete('alpha')             # delete tag from all records
-Entity.where(...).tags.delete('alpha')  # delete tag from filtered records
+Entity.tags.delete('alpha')              # delete tag from all records
+Entity.tags.delete(%w[alpha beta gamma]) # delete many tags from all records
+Entity.where(...).tags.delete('alpha')   # delete tag from filtered records
 
 # any of these methods accepts :returning option
 Entity.tags.update('alpha', 'a', returning: %w[id tags])

data/lib/pg_tags_on/repositories/array_jsonb_repository.rb

@@ -4,43 +4,56 @@ module PgTagsOn
   module Repositories
     # Operatons for 'jsonb[]' column type
     class ArrayJsonbRepository < ArrayRepository
-      def create(tag, returning: nil)
-        with_normalized_tags(tag) do |n_tag|
-          super(n_tag, returning: returning)
-        end
+      def create(tag_or_tags, returning: nil)
+        tags = normalize_tags(Array.wrap(tag_or_tags))
+
+        super(tags, returning: returning)
       end
 
       def update(tag, new_tag, returning: nil)
-        with_normalized_tags(tag, new_tag) do |n_tag, n_new_tag|
-          sql_set = <<-SQL.strip
-            #{column_name}[index] = #{column_name}[index] || $2
-          SQL
-
-          update_tag(n_tag,
-                     sql_set,
-                     bindings: [query_attribute(n_new_tag.to_json)],
-                     returning: returning)
-        end
-      end
+        n_tag, n_new_tag = normalize_tags([tag, new_tag])
 
-      def delete(tag, returning: nil)
-        with_normalized_tags(tag) do |n_tag|
-          sql_set = <<-SQL.strip
-            #{column_name} = #{column_name}[1:index-1] || #{column_name}[index+1:2147483647]
-          SQL
+        sql_set = <<-SQL.strip
+          #{column_name}[index] = #{column_name}[index] || $2
+        SQL
+
+        update_tag(n_tag,
+                   sql_set,
+                   bindings: [query_attribute(n_new_tag.to_json)],
+                   returning: returning)
+      end
 
-          update_tag(n_tag, sql_set, returning: returning)
+      def delete(tag_or_tags, returning: nil)
+        tags = Array.wrap(tag_or_tags)
+        normalized_tags = normalize_tags(tags)
+        rel = klass.where(column_name => PgTagsOn.query_class.any(tags))
+        sm = build_tags_select_manager
+        normalized_tags.each do |tag|
+          sm.where(arel_infix_operation('@>', Arel.sql('tag'), bind_for(tag.to_json, nil)).not)
         end
+        value = arel_function('array', sm)
+
+        perform_update(rel, { column_name => value }, returning: returning)
       end
 
       private
 
-      def with_normalized_tags(*tags, &block)
-        normalized_tags = Array.wrap(tags).flatten.map do |tag|
-          key? && Array.wrap(key).reverse.inject(tag) { |a, n| { n => a } } || tag
-        end
+      # Returns SelectManager for unnested tags.
+      # sql: select tag from ( select unnest(tags_jsonb) as tag ) as _tags
+      def build_tags_select_manager
+        Arel::SelectManager.new
+                           .project('tag')
+                           .from(Arel::SelectManager.new
+                  .project(unnest.as('tag'))
+                  .as('_tags'))
+      end
 
-        block.call(*normalized_tags)
+      def normalize_tags(tags)
+        return tags unless key?
+
+        tags.map do |tag|
+          Array.wrap(key).reverse.inject(tag) { |a, n| { n => a } }
+        end
       end
 
       def array_to_recordset
@@ -82,6 +95,7 @@ module PgTagsOn
           FROM records
           WHERE #{table_name}.id = records.id
         SQL
+
         sql += " RETURNING #{Array.wrap(returning).join(', ')}" if returning.present?
 
         bindings = [query_attribute(tag.to_json)] + Array.wrap(bindings)

data/lib/pg_tags_on/repositories/array_repository.rb

@@ -43,36 +43,37 @@ module PgTagsOn
       end
 
       def create(tag, returning: nil)
-        raise 'Tag cannot be blank' if tag.blank?
+        value = arel_array_cat(arel_column, bind_for(Array.wrap(tag)))
 
-        perform_update(klass,
-                       { column_name => arel_array_cat(arel_column, bind_for(Array.wrap(tag))) },
-                       returning: returning)
+        perform_update(klass, { column_name => value }, returning: returning)
       end
 
       def update(tag, new_tag, returning: nil)
-        raise 'Tag cannot be blank' if tag.blank? || new_tag.blank?
-
         rel = klass.where(column_name => PgTagsOn.query_class.one(tag))
+        value = arel_array_replace(arel_column, bind_for(tag), bind_for(new_tag))
 
-        perform_update(rel,
-                       { column_name => arel_array_replace(arel_column, bind_for(tag), bind_for(new_tag)) },
-                       returning: returning)
+        perform_update(rel, { column_name => value }, returning: returning)
       end
 
-      def delete(tag, returning: nil)
-        raise 'Tag cannot be blank' if tag.blank?
-
-        rel = klass.where(column_name => PgTagsOn.query_class.one(tag))
+      def delete(tag_or_tags, returning: nil)
+        tags = Array.wrap(tag_or_tags)
+        rel = klass.where(column_name => PgTagsOn.query_class.any(tags))
+        sm = Arel::SelectManager.new
+                                .project(unnest)
+                                .except(
+                                  Arel::SelectManager.new
+                                    .project(arel_unnest(arel_cast(bind_for(tags), native_column_type)))
+                                )
+        value = arel_function('array', sm)
 
-        perform_update(rel, { column_name => arel_array_remove(arel_column, bind_for(tag)) }, returning: returning)
+        perform_update(rel, { column_name => value }, returning: returning)
       end
 
       private
 
       def perform_update(rel, updates, returning: nil)
-        updater = update_manager(rel, updates)
-        sql, binds = klass.connection.send :to_sql_and_binds, updater
+        update_manager = get_update_manager(rel, updates)
+        sql, binds = klass.connection.send :to_sql_and_binds, update_manager
         sql += " RETURNING #{Array.wrap(returning).join(', ')}" if returning.present?
 
         result = klass.connection.exec_query(sql, 'SQL', binds).rows
@@ -80,26 +81,6 @@ module PgTagsOn
         returning ? result : true
       end
 
-      # Method copied from ActiveRecord as there is no way to inject sql into update manager.
-      def update_manager(rel, updates)
-        raise ArgumentError, 'Empty list of attributes to change' if updates.blank?
-
-        stmt = ::Arel::UpdateManager.new
-        stmt.table(arel_table)
-        stmt.key = klass.arel_attribute(klass.primary_key)
-        stmt.take(rel.arel.limit)
-        stmt.offset(rel.arel.offset)
-        stmt.order(*rel.arel.orders)
-        stmt.wheres = rel.arel.constraints
-        stmt.set rel.send(:_substitute_values, updates)
-
-        stmt
-      end
-
-      def array_to_recordset
-        unnest
-      end
-
       def taggings_query
         klass
           .select(
@@ -110,14 +91,14 @@ module PgTagsOn
           .as('taggings')
       end
 
-      def ref
-        "#{table_name}.#{column_name}"
-      end
-
       def unnest
         arel_unnest(arel_column)
       end
 
+      def array_to_recordset
+        unnest
+      end
+
       def unnest_with_ordinality(alias_table: 't')
         "#{unnest.to_sql} WITH ORDINALITY #{alias_table}(name, index)"
       end

data/lib/pg_tags_on/repositories/base_repository.rb

@@ -28,10 +28,6 @@ module PgTagsOn
         @table_name ||= klass.table_name
       end
 
-      def cast_type
-        @cast_type ||= klass.type_for_attribute(column_name)
-      end
-
       def arel_table
         klass.arel_table
       end
@@ -39,6 +35,45 @@ module PgTagsOn
       def arel_column
         arel_table[column_name]
       end
+
+      # Returns ActiveRecord Column instance
+      def ar_column
+        @ar_column ||= klass.columns_hash[column_name.to_s]
+      end
+
+      def ref
+        "#{table_name}.#{column_name}"
+      end
+
+      # Returns Type instance
+      def cast_type
+        @cast_type ||= klass.type_for_attribute(column_name)
+      end
+
+      # Returns db type as string.
+      # Ex: character varying[], integer[]
+      def native_column_type
+        type = ::ActiveRecord::ConnectionAdapters::PostgreSQLAdapter::NATIVE_DATABASE_TYPES.fetch(cast_type.type)[:name]
+        type += '[]' if ar_column.array?
+
+        type
+      end
+
+      # Method copied from ActiveRecord as there is no way to inject sql into update manager.
+      def get_update_manager(rel, updates)
+        raise ArgumentError, 'Empty list of attributes to change' if updates.blank?
+
+        stmt = ::Arel::UpdateManager.new
+        stmt.table(arel_table)
+        stmt.key = klass.arel_attribute(klass.primary_key)
+        stmt.take(rel.arel.limit)
+        stmt.offset(rel.arel.offset)
+        stmt.order(*rel.arel.orders)
+        stmt.wheres = rel.arel.constraints
+        stmt.set rel.send(:_substitute_values, updates)
+
+        stmt
+      end
     end
   end
 end

data/lib/pg_tags_on/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module PgTagsOn
-  VERSION = '0.1.4'
+  VERSION = '0.2.0'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: pg_tags_on
 version: !ruby/object:Gem::Version
-  version: 0.1.4
+  version: 0.2.0
 platform: ruby
 authors:
 - Catalin Marinescu
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-04-12 00:00:00.000000000 Z
+date: 2020-09-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord