active_fields 1.0.0 → 2.0.0

data/lib/active_fields/finders/boolean_finder.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module ActiveFields
+  module Finders
+    class BooleanFinder < SingularFinder
+      operation :eq, operator: OPS[:eq] do |value|
+        scope.where(eq(casted_value_field("boolean"), cast(value)))
+      end
+      operation :not_eq, operator: OPS[:not_eq] do |value|
+        scope.where(not_eq(casted_value_field("boolean"), cast(value)))
+      end
+
+      private
+
+      def cast(value)
+        Casters::BooleanCaster.new.deserialize(value)
+      end
+    end
+  end
+end

data/lib/active_fields/finders/date_array_finder.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+module ActiveFields
+  module Finders
+    class DateArrayFinder < ArrayFinder
+      operation :include, operator: OPS[:include] do |value|
+        scope.where(value_match_any("==", cast(value)))
+      end
+      operation :not_include, operator: OPS[:not_include] do |value|
+        scope.where.not(value_match_any("==", cast(value)))
+      end
+      operation :any_gt, operator: OPS[:any_gt] do |value|
+        scope.where(value_match_any(">", cast(value)))
+      end
+      operation :any_gteq, operator: OPS[:any_gteq] do |value|
+        scope.where(value_match_any(">=", cast(value)))
+      end
+      operation :any_lt, operator: OPS[:any_lt] do |value|
+        scope.where(value_match_any("<", cast(value)))
+      end
+      operation :any_lteq, operator: OPS[:any_lteq] do |value|
+        scope.where(value_match_any("<=", cast(value)))
+      end
+      operation :all_gt, operator: OPS[:all_gt] do |value|
+        scope.where(value_match_all(">", cast(value)))
+      end
+      operation :all_gteq, operator: OPS[:all_gteq] do |value|
+        scope.where(value_match_all(">=", cast(value)))
+      end
+      operation :all_lt, operator: OPS[:all_lt] do |value|
+        scope.where(value_match_all("<", cast(value)))
+      end
+      operation :all_lteq, operator: OPS[:all_lteq] do |value|
+        scope.where(value_match_all("<=", cast(value)))
+      end
+      operation :size_eq, operator: OPS[:size_eq] do |value|
+        scope.where(value_size_eq(value))
+      end
+      operation :size_not_eq, operator: OPS[:size_not_eq] do |value|
+        scope.where(value_size_not_eq(value))
+      end
+      operation :size_gt, operator: OPS[:size_gt] do |value|
+        scope.where(value_size_gt(value))
+      end
+      operation :size_gteq, operator: OPS[:size_gteq] do |value|
+        scope.where(value_size_gteq(value))
+      end
+      operation :size_lt, operator: OPS[:size_lt] do |value|
+        scope.where(value_size_lt(value))
+      end
+      operation :size_lteq, operator: OPS[:size_lteq] do |value|
+        scope.where(value_size_lteq(value))
+      end
+
+      private
+
+      def cast(value)
+        caster = Casters::DateCaster.new
+        caster.serialize(caster.deserialize(value))
+      end
+
+      def jsonpath(operator) = "$[*] ? (@.date() #{operator} $value.date())"
+    end
+  end
+end

data/lib/active_fields/finders/date_finder.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module ActiveFields
+  module Finders
+    class DateFinder < SingularFinder
+      operation :eq, operator: OPS[:eq] do |value|
+        scope.where(eq(casted_value_field("date"), cast(value)))
+      end
+      operation :not_eq, operator: OPS[:not_eq] do |value|
+        scope.where(not_eq(casted_value_field("date"), cast(value)))
+      end
+      operation :gt, operator: OPS[:gt] do |value|
+        scope.where(gt(casted_value_field("date"), cast(value)))
+      end
+      operation :gteq, operator: OPS[:gteq] do |value|
+        scope.where(gteq(casted_value_field("date"), cast(value)))
+      end
+      operation :lt, operator: OPS[:lt] do |value|
+        scope.where(lt(casted_value_field("date"), cast(value)))
+      end
+      operation :lteq, operator: OPS[:lteq] do |value|
+        scope.where(lteq(casted_value_field("date"), cast(value)))
+      end
+
+      private
+
+      def cast(value)
+        Casters::DateCaster.new.deserialize(value)
+      end
+    end
+  end
+end

