pg_tags_on 0.1.1

data/lib/pg_tags_on/predicate_handler/array_jsonb_with_attrs_handler.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module PgTagsOn
+  class PredicateHandler
+    # Predicate handler for jsonb[] column type
+    class ArrayJsonbWithAttrsHandler < ArrayJsonbHandler
+      OPERATORS = {
+        eq: :eq,
+        all: '?&',
+        any: '?|',
+        in: '<@',
+        one: '?&'
+      }.freeze
+
+      def left
+        node = arel_function('array_to_json', attribute)
+        node = arel_cast(node, 'jsonb')
+        node = arel_function('jsonb_path_query_array', node, arel_build_quoted("$[*].#{key.join('.')}"))
+
+        node
+      end
+
+      def right
+        if predicate == :in
+          arel_cast(arel_sql("'#{value.to_json}'"), 'jsonb')
+        else
+          super
+        end
+      end
+
+      def value
+        @value ||= Array.wrap(query.value)
+      end
+
+      def cast_type
+        subtype = ActiveModel::Type::String.new
+        ::ActiveRecord::ConnectionAdapters::PostgreSQL::OID::Array.new(subtype)
+      end
+    end
+  end
+end

data/lib/pg_tags_on/predicate_handler/array_string_handler.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module PgTagsOn
+  class PredicateHandler
+    # Predicate handler for character varying[] column type
+    class ArrayStringHandler < BaseHandler
+    end
+  end
+end

data/lib/pg_tags_on/predicate_handler/array_text_handler.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module PgTagsOn
+  class PredicateHandler
+    # Predicate handler for character varying[] column type
+    class ArrayTextHandler < BaseHandler
+    end
+  end
+end

data/lib/pg_tags_on/predicate_handler/base_handler.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+module PgTagsOn
+  class PredicateHandler
+    # Base predicate handler
+    class BaseHandler
+      include PgTagsOn::ActiveRecord::Arel
+
+      OPERATORS = {
+        eq: :eq,
+        all: '@>',
+        any: '&&',
+        in: '<@',
+        one: '@>'
+      }.freeze
+
+      def initialize(attribute, query, predicate_builder)
+        @attribute = attribute
+        @query = query
+        @predicate_builder = predicate_builder
+      end
+
+      def call
+        raise 'Invalid predicate' unless OPERATORS.keys.include?(predicate)
+
+        if operator.is_a?(Symbol)
+          send("#{operator}_node")
+        else
+          ::Arel::Nodes::InfixOperation.new(operator, left, right)
+        end
+      end
+
+      def predicate
+        @predicate ||= query.predicate.to_sym
+      end
+
+      def operator
+        @operator ||= self.class.const_get('OPERATORS').fetch(predicate)
+      end
+
+      def eq_node
+        node = ::Arel::Nodes::InfixOperation.new(self.class::OPERATORS[:all], left, right)
+        node.and(arel_function('array_length', attribute, 1).eq(value.size))
+      end
+
+      def left
+        attribute
+      end
+
+      def right
+        bind_node
+      end
+
+      def bind_node
+        query_attr = ::ActiveRecord::Relation::QueryAttribute.new(attribute_name, value, cast_type)
+        Arel::Nodes::BindParam.new(query_attr)
+      end
+
+      def value
+        @value ||= Array.wrap(query.value)
+      end
+
+      def klass
+        @klass ||= predicate_builder.send(:table).send(:klass)
+      end
+
+      def table_name
+        @table_name ||= attribute.relation.name
+      end
+
+      def attribute_name
+        attribute.name.to_s
+      end
+
+      # Returns Type object
+      def cast_type
+        @cast_type ||= klass.type_for_attribute(attribute_name)
+      end
+
+      def settings
+        @settings ||= (klass.pg_tags_on_options_for(attribute_name) || {}).symbolize_keys
+      end
+
+      private
+
+      attr_reader :attribute, :query, :predicate_builder
+    end
+  end
+end

