Class: Parse::Constraint::ArrayNeqConstraint

Inherits:

Parse::Constraint

Object
Parse::Constraint
Parse::Constraint::ArrayNeqConstraint

show all

Defined in:: lib/parse/query/constraints.rb

Overview

Note:

This constraint uses aggregation pipeline with MongoDB $ne on arrays.

Array not-equal constraint using MongoDB aggregation with $ne. Matches arrays that are NOT exactly equal (including element order). This is order-dependent: [A, B] does NOT match [A, B] but DOES match [B, A].

q.where :field.neq => ["rock", "pop"] q.where :tags.neq => [category1, category2] # for pointers

Instance Attribute Summary

Attributes inherited from Parse::Constraint

#operand, #operation, #operator, #value

Instance Method Summary collapse

#build ⇒ Hash
The compiled constraint using aggregation pipeline.
#neq ⇒ ArrayNeqConstraint
A registered method on a symbol to create the constraint.

Methods inherited from Parse::Constraint

#as_json, constraint_keyword, create, formatted_value, #formatted_value, #initialize, #key, #precedence, register, #to_s

Constructor Details

This class inherits a constructor from Parse::Constraint

Instance Method Details

#build ⇒ `Hash`

Returns the compiled constraint using aggregation pipeline.

Returns:

(Hash) —
the compiled constraint using aggregation pipeline.

# File 'lib/parse/query/constraints.rb', line 1052

def build
  val = formatted_value
  val = [val].compact unless val.is_a?(Array)

  field_name = Parse::Query.format_field(@operation.operand)

  # Check if values are pointers (Parse objects or pointer objects)
  is_pointer_array = val.any? do |item|
    item.respond_to?(:pointer) || item.is_a?(Parse::Pointer)
  end

  if is_pointer_array
    # Extract objectIds from pointers for comparison
    target_ids = val.map do |item|
      if item.respond_to?(:id)
        item.id
      elsif item.is_a?(Parse::Pointer)
        item.id
      else
        item
      end
    end

    # Validate all IDs are present (unsaved objects have nil IDs)
    if target_ids.any?(&:nil?)
      raise ArgumentError, "#{self.class.name}: Cannot use unsaved objects (missing ID) in array constraint"
    end

    # For pointer arrays, compare mapped objectIds with $ne (order matters).
    # $ifNull coerces a missing/null field to [] so $map doesn't raise a type
    # error on legacy documents that lack the field.
    pipeline = [
      {
        "$match" => {
          "$expr" => {
            "$ne" => [
              { "$map" => {
                  "input" => { "$ifNull" => ["$#{field_name}", []] },
                  "as" => "p",
                  "in" => "$$p.objectId",
                } },
              target_ids,
            ],
          },
        },
      },
    ]
  else
    # For simple value arrays, direct $ne comparison (order matters).
    # $ifNull coerces a missing/null field to [] so a doc lacking the field
    # is treated the same as one with [], consistent with set_equals/arr_empty.
    pipeline = [
      {
        "$match" => {
          "$expr" => {
            "$ne" => [
              { "$ifNull" => ["$#{field_name}", []] },
              val,
            ],
          },
        },
      },
    ]
  end

  { "__aggregation_pipeline" => pipeline }
end

#neq ⇒ `ArrayNeqConstraint`

A registered method on a symbol to create the constraint.

Examples:

q.where :field.neq => ["value1", "value2"]
q.where :categories.neq => [cat1, cat2]