data/lib/active_fields/finders/date_time_array_finder.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+module ActiveFields
+  module Finders
+    class DateTimeArrayFinder < ArrayFinder
+      operation :include, operator: OPS[:include] do |value|
+        scope.where(value_match_any("==", cast(value)))
+      end
+      operation :not_include, operator: OPS[:not_include] do |value|
+        scope.where.not(value_match_any("==", cast(value)))
+      end
+      operation :any_gt, operator: OPS[:any_gt] do |value|
+        scope.where(value_match_any(">", cast(value)))
+      end
+      operation :any_gteq, operator: OPS[:any_gteq] do |value|
+        scope.where(value_match_any(">=", cast(value)))
+      end
+      operation :any_lt, operator: OPS[:any_lt] do |value|
+        scope.where(value_match_any("<", cast(value)))
+      end
+      operation :any_lteq, operator: OPS[:any_lteq] do |value|
+        scope.where(value_match_any("<=", cast(value)))
+      end
+      operation :all_gt, operator: OPS[:all_gt] do |value|
+        scope.where(value_match_all(">", cast(value)))
+      end
+      operation :all_gteq, operator: OPS[:all_gteq] do |value|
+        scope.where(value_match_all(">=", cast(value)))
+      end
+      operation :all_lt, operator: OPS[:all_lt] do |value|
+        scope.where(value_match_all("<", cast(value)))
+      end
+      operation :all_lteq, operator: OPS[:all_lteq] do |value|
+        scope.where(value_match_all("<=", cast(value)))
+      end
+      operation :size_eq, operator: OPS[:size_eq] do |value|
+        scope.where(value_size_eq(value))
+      end
+      operation :size_not_eq, operator: OPS[:size_not_eq] do |value|
+        scope.where(value_size_not_eq(value))
+      end
+      operation :size_gt, operator: OPS[:size_gt] do |value|
+        scope.where(value_size_gt(value))
+      end
+      operation :size_gteq, operator: OPS[:size_gteq] do |value|
+        scope.where(value_size_gteq(value))
+      end
+      operation :size_lt, operator: OPS[:size_lt] do |value|
+        scope.where(value_size_lt(value))
+      end
+      operation :size_lteq, operator: OPS[:size_lteq] do |value|
+        scope.where(value_size_lteq(value))
+      end
+
+      private
+
+      def cast(value)
+        caster = Casters::DateTimeCaster.new(precision: active_field.precision)
+        caster.serialize(caster.deserialize(value))
+      end
+
+      def jsonpath(operator) = "$[*] ? (@.timestamp_tz() #{operator} $value.timestamp_tz())"
+    end
+  end
+end

data/lib/active_fields/finders/date_time_finder.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module ActiveFields
+  module Finders
+    class DateTimeFinder < SingularFinder
+      operation :eq, operator: OPS[:eq] do |value|
+        scope.where(eq(casted_value_field("timestamp"), cast(value)))
+      end
+      operation :not_eq, operator: OPS[:not_eq] do |value|
+        scope.where(not_eq(casted_value_field("timestamp"), cast(value)))
+      end
+      operation :gt, operator: OPS[:gt] do |value|
+        scope.where(gt(casted_value_field("timestamp"), cast(value)))
+      end
+      operation :gteq, operator: OPS[:gteq] do |value|
+        scope.where(gteq(casted_value_field("timestamp"), cast(value)))
+      end
+      operation :lt, operator: OPS[:lt] do |value|
+        scope.where(lt(casted_value_field("timestamp"), cast(value)))
+      end
+      operation :lteq, operator: OPS[:lteq] do |value|
+        scope.where(lteq(casted_value_field("timestamp"), cast(value)))
+      end
+
+      private
+
+      def cast(value)
+        Casters::DateTimeCaster.new(precision: active_field.precision).deserialize(value)
+      end
+    end
+  end
+end