data/lib/pg_tags_on/predicate_handler.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module PgTagsOn
+  # Models' predicate handlers register this class
+  class PredicateHandler < ::ActiveRecord::PredicateBuilder::BaseHandler
+    def call(attribute, query)
+      handler = Builder.new(attribute, query, predicate_builder).call
+
+      handler.call
+    end
+
+    # Handler builder class
+    class Builder
+      def initialize(attribute, query, predicate_builder)
+        @attribute = attribute
+        @query = query
+        @predicate_builder = predicate_builder
+      end
+
+      def call
+        if column.array?
+          array_handler
+        else
+          BaseHandler.new(attribute, query, predicate_builder)
+        end
+      end
+
+      private
+
+      attr_reader :attribute, :query, :predicate_builder
+
+      def klass
+        @klass ||= predicate_builder.send(:table).send(:klass)
+      end
+
+      def column
+        @column ||= klass.columns_hash[attribute.name]
+      end
+
+      def column_type
+        @column_type ||= column.type.to_s
+      end
+
+      def settings
+        @settings ||= (klass.pg_tags_on_options_for(attribute.name) || {}).symbolize_keys
+      end
+
+      def array_handler
+        handler_klass =
+          if column_type == 'jsonb'
+            if settings.key?(:has_attributes)
+              ArrayJsonbWithAttrsHandler
+            else
+              ArrayJsonbHandler
+            end
+          else
+            PredicateHandler.const_get("Array#{column_type.classify}Handler")
+          end
+
+        handler_klass.new(attribute, query, predicate_builder)
+      end
+    end
+  end
+end

data/lib/pg_tags_on/repositories/array_jsonb_repository.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+module PgTagsOn
+  module Repositories
+    # Operatons for 'jsonb[]' column type
+    class ArrayJsonbRepository < ArrayRepository
+      def create(tag)
+        with_normalized_tags(tag) do |n_tag|
+          super(n_tag)
+        end
+      end
+
+      def update(tag, new_tag)
+        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, [query_attribute(n_new_tag.to_json)])
+        end
+      end
+
+      def delete(tag)
+        with_normalized_tags(tag) do |n_tag|
+          sql_set = <<-SQL.strip
+            #{column_name} = #{column_name}[1:index-1] || #{column_name}[index+1:2147483647]
+          SQL
+
+          update_tag(n_tag, sql_set)
+        end
+      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
+
+        block.call(*normalized_tags)
+      end
+
+      def array_to_recordset
+        return unnest unless key?
+
+        arel_jsonb_extract_path(unnest, *key_sql)
+      end
+
+      def key
+        @key ||= options[:key]
+      end
+
+      def key_sql
+        @key_sql ||= Array.wrap(key).map { |k| Arel.sql("'#{k}'") }
+      end
+
+      def key?
+        key.present?
+      end
+
+      def taggings_with_ordinality_query(tag)
+        column = Arel::Table.new('t')['name']
+        value = bind_for(tag.to_json, nil)
+
+        arel_table
+          .project('id, name, index')
+          .from("#{table_name}, #{unnest_with_ordinality}")
+          .where(arel_infix_operation('@>', column, value))
+      end
+
+      def update_tag(tag, set_sql, bindings = [])
+        subquery = taggings_with_ordinality_query(tag)
+                   .where(arel_table[:id].in(arel_sql(klass.reselect('id').to_sql)))
+
+        sql = <<-SQL.strip
+          WITH records as ( #{subquery.to_sql} )
+          UPDATE #{table_name}
+          SET #{set_sql}
+          FROM records
+          WHERE #{table_name}.id = records.id
+        SQL
+
+        bindings = [query_attribute(tag.to_json)] + Array.wrap(bindings)
+        klass.connection.exec_query(sql, 'SQL', bindings)
+      end
+    end
+  end
+end

data/lib/pg_tags_on/repositories/array_repository.rb

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+module PgTagsOn
+  module Repositories
+    # This repository works with "character varying[]" and "integer[]" column types
+    class ArrayRepository < BaseRepository
+      def all
+        subquery = klass
+                   .select(arel_distinct(array_to_recordset).as('name'))
+                   .arel
+                   .as('tags')
+
+        PgTagsOn::Tag
+          .select(Arel.star)
+          .from(subquery)
+          .order('tags.name') # override rails' default order by id
+      end
+
+      def all_with_counts
+        taggings
+          .except(:select)
+          .select('name, count(name) as count')
+          .group('name')
+      end
+
+      def find(tag)
+        all.where(name: tag).first
+      end
+
+      def exists?(tag)
+        all.exists?(tag)
+      end
+
+      def taggings
+        PgTagsOn::Tag
+          .select(Arel.star)
+          .from(taggings_query)
+          .order('taggings.name')
+      end
+
+      def count
+        all.count
+      end
+
+      def create(tag)
+        return true if tag.blank?
+
+        klass.update_all(column_name => arel_array_cat(arel_column, bind_for(Array.wrap(tag))))
+      end
+
+      def update(tag, new_tag)
+        return true if tag.blank? || new_tag.blank? || tag == new_tag
+
+        klass
+          .where(column_name => Tags.one(tag))
+          .update_all(column_name => arel_array_replace(arel_column, bind_for(tag), bind_for(new_tag)))
+      end
+
+      def delete(tag)
+        klass
+          .where(column_name => Tags.one(tag))
+          .update_all(column_name => arel_array_remove(arel_column, bind_for(tag)))
+      end
+
+      private
+
+      def array_to_recordset
+        unnest
+      end
+
+      def taggings_query
+        klass
+          .select(
+            array_to_recordset.as('name'),
+            arel_table['id'].as('entity_id')
+          )
+          .arel
+          .as('taggings')
+      end
+
+      def ref
+        "#{table_name}.#{column_name}"
+      end
+
+      def unnest
+        arel_unnest(arel_column)
+      end
+
+      def unnest_with_ordinality(alias_table: 't')
+        "#{unnest.to_sql} WITH ORDINALITY #{alias_table}(name, index)"
+      end
+
+      def query_attribute(value)
+        arel_query_attribute(arel_column, value, cast_type)
+      end
+
+      def bind_for(value, attr = arel_column)
+        query_attr = arel_query_attribute(attr, value, cast_type)
+        arel_bind(query_attr)
+      end
+    end
+  end
+end

data/lib/pg_tags_on/repositories/base_repository.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module PgTagsOn
+  module Repositories
+    # Base class for repositories.
+    class BaseRepository
+      include ::PgTagsOn::ActiveRecord::Arel
+
+      def self.api_methods
+        %i[all all_with_counts find exists? taggings count create update delete to_s]
+      end
+
+      api_methods.each do |m|
+        define_method(m) do
+          raise 'Not implemented'
+        end
+      end
+
+      attr_reader :klass, :column_name, :options
+
+      def initialize(klass, column_name, options = {})
+        @klass = klass
+        @column_name = column_name
+        @options = options.deep_symbolize_keys
+      end
+
+      def table_name
+        @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
+
+      def arel_column
+        arel_table[column_name]
+      end
+    end
+  end
+end

data/lib/pg_tags_on/repository.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module PgTagsOn
+  # Repository class for tags.
+  # Examples:
+  #
+  #   repo = PgTagsOn::Repository.new(Entity, :tags)
+  #   repo.all
+  #   repo.update('foo', 'boo')
+  #   ...
+  #
+  class Repository
+    extend Forwardable
+    def_delegators :gateway, :all, :all_with_counts, :taggings, :count, :create, :update, :delete
+
+    attr_reader :klass, :column_name
+
+    def initialize(klass, column_name)
+      @klass = klass
+      @column_name = column_name.to_s
+    end
+
+    private
+
+    def gateway
+      raise 'Invalid column type' unless column.array?
+
+      @gateway ||= send("#{column.type}_gateway")
+    end
+
+    def column
+      @column ||= klass.columns_hash[column_name]
+    end
+
+    def default_gateway
+      PgTagsOn::Repositories::ArrayRepository.new(klass, column_name, settings)
+    end
+
+    def string_gateway
+      default_gateway
+    end
+
+    def text_gateway
+      default_gateway
+    end
+
+    def integer_gateway
+      default_gateway
+    end
+
+    def jsonb_gateway
+      PgTagsOn::Repositories::ArrayJsonbRepository.new(klass, column_name, settings)
+    end
+
+    def settings
+      @settings ||= (klass.pg_tags_on_options_for(column_name) || {}).symbolize_keys
+    end
+  end
+end

data/lib/pg_tags_on/tag.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module PgTagsOn
+  # Model for tags.
+  # Schema is defined dynamically and has only +name+ column as string.
+  class Tag < ::ActiveRecord::Base
+    self.table_name = 'tags'
+
+    class << self
+      def load_schema!
+        @load_schema ||= begin
+          name_column = ::ActiveRecord::ConnectionAdapters::PostgreSQL::Column.new('name', '', pg_string_type)
+          @columns_hash = { 'name' => name_column }
+        end
+      end
+
+      private
+
+      def pg_string_type
+        string = ::ActiveRecord::ConnectionAdapters::SqlTypeMetadata.new(sql_type: 'character varying', type: 'string')
+        ::ActiveRecord::ConnectionAdapters::PostgreSQL::TypeMetadata.new(string)
+      end
+    end
+
+    def inspect
+      info = attributes.map { |name, value| %(#{name}: #{format_for_inspect(value)}) }.join(', ')
+
+      "#<#{self.class.name} #{info}>"
+    end
+  end
+end

data/lib/pg_tags_on/tags_query.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module PgTagsOn
+  # Helper class to construct queries.
+  # This class is registered in models' predicate builders.
+  # See configuration in order to create an alias for it.
+  class TagsQuery
+    %w[one all any in eq].each do |predicate|
+      instance_eval <<-RUBY, __FILE__, __LINE__ + 1
+        def #{predicate}(*args)
+          params = args.size == 1 ? args.first : args
+          new(params, "#{predicate}")
+        end
+      RUBY
+    end
+
+    attr_reader :value
+    attr_reader :predicate
+    attr_reader :options
+
+    def initialize(value, predicate, options = {})
+      @value = value
+      @predicate = predicate
+      @options = options
+    end
+  end
+end

data/lib/pg_tags_on/validations/validator.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module PgTagsOn
+  # Validator for max. number of tags and max. tag length.
+  #
+  #   class Entity
+  #     pg_tags_on :tags, limit: 20, tag_length: 64
+  #   end
+  #
+  class TagsValidator < ActiveModel::EachValidator
+    def initialize(options = {})
+      super
+      @klass = options[:class]
+    end
+
+    def validate_each(record, attribute, value)
+      validate_limit(record, attribute, value)
+      validate_tag_length(record, attribute, value)
+
+      record.errors.present?
+    end
+
+    private
+
+    attr_reader :klass
+
+    def validate_limit(record, attr, value)
+      limit = klass.pg_tags_on_options_for(attr)[:limit]
+      return true unless limit && value
+
+      record.errors.add(attr, "size exceeded #{limit} tags") if value.size > limit.to_i
+    end
+
+    def validate_tag_length(record, attr, value)
+      limit, key = klass.pg_tags_on_options_for(attr).values_at(:tag_length, :key)
+      return true unless limit && value
+
+      value.map! { |tag| tag.with_indifferent_access.dig(*key) } if key
+
+      record.errors.add(attr, "length exceeded #{limit} characters") if value.any? { |val| val.size > limit.to_i }
+    end
+  end
+end

data/lib/pg_tags_on/version.rb

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

data/lib/pg_tags_on.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+require 'forwardable'
+
+require 'pg_tags_on/version'
+require 'pg_tags_on/active_record/base'
+require 'pg_tags_on/active_record/arel'
+require 'pg_tags_on/predicate_handler'
+require 'pg_tags_on/predicate_handler/base_handler'
+require 'pg_tags_on/predicate_handler/array_string_handler'
+require 'pg_tags_on/predicate_handler/array_text_handler'
+require 'pg_tags_on/predicate_handler/array_integer_handler'
+require 'pg_tags_on/predicate_handler/array_jsonb_handler'
+require 'pg_tags_on/predicate_handler/array_jsonb_with_attrs_handler'
+require 'pg_tags_on/tag'
+require 'pg_tags_on/tags_query'
+require 'pg_tags_on/validations/validator'
+require 'pg_tags_on/repository'
+require 'pg_tags_on/repositories/base_repository'
+require 'pg_tags_on/repositories/array_repository'
+require 'pg_tags_on/repositories/array_jsonb_repository'
+require 'pg_tags_on/benchmark/benchmark'
+
+# PgTagsOn configuration methods
+module PgTagsOn
+  class Error < StandardError; end
+  class ColumnNotFoundError < Error; end
+
+  def configure
+    @config ||= OpenStruct.new(query_class: 'Tags')
+    yield @config if block_given?
+    @config
+  end
+
+  def configuration
+    @config || configure
+  end
+
+  def register_query_class
+    return true if query_class?
+
+    Kernel.const_set(PgTagsOn.configuration.query_class.to_sym, PgTagsOn::TagsQuery)
+  end
+
+  def query_class?
+    Kernel.const_defined?(PgTagsOn.configuration.query_class)
+  end
+
+  def query_class
+    Kernel.const_get(PgTagsOn.configuration.query_class)
+  end
+
+  module_function :configure, :configuration, :register_query_class, :query_class, :query_class?
+end
+
+ActiveRecord::Base.include PgTagsOn::ActiveRecord::Base