data/lib/active_fields/finders/decimal_array_finder.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+module ActiveFields
+  module Finders
+    class DecimalArrayFinder < ArrayFinder
+      operation :include, operator: OPS[:include] do |value|
+        scope.where(value_match_any("==", cast(value)))
+      end
+      operation :not_include, operator: OPS[:not_include] do |value|
+        scope.where.not(value_match_any("==", cast(value)))
+      end
+      operation :any_gt, operator: OPS[:any_gt] do |value|
+        scope.where(value_match_any(">", cast(value)))
+      end
+      operation :any_gteq, operator: OPS[:any_gteq] do |value|
+        scope.where(value_match_any(">=", cast(value)))
+      end
+      operation :any_lt, operator: OPS[:any_lt] do |value|
+        scope.where(value_match_any("<", cast(value)))
+      end
+      operation :any_lteq, operator: OPS[:any_lteq] do |value|
+        scope.where(value_match_any("<=", cast(value)))
+      end
+      operation :all_gt, operator: OPS[:all_gt] do |value|
+        scope.where(value_match_all(">", cast(value)))
+      end
+      operation :all_gteq, operator: OPS[:all_gteq] do |value|
+        scope.where(value_match_all(">=", cast(value)))
+      end
+      operation :all_lt, operator: OPS[:all_lt] do |value|
+        scope.where(value_match_all("<", cast(value)))
+      end
+      operation :all_lteq, operator: OPS[:all_lteq] do |value|
+        scope.where(value_match_all("<=", cast(value)))
+      end
+      operation :size_eq, operator: OPS[:size_eq] do |value|
+        scope.where(value_size_eq(value))
+      end
+      operation :size_not_eq, operator: OPS[:size_not_eq] do |value|
+        scope.where(value_size_not_eq(value))
+      end
+      operation :size_gt, operator: OPS[:size_gt] do |value|
+        scope.where(value_size_gt(value))
+      end
+      operation :size_gteq, operator: OPS[:size_gteq] do |value|
+        scope.where(value_size_gteq(value))
+      end
+      operation :size_lt, operator: OPS[:size_lt] do |value|
+        scope.where(value_size_lt(value))
+      end
+      operation :size_lteq, operator: OPS[:size_lteq] do |value|
+        scope.where(value_size_lteq(value))
+      end
+
+      private
+
+      def cast(value)
+        caster = Casters::DecimalCaster.new(precision: active_field.precision)
+        caster.serialize(caster.deserialize(value))
+      end
+
+      def jsonpath(operator) = "$[*] ? (@.number() #{operator} $value.number())"
+    end
+  end
+end

data/lib/active_fields/finders/decimal_finder.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module ActiveFields
+  module Finders
+    class DecimalFinder < SingularFinder
+      operation :eq, operator: OPS[:eq] do |value|
+        scope.where(eq(casted_value_field("decimal"), cast(value)))
+      end
+      operation :not_eq, operator: OPS[:not_eq] do |value|
+        scope.where(not_eq(casted_value_field("decimal"), cast(value)))
+      end
+      operation :gt, operator: OPS[:gt] do |value|
+        scope.where(gt(casted_value_field("decimal"), cast(value)))
+      end
+      operation :gteq, operator: OPS[:gteq] do |value|
+        scope.where(gteq(casted_value_field("decimal"), cast(value)))
+      end
+      operation :lt, operator: OPS[:lt] do |value|
+        scope.where(lt(casted_value_field("decimal"), cast(value)))
+      end
+      operation :lteq, operator: OPS[:lteq] do |value|
+        scope.where(lteq(casted_value_field("decimal"), cast(value)))
+      end
+
+      private
+
+      def cast(value)
+        Casters::DecimalCaster.new(precision: active_field.precision).deserialize(value)
+      end
+    end
+  end
+end

data/lib/active_fields/finders/enum_array_finder.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module ActiveFields
+  module Finders
+    class EnumArrayFinder < ArrayFinder
+      operation :include, operator: OPS[:include] do |value|
+        scope.where(value_match_any("==", cast(value)))
+      end
+      operation :not_include, operator: OPS[:not_include] do |value|
+        scope.where.not(value_match_any("==", cast(value)))
+      end
+      operation :size_eq, operator: OPS[:size_eq] do |value|
+        scope.where(value_size_eq(value))
+      end
+      operation :size_not_eq, operator: OPS[:size_not_eq] do |value|
+        scope.where(value_size_not_eq(value))
+      end
+      operation :size_gt, operator: OPS[:size_gt] do |value|
+        scope.where(value_size_gt(value))
+      end
+      operation :size_gteq, operator: OPS[:size_gteq] do |value|
+        scope.where(value_size_gteq(value))
+      end
+      operation :size_lt, operator: OPS[:size_lt] do |value|
+        scope.where(value_size_lt(value))
+      end
+      operation :size_lteq, operator: OPS[:size_lteq] do |value|
+        scope.where(value_size_lteq(value))
+      end
+
+      private
+
+      def cast(value)
+        caster = Casters::EnumCaster.new
+        caster.serialize(caster.deserialize(value))
+      end
+
+      def jsonpath(operator) = "$[*] ? (@ #{operator} $value)"
+    end
+  end
+end

data/lib/active_fields/finders/enum_finder.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module ActiveFields
+  module Finders
+    class EnumFinder < SingularFinder
+      operation :eq, operator: OPS[:eq] do |value|
+        scope.where(eq(casted_value_field("text"), cast(value)))
+      end
+      operation :not_eq, operator: OPS[:not_eq] do |value|
+        scope.where(not_eq(casted_value_field("text"), cast(value)))
+      end
+
+      private
+
+      def cast(value)
+        Casters::EnumCaster.new.deserialize(value)
+      end
+    end
+  end
+end

data/lib/active_fields/finders/integer_array_finder.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+module ActiveFields
+  module Finders
+    class IntegerArrayFinder < ArrayFinder
+      operation :include, operator: OPS[:include] do |value|
+        scope.where(value_match_any("==", cast(value)))
+      end
+      operation :not_include, operator: OPS[:not_include] do |value|
+        scope.where.not(value_match_any("==", cast(value)))
+      end
+      operation :any_gt, operator: OPS[:any_gt] do |value|
+        scope.where(value_match_any(">", cast(value)))
+      end
+      operation :any_gteq, operator: OPS[:any_gteq] do |value|
+        scope.where(value_match_any(">=", cast(value)))
+      end
+      operation :any_lt, operator: OPS[:any_lt] do |value|
+        scope.where(value_match_any("<", cast(value)))
+      end
+      operation :any_lteq, operator: OPS[:any_lteq] do |value|
+        scope.where(value_match_any("<=", cast(value)))
+      end
+      operation :all_gt, operator: OPS[:all_gt] do |value|
+        scope.where(value_match_all(">", cast(value)))
+      end
+      operation :all_gteq, operator: OPS[:all_gteq] do |value|
+        scope.where(value_match_all(">=", cast(value)))
+      end
+      operation :all_lt, operator: OPS[:all_lt] do |value|
+        scope.where(value_match_all("<", cast(value)))
+      end
+      operation :all_lteq, operator: OPS[:all_lteq] do |value|
+        scope.where(value_match_all("<=", cast(value)))
+      end
+      operation :size_eq, operator: OPS[:size_eq] do |value|
+        scope.where(value_size_eq(value))
+      end
+      operation :size_not_eq, operator: OPS[:size_not_eq] do |value|
+        scope.where(value_size_not_eq(value))
+      end
+      operation :size_gt, operator: OPS[:size_gt] do |value|
+        scope.where(value_size_gt(value))
+      end
+      operation :size_gteq, operator: OPS[:size_gteq] do |value|
+        scope.where(value_size_gteq(value))
+      end
+      operation :size_lt, operator: OPS[:size_lt] do |value|
+        scope.where(value_size_lt(value))
+      end
+      operation :size_lteq, operator: OPS[:size_lteq] do |value|
+        scope.where(value_size_lteq(value))
+      end
+
+      private
+
+      def cast(value)
+        caster = Casters::IntegerCaster.new
+        caster.serialize(caster.deserialize(value))
+      end
+
+      def jsonpath(operator) = "$[*] ? (@ #{operator} $value)"
+    end
+  end
+end

data/lib/active_fields/finders/integer_finder.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module ActiveFields
+  module Finders
+    class IntegerFinder < SingularFinder
+      operation :eq, operator: OPS[:eq] do |value|
+        scope.where(eq(casted_value_field("bigint"), cast(value)))
+      end
+      operation :not_eq, operator: OPS[:not_eq] do |value|
+        scope.where(not_eq(casted_value_field("bigint"), cast(value)))
+      end
+      operation :gt, operator: OPS[:gt] do |value|
+        scope.where(gt(casted_value_field("bigint"), cast(value)))
+      end
+      operation :gteq, operator: OPS[:gteq] do |value|
+        scope.where(gteq(casted_value_field("bigint"), cast(value)))
+      end
+      operation :lt, operator: OPS[:lt] do |value|
+        scope.where(lt(casted_value_field("bigint"), cast(value)))
+      end
+      operation :lteq, operator: OPS[:lteq] do |value|
+        scope.where(lteq(casted_value_field("bigint"), cast(value)))
+      end
+
+      private
+
+      def cast(value)
+        Casters::IntegerCaster.new.deserialize(value)
+      end
+    end
+  end
+end

data/lib/active_fields/finders/singular_finder.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+module ActiveFields
+  module Finders
+    class SingularFinder < BaseFinder
+      private
+
+      # Arel node for `active_fields.value_meta->>const`
+      def value_field_text
+        Arel::Nodes::InfixOperation.new(
+          "->>",
+          Arel::Table.new(cte_name)[:value_meta],
+          Arel::Nodes.build_quoted("const"),
+        )
+      end
+
+      # Arel node with stored value casted to provided type
+      # E.g. `CAST active_fields.value_meta->>const AS bigint`
+      def casted_value_field(to)
+        Arel::Nodes::NamedFunction.new("CAST", [value_field_text.as(to)])
+      end
+
+      # Equal operation, that respects boolean and NULL values
+      def eq(target, value)
+        if value.is_a?(TrueClass) || value.is_a?(FalseClass) || value.is_a?(NilClass)
+          Arel::Nodes::InfixOperation.new("IS", target, Arel::Nodes.build_quoted(value))
+        else
+          target.eq(value)
+        end
+      end
+
+      # Not equal operation, that respects boolean and NULL values
+      def not_eq(target, value)
+        if value.is_a?(TrueClass) || value.is_a?(FalseClass) || value.is_a?(NilClass)
+          Arel::Nodes::InfixOperation.new("IS NOT", target, Arel::Nodes.build_quoted(value))
+        else
+          # Comparison with NULL always returns NULL.
+          # NOT NULL is always NULL as well.
+          # We expect them not to be equal to any provided value except TRUE, FALSE and NULL.
+          # So we should search for NULL values too.
+          target.not_eq(value).or(target.eq(nil))
+        end
+      end
+
+      # Greater than operation
+      def gt(target, value)
+        target.gt(value)
+      end
+
+      # Greater than or equal to operation
+      def gteq(target, value)
+        target.gteq(value)
+      end
+
+      # Less than operation
+      def lt(target, value)
+        target.lt(value)
+      end
+
+      # Less than or equal to operation
+      def lteq(target, value)
+        target.lteq(value)
+      end
+    end
+  end
+end

data/lib/active_fields/finders/text_array_finder.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module ActiveFields
+  module Finders
+    class TextArrayFinder < ArrayFinder
+      operation :include, operator: OPS[:include] do |value|
+        scope.where(value_match_any("==", cast(value)))
+      end
+      operation :not_include, operator: OPS[:not_include] do |value|
+        scope.where.not(value_match_any("==", cast(value)))
+      end
+      operation :any_start_with, operator: OPS[:any_start_with] do |value|
+        scope.where(value_match_any("starts with", cast(value)))
+      end
+      operation :all_start_with, operator: OPS[:all_start_with] do |value|
+        scope.where(value_match_all("starts with", cast(value)))
+      end
+      operation :size_eq, operator: OPS[:size_eq] do |value|
+        scope.where(value_size_eq(value))
+      end
+      operation :size_not_eq, operator: OPS[:size_not_eq] do |value|
+        scope.where(value_size_not_eq(value))
+      end
+      operation :size_gt, operator: OPS[:size_gt] do |value|
+        scope.where(value_size_gt(value))
+      end
+      operation :size_gteq, operator: OPS[:size_gteq] do |value|
+        scope.where(value_size_gteq(value))
+      end
+      operation :size_lt, operator: OPS[:size_lt] do |value|
+        scope.where(value_size_lt(value))
+      end
+      operation :size_lteq, operator: OPS[:size_lteq] do |value|
+        scope.where(value_size_lteq(value))
+      end
+
+      private
+
+      def cast(value)
+        caster = Casters::TextCaster.new
+        caster.serialize(caster.deserialize(value))
+      end
+
+      def jsonpath(operator) = "$[*] ? (@ #{operator} $value)"
+    end
+  end
+end

data/lib/active_fields/finders/text_finder.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+module ActiveFields
+  module Finders
+    class TextFinder < SingularFinder
+      operation :eq, operator: OPS[:eq] do |value|
+        scope.where(eq(casted_value_field("text"), cast(value)))
+      end
+      operation :not_eq, operator: OPS[:not_eq] do |value|
+        scope.where(not_eq(casted_value_field("text"), cast(value)))
+      end
+      operation :start_with, operator: OPS[:start_with] do |value|
+        scope.where(like(casted_value_field("text"), "#{escape_pattern(cast(value))}%"))
+      end
+      operation :end_with, operator: OPS[:end_with] do |value|
+        scope.where(like(casted_value_field("text"), "%#{escape_pattern(cast(value))}"))
+      end
+      operation :contain, operator: OPS[:contain] do |value|
+        scope.where(like(casted_value_field("text"), "%#{escape_pattern(cast(value))}%"))
+      end
+      operation :not_start_with, operator: OPS[:not_start_with] do |value|
+        scope.where(not_like(casted_value_field("text"), "#{escape_pattern(cast(value))}%"))
+      end
+      operation :not_end_with, operator: OPS[:not_end_with] do |value|
+        scope.where(not_like(casted_value_field("text"), "%#{escape_pattern(cast(value))}"))
+      end
+      operation :not_contain, operator: OPS[:not_contain] do |value|
+        scope.where(not_like(casted_value_field("text"), "%#{escape_pattern(cast(value))}%"))
+      end
+      operation :istart_with, operator: OPS[:istart_with] do |value|
+        scope.where(ilike(casted_value_field("text"), "#{escape_pattern(cast(value))}%"))
+      end
+      operation :iend_with, operator: OPS[:iend_with] do |value|
+        scope.where(ilike(casted_value_field("text"), "%#{escape_pattern(cast(value))}"))
+      end
+      operation :icontain, operator: OPS[:icontain] do |value|
+        scope.where(ilike(casted_value_field("text"), "%#{escape_pattern(cast(value))}%"))
+      end
+      operation :not_istart_with, operator: OPS[:not_istart_with] do |value|
+        scope.where(not_ilike(casted_value_field("text"), "#{escape_pattern(cast(value))}%"))
+      end
+      operation :not_iend_with, operator: OPS[:not_iend_with] do |value|
+        scope.where(not_ilike(casted_value_field("text"), "%#{escape_pattern(cast(value))}"))
+      end
+      operation :not_icontain, operator: OPS[:not_icontain] do |value|
+        scope.where(not_ilike(casted_value_field("text"), "%#{escape_pattern(cast(value))}%"))
+      end
+
+      private
+
+      def cast(value)
+        Casters::TextCaster.new.deserialize(value)
+      end
+
+      def like(target, value)
+        target.matches(value, nil, true)
+      end
+
+      def ilike(target, value)
+        target.matches(value, nil, false)
+      end
+
+      def not_like(target, value)
+        # We expect NULLs to never match the pattern
+        target.does_not_match(value, nil, true).or(target.eq(nil))
+      end
+
+      def not_ilike(target, value)
+        # We expect NULLs to never match the pattern
+        target.does_not_match(value, nil, false).or(target.eq(nil))
+      end
+
+      # Escape special chars (\, %, _) in LIKE/ILIKE pattern
+      def escape_pattern(value)
+        return unless value.is_a?(String)
+
+        value.gsub("\\", "\\\\\\").gsub("%", "\\%").gsub("_", "\\_")
+      end
+    end
+  end
+end