モジュール: Mongoid::Criteria::Queryable::Selectable

次による拡張機能。
Macroable
定義:
lib/mongoid/criteria/queryable/selectable.rb

Overview

クエリ可能な選択可能な は、データベースからドキュメントを選択する機能があるという点で選択可能です。 選択可能なモジュールは、MongoDB セレクターの構築に関連するすべての機能を選択可能な に提供します。

定数の概要の削減

Line_STRING =

LineString $geometry の 定数。

'LineString'
POINT =

点 $geometry の定数。

'点'
ポリゴン =

多角形 $geometry の定数。

'多角形'

インスタンス属性の概要を折りたたむ

クラスメソッドの概要を折りたたむ

インスタンス メソッドの概要を折りたたむ

Macroableに含まれるメソッド

キー

インスタンス属性の詳細

#否定 =オブジェクト

属性が否定の値を返します。



23
24
25
 
# ファイル 'lib/mongoid/criteria/queryable/selectable.rb' は、 23行

デフォルト 否定
  @否定
end

次の式が否定される場合は、# を否定します。 （場合） =オブジェクト 



23
 
# ファイル 'lib/mongoid/criteria/queryable/selectable.rb' は、 23行

attr_accessor : 否定, : セレクター

#セレクター=オブジェクト

属性セレクターの値を返します。



23
24
25
 
# ファイル 'lib/mongoid/criteria/queryable/selectable.rb' は、 23行

デフォルト セレクター
  @Selector
end

# selector クエリ セレクター。 （クエリ セレクター） =オブジェクト 



23
 
# ファイル 'lib/mongoid/criteria/queryable/selectable.rb' は、 23行

attr_accessor : 否定, : セレクター

クラスメソッドの詳細

。 フォワードルック → 配列_シンボル<Symbol>

モデルから転送できる選択可能な のメソッドを取得します。

例:

転送可能なメソッドを取得します。

Selectable.forwardables

次の値を返します。

  • （配列<Symbol> ） —

    転送可能なメソッドの名前。



883
884
885
886
 
# ファイル 'lib/mongoid/criteria/queryable/selectable.rb' は、 883行

デフォルト forwardables
  public_instance_methods(false) -
    %i[否定 否定= 否定 セレクター SELECTOR =]
end

インスタンス メソッドの詳細

# all (*criteria) =選択可能な別名: all_in

$all 基準を追加します。

例:

基準を追加します。

selectable.all(field: [ 1, 2 ])

where クエリで $all を実行します。

selectable.where(:field.all => [ 1, 2 ])

パラメーター:

  • *criteria (ハッシュ... ) —

    $all 一致のキーと値のペア。

次の値を返します。

  • （選択可能） —

    選択可能な を複製しました。



36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
 
# ファイル 'lib/mongoid/criteria/queryable/selectable.rb' は、 36行

デフォルト すべて(*条件)
  場合 条件.空の場合
    return 複製.タップ 行う |クエリ|
      クエリ.reset_strategies!
    end
  end

  条件.inject(複製) 行う |クエリ, 条件|
    発生 Errors::CriteriaArgmentRequired, :all 場合 条件.nil?

    条件 = explain_条件_to_array_values(条件)

    場合 戦略
      送信(戦略, 条件, ' $all ')
    else
      条件.inject(クエリ) 行う |_query, (フィールド, 価値)|
        v = { ' $all ' => 価値 }
        v = { ' $not ' => v } 場合 否定
        _query.add_field_式(フィールド.to_s, v)
      end
    end
  end.reset_strategies!
end

#および(*criteria) =選択可能な別名: all_ of

$and 基準を追加します。

例:

基準を追加します。

selectable.and({ field: value }, { other: value })

パラメーター:

  • *criteria （ [ ハッシュ |基準値| 配列 ] が [ ハッシュ |基準値> ]... ） —

    複数のキーと値のペアに一致するか、結果を返すためにすべてが一致する必要がある Criteria オブジェクト。

次の値を返します。



72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
 
# ファイル 'lib/mongoid/criteria/queryable/selectable.rb' は、 72行

デフォルト および(*条件)
  _mongoid_ flatten_arrays(条件).inject(複製) 行う |c, new_s|
    new_s = new_s.セレクター 場合 new_s.is_a?(選択可能)
    正規化された = _mongoid_expand_keys(new_s)
    正規化された.各 行う |k, v|
      k = k.to_s
      場合 c.セレクター[k]
        # k にはすでに条件があります。
        # v が演算子で、既存のすべての条件が次の場合:
        や 演算子もあり、v は既存の条件に存在しないため、
        既存の条件に追加できます。
        # それ以外の場合は $and を使用します。
        場合 v.is_a?(ハッシュ) & &
           v.Length == 1 & &
           (new_k = v.キー.最初に).start_with?('$') & &
           (existing_kv = c.セレクター[k]).is_a?(ハッシュ) & &
           !existing_kv.key?(new_k) & &
           existing_kv.キー.すべて? { |sub_k| sub_k.start_with?('$') }
          merge_v = c.セレクター[k].merge(v)
          c.セレクター.store(k, merge_v)
        else
          c = c.送信(:__multi__, [ { k => v } ], ' $and ')
        end
      else
        c.セレクター.store(k, v)
      end
    end
    c
  end
end

#any_ of (*criteria) =選択可能

引数の論理和を受信者にすでに存在する基準に追加の制約として追加します。

orを使用して、レシーバーを論理和オペランドの 1 つになります。

各引数は、ハッシュ、Criteria オブジェクト、Hash または Criteria オブジェクトの配列、またはネストされた配列にすることができます。 ネストされた配列はフラット化され、任意の深さになります。 配列を渡すことは非推奨です。

例:

両方のフィールドに指定された値が必要な $or 選択を追加します。

selectable.any_of(field: 1, field: 2)

いずれかの値が一致するだけで十分な場合に $or 選択を追加します。

selectable.any_of({field: 1}, {field: 2})

前の例と同じですが、非推奨の 配列ラップ を使用しています。

selectable.any_of([{field: 1}, {field: 2}])

前の例と同じですが、これも非推奨です。

selectable.any_of([{field: 1}], [{field: 2}])

パラメーター:

  • *criteria （ [ ハッシュ |基準値| 配列 ] が [ ハッシュ |基準値> ]... ） —

    複数のキーと値のペアの一致または Criteria オブジェクト、またはそれらの配列。 配列を渡すことは非推奨です。

次の値を返します。



625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
 
# ファイル 'lib/mongoid/criteria/queryable/selectable.rb' は、 625行

デフォルト any_of(*条件)
  条件 = _mongoid_ flatten_arrays(条件)
  ケース 条件.Length
  次の場合: 0
    複製
  次の場合: 1
    # 条件が 1 つの場合、任意の _ は と のように動作します。
    注: 条件は クエリ オブジェクトにすることができます。このオブジェクトは メソッドが
    # はサポートしていません。
    自己.および(*条件)
  else
    複数の条件がある場合は、それらをすべて $or で組み合わせます
    # を作成し、その結果を自分自身に追加します。
    explains = 条件.map 行う |criterion|
      場合 criterion.is_a?(選択可能)
        _mongoid_expand_keys(criterion.セレクター)
      else
        ハッシュ[criterion.map 行う |k, v|
          場合 k.is_a?(シンボル)
            [ k.to_s, v ]
          else
            [ k, v ]
          end
        end]
      end
    end
    自己.および(' $or ' => explains)
  end
end

間での#（基準）=選択可能

範囲選択を追加します。

例:

単一の範囲内の結果と一致します。

selectable.between(field: 1..2)

複数の範囲間で結果を照合します。

selectable.between(field: 1..2, other: 5..7)

パラメーター:

  • criterion （ハッシュ） —

    複数のキーと範囲のペア。

次の値を返します。

  • （選択可能） —

    選択可能な を複製しました。

次の値が発生します。



115
116
117
118
119
120
121
122
123
124
 
# ファイル 'lib/mongoid/criteria/queryable/selectable.rb' は、 115行

デフォルト 間(criterion)
  発生 Errors::CriteriaArgmentRequired, : 間 場合 criterion.nil?

  選択(criterion) 行う |セレクター, フィールド, 価値|
    セレクター.store(
      フィールド,
      { '$gte' => 価値.min, '$lte' => 価値.最大 }
    )
  end
end

# elem_match （基準） =選択可能

$elemMatch で を選択します。

例:

単一の一致の基準を追加します。

selectable.elem_match(field: { name: "value" })

複数の一致の基準を追加しました。

selectable.elem_match(
  field: { name: "value" },
  other: { name: "value"}
)

where クエリで $elemMatch を実行します。

selectable.where(:field.elem_match => { name: "value" })

パラメーター:

  • criterion （ハッシュ） —

    フィールドと一致のペア。

次の値を返します。

  • （選択可能） —

    選択可能な を複製しました。

次の値が発生します。



143
144
145
146
147
 
# ファイル 'lib/mongoid/criteria/queryable/selectable.rb' は、 143行

デフォルト elem_match(criterion)
  発生 Errors::CriteriaArgmentRequired, :elem_match 場合 criterion.nil?

  と_with_演算子(criterion, '$elemMatch')
end

# eq （基準） =選択可能

セレクターに $eq 基準を追加します。

例:

$eq 基準を追加します。

selectable.eq(age: 60)

where クエリで $eq を実行します。

selectable.where(:field.eq => 10)

パラメーター:

  • criterion （ハッシュ） —

    確認するフィールドと値のペア。

次の値を返します。

  • （選択可能） —

    選択可能な を複製しました。

次の値が発生します。



240
241
242
243
244
 
# ファイル 'lib/mongoid/criteria/queryable/selectable.rb' は、 240行

デフォルト eq(criterion)
  発生 Errors::CriteriaArgmentRequired, :eq 場合 criterion.nil?

  と_with_演算子(criterion, '$eq')
end

# exists （基準） =選択可能

$exists 選択を追加します。

例:

単一の選択を追加します。

selectable.exists(field: true)

複数の選択を追加します。

selectable.exists(field: true, other: false)

where クエリで $exists を実行します。

selectable.where(:field.exists => true)

パラメーター:

  • criterion （ハッシュ） —

    フィールドまたはブール値の有無をチェックします。

次の値を返します。

  • （選択可能） —

    選択可能な を複製しました。

次の値が発生します。



164
165
166
167
168
169
170
 
# ファイル 'lib/mongoid/criteria/queryable/selectable.rb' は、 164行

デフォルト exists(criterion)
  発生 Errors::CriteriaArgmentRequired, :exists 場合 criterion.nil?

  typed_overwrite(criterion, ' $exists ') 行う |価値|
    Mongoid::ブール値.量用(価値)
  end
end

#expr_query (criteria) ⇒ 選択可能

このメソッドは、プライベート API の一部です。 このメソッドは将来削除または変更される可能性があるため、可能な限り使用しないでください。

指定された式をクエリに追加します。

基準は、次のいずれかの形式のハッシュである必要があります。

  • 価値
  • => 値
  • 価値
  • =オペレーター>_値_式

フィールド名と演算子は、string または記号のいずれかとして指定できます。

例:

選択範囲を作成します。

selectable.expr_query(age: 50)

パラメーター:

  • criterion （ハッシュ） —

    フィールドと値のペア。

次の値を返します。

  • （選択可能） —

    選択可能な を複製しました。

次の値が発生します。

  • (ArgumentError) 


795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
 
# ファイル 'lib/mongoid/criteria/queryable/selectable.rb' は、 795行

デフォルト expr_query(criterion)
  発生 ArgumentError, 「ここでは条件は nil にはできません」 場合 criterion.nil?
  ただし、 criterion.is_a?(ハッシュ)
    発生 Errors::InvalidQuery, " 式はハッシュでなければなりません: #{ Errors:: InvalidQuery
  end

  正規化された = _mongoid_expand_keys(criterion)
  複製.タップ 行う |クエリ|
    正規化された.各 行う |フィールド, 価値|
      field_s = フィールド.to_s
      場合 field_s.start_with?('$')
        # クエリ式レベルの演算子 （$andや $where など）
        クエリ.add_operator_式(field_s, 価値)
      else
        クエリ.add_field_式(フィールド, 価値)
      end
    end
    クエリ.reset_strategies!
  end
end

# geo_spaced （基準） =選択可能

注：

$geoIntersects の有効なジオメトリシェイプは、 : Intersects_line、 : Intersects_point、 : Intersects_polygon のみです。

注：

$geoWithin クエリの有効なオプションは、ジオメトリシェイプ :within_polygon と 演算子 :within_box のみです。

注：

$geoWithin クエリの :within_box 演算子は、最初の引数として左下（緯度）の座標ペアを、2 番目の引数として右上（北極と南極が入っている）の座標ペアを要求します。重要: 緯度と経度が渡される場合、座標ペアの最初の要素として経度が予想されます。ソース： https://www.mongodb.com/ja-jp/docs/manual/参照/operator/query/box/

$geoIntersects または $geoWithin 選択を追加します。 基準を展開するには、例に示すように、シンボル演算子を使用する必要があります。

例:

ラインの地理と交差する基準を追加します。

query.geo_spatial(:location.intersects_line => [[ 1, 10 ], [ 2, 10 ]])

ポイントの地理交差基準を追加します。

query.geo_spatial(:location.intersects_point => [[ 1, 10 ]])

多角形に地理交差基準を追加します。

query.geo_spatial(:location.intersects_polygon => [[ 1, 10 ], [ 2, 10 ], [ 1, 10 ]])

多角形の 基準内の地理を追加します。

query.geo_spatial(:location.within_polygon => [[ 1, 10 ], [ 2, 10 ], [ 1, 10 ]])

ボックスの基準内の地理を追加します。

query.geo_spatial(:location.within_box => [[ 1, 10 ], [ 2, 10 ])

パラメーター:

  • criterion （ハッシュ） —

    基準。

次の値を返します。

  • （選択可能） —

    選択可能な を複製しました。

次の値が発生します。



209
210
211
212
213
 
# ファイル 'lib/mongoid/criteria/queryable/selectable.rb' は、 209行

デフォルト geo_patial(criterion)
  発生 Errors::CriteriaArgmentRequired, :geo_patial 場合 criterion.nil?

  __merge__(criterion)
end

# gt (criteria) =選択可能

セレクターに $gt 基準を追加します。

例:

$gt 基準を追加します。

selectable.gt(age: 60)

where クエリで $gt を実行します。

selectable.where(:field.gt => 10)

パラメーター:

  • criterion （ハッシュ） —

    確認するフィールドと値のペア。

次の値を返します。

  • （選択可能） —

    選択可能な を複製しました。

次の値が発生します。



258
259
260
261
262
 
# ファイル 'lib/mongoid/criteria/queryable/selectable.rb' は、 258行

デフォルト gt(criterion)
  発生 Errors::CriteriaArgmentRequired, :gt 場合 criterion.nil?

  と_with_演算子(criterion, '$gt')
end

# gte （基準） =選択可能

セレクターに $gte 基準を追加します。

例:

$gte 基準を追加します。

selectable.gte(age: 60)

where クエリで $gte を実行します。

selectable.where(:field.gte => 10)

パラメーター:

  • criterion （ハッシュ） —

    確認するフィールドと値のペア。

次の値を返します。

  • （選択可能） —

    選択可能な を複製しました。

次の値が発生します。



276
277
278
279
280
 
# ファイル 'lib/mongoid/criteria/queryable/selectable.rb' は、 276行

デフォルト gte(criterion)
  発生 Errors::CriteriaArgmentRequired, :gte 場合 criterion.nil?

  と_with_演算子(criterion, '$gte')
end

（条件） ====== ======================================================

$in 選択を 選択可能に追加します。

例:

配列に $in 選択を追加します。

selectable.in(age: [ 1, 2, 3 ])

範囲に $in 選択を追加します。

selectable.in(age: 18..24)

where クエリで $in を実行します。

selectable.where(:field.in => [ 1, 2, 3 ])

パラメーター:

  • 条件 （ハッシュ） —

    フィールドと値の基準ペア。

次の値を返します。

  • （選択可能） —

    選択可能な を複製しました。

次の値が発生します。



297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
 
# ファイル 'lib/mongoid/criteria/queryable/selectable.rb' は、 297行

デフォルト in(条件)
  発生 Errors::CriteriaArgmentRequired, : で 場合 条件.nil?

  条件 = explain_条件_to_array_values(条件)

  場合 戦略
    送信(戦略, 条件, '$in')
  else
    条件.inject(複製) 行う |クエリ, (フィールド, 価値)|
      v = { '$in' => 価値 }
      v = { ' $not ' => v } 場合 否定
      クエリ.add_field_式(フィールド.to_s, v)
    end.reset_strategies!
  end
end

#js_query (criteria) = 選択可能

このメソッドは、プライベート API の一部です。 このメソッドは将来削除または変更される可能性があるため、可能な限り使用しないでください。

javascript の選択 を作成します。

例:

javascript の選択を作成します。

selectable.js_query("this.age == 50")

パラメーター:

  • criterion ( string ) —

    string としての javascript 。

次の値を返します。



826
827
828
829
830
831
832
833
834
835
836
 
# ファイル 'lib/mongoid/criteria/queryable/selectable.rb' は、 826行

デフォルト js_query(criterion)
  複製.タップ 行う |クエリ|
    場合 否定
      クエリ.add_operator_式(' $and ',
                                    [ { ' $nor ' => [ { '$where' => criterion } ] } ])
    else
      クエリ.add_operator_式('$where', criterion)
    end
    クエリ.reset_strategies!
  end
end

# lt （基準） =選択可能

セレクターに $lt 基準を追加します。

例:

$lt 基準を追加します。

selectable.lt(age: 60)

where クエリで $lt を実行します。

selectable.where(:field.lt => 10)

パラメーター:

  • criterion （ハッシュ） —

    確認するフィールドと値のペア。

次の値を返します。

  • （選択可能） —

    選択可能な を複製しました。

次の値が発生します。



326
327
328
329
330
 
# ファイル 'lib/mongoid/criteria/queryable/selectable.rb' は、 326行

デフォルト lt(criterion)
  発生 Errors::CriteriaArgmentRequired, :lt 場合 criterion.nil?

  と_with_演算子(criterion, '$lt')
end

#lte （基準）=選択可能

セレクターに $lte 基準を追加します。

例:

$lte 基準を追加します。

selectable.lte(age: 60)

where クエリで $lte を実行します。

selectable.where(:field.lte => 10)

パラメーター:

  • criterion （ハッシュ） —

    確認するフィールドと値のペア。

次の値を返します。

  • （選択可能） —

    選択可能な を複製しました。

次の値が発生します。



344
345
346
347
348
 
# ファイル 'lib/mongoid/criteria/queryable/selectable.rb' は、 344行

デフォルト lte(criterion)
  発生 Errors::CriteriaArgmentRequired, :lte 場合 criterion.nil?

  と_with_演算子(criterion, '$lte')
end

# max_ ユーザー距離（基準） =選択可能

$maxDistance の選択を 選択可能に追加します。

例:

$maxDistance の選択を追加します。

selectable.max_distance(location: 10)

パラメーター:

  • criterion （ハッシュ） —

    フィールドと距離のペア。

次の値を返します。

  • （選択可能） —

    選択可能な を複製しました。

次の値が発生します。



359
360
361
362
363
364
 
# ファイル 'lib/mongoid/criteria/queryable/selectable.rb' は、 359行

デフォルト max_ ユーザー距離(criterion)
  発生 Errors::CriteriaArgmentRequired, :max_ ユーザー距離 場合 criterion.nil?

  #$maxDistance は $near と併用する必要があります
  __add__(criterion, '$maxDistance')
end

#mod （基準） =選択可能

選択可能に $mod 選択を追加します。

例:

$mod 選択を追加します。

selectable.mod(field: [ 10, 1 ])

where クエリで $mod を実行します。

selectable.where(:field.mod => [ 10, 1 ])

パラメーター:

  • criterion （ハッシュ） —

    フィールドまたは Mod の選択。

次の値を返します。

  • （選択可能） —

    選択可能な を複製しました。

次の値が発生します。



377
378
379
380
381
 
# ファイル 'lib/mongoid/criteria/queryable/selectable.rb' は、 377行

デフォルト mod(criterion)
  発生 Errors::CriteriaArgmentRequired, :mod 場合 criterion.nil?

  と_with_演算子(criterion, '$mod')
end

#ネ（基準） =選択可能別名:除外

選択可能に $ne 選択を追加します。

例:

$ne に対する値のクエリ。

selectable.ne(field: 10)

where クエリで $ne を実行します。

selectable.where(:field.ne => "value")

パラメーター:

  • criterion （ハッシュ） —

    フィールド/値の選択。

次の値を返します。

  • （選択可能） —

    選択可能な を複製しました。

次の値が発生します。



395
396
397
398
399
 
# ファイル 'lib/mongoid/criteria/queryable/selectable.rb' は、 395行

デフォルト ne(criterion)
  発生 Errors::CriteriaArgmentRequired, :ne 場合 criterion.nil?

  と_with_演算子(criterion, '$ne')
end

両方の値が存在しない場合（基準）=選択可能

地理選択に $near 基準を追加します。

例:

$near 選択を追加します。

selectable.near(location: [ 23.1, 12.1 ])

where クエリで $near を実行します。

selectable.where(:field.near => [ 23.2, 12.1 ])

パラメーター:

  • criterion （ハッシュ） —

    フィールドとロケーションのペア。

次の値を返します。

  • （選択可能） —

    選択可能な を複製しました。

次の値が発生します。



414
415
416
417
418
 
# ファイル 'lib/mongoid/criteria/queryable/selectable.rb' は、 414行

デフォルト near(criterion)
  発生 Errors::CriteriaArgmentRequired, :near 場合 criterion.nil?

  と_with_演算子(criterion, '$near')
end

# near_sphere （基準） =選択可能

地理選択に $nearSphere 基準を追加します。

例:

$nearSphere の選択を追加します。

selectable.near_sphere(location: [ 23.1, 12.1 ])

where クエリで $nearSphere を実行します。

selectable.where(:field.near_sphere => [ 10.11, 3.22 ])

パラメーター:

  • criterion （ハッシュ） —

    フィールドとロケーションのペア。

次の値を返します。

  • （選択可能） —

    選択可能な を複製しました。

次の値が発生します。



432
433
434
435
436
 
# ファイル 'lib/mongoid/criteria/queryable/selectable.rb' は、 432行

デフォルト near_sphere(criterion)
  発生 Errors::CriteriaArgmentRequired, :near_sphere 場合 criterion.nil?

  と_with_演算子(criterion, 「$nearSphere」)
end

#否定 = true | false

現在の選択可能な は次の選択を否定しますか。

例:

選択可能な は否定か。

selectable.negating?

次の値を返します。

  • （ true | false ） —

    選択可能な が否定の場合。



490
491
492
 
# ファイル 'lib/mongoid/criteria/queryable/selectable.rb' は、 490行

デフォルト 否定
  !!否定
end

非 _in と も呼ばれます

$nin 選択を 選択可能に追加します。

例:

配列に $nin 選択を追加します。

selectable.nin(age: [ 1, 2, 3 ])

範囲に $nin 選択を追加します。

selectable.nin(age: 18..24)

where クエリで $nin を実行します。

selectable.where(:field.nin => [ 1, 2, 3 ])

パラメーター:

  • 条件 （ハッシュ） —

    フィールドと値の基準ペア。

次の値を返します。

  • （選択可能） —

    選択可能な を複製しました。

次の値が発生します。



453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
 
# ファイル 'lib/mongoid/criteria/queryable/selectable.rb' は、 453行

デフォルト nin(条件)
  発生 Errors::CriteriaArgmentRequired, :nin 場合 条件.nil?

  条件 = explain_条件_to_array_values(条件)

  場合 戦略
    送信(戦略, 条件, '$nin')
  else
    条件.inject(複製) 行う |クエリ, (フィールド, 価値)|
      v = { '$nin' => 価値 }
      v = { ' $not ' => v } 場合 否定
      クエリ.add_field_式(フィールド.to_s, v)
    end.reset_strategies!
  end
end

#none_ of (*criteria) =選択可能

引数を否定し、引数に一致しないドキュメントのみにクエリを制限します。

例:

単一の条件を除外します。

selectable.none_of(name: /Bob/)

複数の条件を除外します。

selectable.none_of(name: /Bob/, country: "USA")

複数の条件を配列として除外します。

selectable.none_of([{ name: /Bob/ }, { country: "USA" }])

パラメーター:

  • *criteria （ [ ハッシュ |基準]... ） —

    キーと値のペアが一致するか、または Criteria オブジェクトを否定します。

次の値を返します。



552
553
554
555
556
557
558
559
560
561
562
563
 
# ファイル 'lib/mongoid/criteria/queryable/selectable.rb' は、 552行

デフォルト non_ of(*条件)
  条件 = _mongoid_ flatten_arrays(条件)
  return dup 場合 条件.空の場合

  explains = 条件.map 行う |criterion|
    _mongoid_expand_keys(
      criterion.is_a?(選択可能) ? criterion.セレクター : criterion
    )
  end

  自己.および(' $nor ' => explains)
end

#nor (*criteria) =選択可能

選択可能に $nor の選択を追加します。

例:

$nor 選択を追加します。

selectable.nor(field: 1, field: 2)

パラメーター:

  • *criteria （ [ ハッシュ |基準値| 配列 ] が [ ハッシュ |基準値> ]... ） —

    複数のキーと値のペアの一致または Criteria オブジェクト。

次の値を返します。



480
481
482
 
# ファイル 'lib/mongoid/criteria/queryable/selectable.rb' は、 480行

デフォルト NULLではない(*条件)
  _mongoid_add_top_level_operation(' $nor ', 条件)
end

NULLではない(*criteria) =選択可能

引数を否定するか、引数が指定されていない場合は次の選択を否定します。

例:

次の選択を否定します。

selectable.not.in(field: [ 1, 2 ])

$not 基準を追加します。

selectable.not(name: /Bob/)

where クエリで $not を実行します。

selectable.where(:field.not => /Bob/)

パラメーター:

  • *criteria （ [ ハッシュ |基準]... ） —

    キーと値のペアが一致するか、または Criteria オブジェクトを否定します。

次の値を返します。



509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
 
# ファイル 'lib/mongoid/criteria/queryable/selectable.rb' は、 509行

デフォルト ではない(*条件)
  場合 条件.空の場合
    dup.タップ { |クエリ| クエリ.否定 = !クエリ.否定 }
  else
    条件.compact.inject(複製) 行う |c, new_s|
      new_s = new_s.セレクター 場合 new_s.is_a?(選択可能)
      _mongoid_expand_keys(new_s).各 行う |k, v|
        k = k.to_s
        場合 c.セレクター[k] || k.start_with?('$')
          c = c.送信(:__multi__, [ { ' $nor ' => [ { k => v } ] } ], ' $and ')
        elsif v.is_a?(ハッシュ)
          c = c.送信(:__multi__, [ { ' $nor ' => [ { k => v } ] } ], ' $and ')
        else
          否定_演算子 = 場合 v.is_a?(Regexp)
                               ' $not '
                             else
                               '$ne'
                             end
          c = c.送信(:__override__, { k => v }, 否定_演算子)
        end
      end
      c
    end
  end
end

#または(*criteria) =選択可能

$or を使用して、レシーバー内の既存の基準と指定された引数から論理和を作成します。

この動作（論理和オペランドの 1 つになる受信者）は、ActiveRecord の or の動作と一致します。

any_ofを使用して、引数の論理和を受信側にすでに存在する基準に追加の制約として追加します。

各引数は、ハッシュ、Criteria オブジェクト、Hash または Criteria オブジェクトの配列、またはネストされた配列にすることができます。 ネストされた配列はフラット化され、任意の深さになります。 配列を渡すことは非推奨です。

例:

両方のフィールドに指定された値が必要な $or 選択を追加します。

selectable.or(field: 1, field: 2)

いずれかの値が一致するだけで十分な場合に $or 選択を追加します。

selectable.or({field: 1}, {field: 2})

前の例と同じですが、非推奨の 配列ラップ を使用しています。

selectable.or([{field: 1}, {field: 2}])

前の例と同じですが、これも非推奨です。

selectable.or([{field: 1}], [{field: 2}])

パラメーター:

  • *criteria （ [ ハッシュ |基準値| 配列 ] が [ ハッシュ |基準値> ]... ） —

    複数のキーと値のペアの一致または Criteria オブジェクト、またはそれらの配列。 配列を渡すことは非推奨です。

次の値を返します。



595
596
597
 
# ファイル 'lib/mongoid/criteria/queryable/selectable.rb' は、 595行

デフォルト or(*条件)
  _mongoid_add_top_level_operation(' $or ', 条件)
end

# text_search （ターム、opts = nil） =選択可能

注：

https://www.mongodb.com/ja-jp/docs/manual/ 参照/operator/query/text/ あたりクエリ内で複数のテキスト検索条件を指定することはできません。Mongoid はそのようなクエリをビルドしますが、実行しようとするとサーバーはエラーを返します。

テキスト検索セレクターを構築します。

例:

テキスト検索セレクターを構築します。

selectable.text_search("testing")

オプションを使用してテキスト検索セレクターを構築します。

selectable.text_search("testing", :$language => "fr")

パラメーター:

  • ターム ( string | Symbol ) —

    MongoDB が解析し、テキスト インデックスをクエリするために使用するタームの文字列。

  • ops （ハッシュ） （デフォルトはnil ） —

    テキスト検索オプション。 オプションについては、 MongoDB のドキュメント を参照してください。

次の値を返します。

  • （選択可能） —

    選択可能な を複製しました。

次の値が発生します。



723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
 
# ファイル 'lib/mongoid/criteria/queryable/selectable.rb' は、 723行

デフォルト text_search(ターム, ops = nil)
  発生 Errors::CriteriaArgmentRequired, : ターム 場合 ターム.nil?

  複製.タップ 行う |クエリ|
    criterion = { '$text' => { ' $search ' => ターム } }
    criterion['$text'].mergeします。(ops) 場合 ops
    場合 クエリ.セレクター['$text']
      https://www.mongodb.com/ja-jp/docs/manual/reference/operator/query/text/ あたり
      複数の $text 式は現在サポートされていません
      #MongoDB サーバーですが、次の代わりにクエリを正しくビルドします:
      # 現在のテキスト検索条件で以前のテキスト検索条件を上書きする
      は 1 つのみを指定します。
      Mongoid.logger.WARN(クエリごとに複数 の $text 式は現在、サーバーではサポートされていません 。)
      クエリ.セレクター = { ' $and ' => [ クエリ.セレクター ] }.merge(criterion)
    else
      クエリ.セレクター = クエリ.セレクター.merge(criterion)
    end
  end
end

( *criteria) =選択可能

これは、ほとんどの MongoDB クエリの一般的なエントリ ポイントです。 これにより、標準フィールドである値の選択と、ハッシュメソッドを使用して拡張された選択が作成されるか、string が指定されている場合は $where 選択が作成されます。

例:

標準選択 を追加します。

selectable.where(name: "syd")

JavaScriptの選択を追加します。

selectable.where("this.name == 'syd'")

パラメーター:

  • *criterion （ [ ハッシュ | string ]... ） —

    標準選択またはJavaScript string 。

次の値を返します。

  • （選択可能） —

    選択可能な を複製しました。



757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
 
# ファイル 'lib/mongoid/criteria/queryable/selectable.rb' は、 757行

デフォルト WHERE(*条件)
  return 複製.reset_strategies! 場合 条件.空の場合

  条件.inject(自己) 行う |クエリ, criterion|
    発生 Errors::CriteriaArgmentRequired, :where 場合 criterion.nil?

    # 基準をインスタンス変数に保存する必要があるため
    # 変更可能なメソッドは、多形オブジェクトの作成方法を認識します。
    #このメソッドは原則として複数の条件を受け入れることに注意してください。
    # では、最初の 1 つだけが @criterion に保存されます。 これ
    は first_or_create などのメソッドがあるため、正常に機能します。
    # は $where に 1 つの基準のみを指定します。
    @criterion = criterion
    場合 criterion.is_a?(文字列)
      クエリ.js_query(criterion)
    else
      クエリ.expr_query(criterion)
    end
  end
end

# with_size (基準) =選択可能

注：

このメソッドは、列挙型またはシンボルの既存のサイズ設定メソッドと競合しないように #with_size という名前が付けられています。

配列フィールドに $size 選択を追加します。

例:

$size 選択を追加します。

selectable.with_size(field: 5)

where クエリで $size を実行します。

selectable.where(:field.with_size => 10)

パラメーター:

  • criterion （ハッシュ） —

    フィールドとサイズのペアの基準。

次の値を返します。

  • （選択可能） —

    選択可能な を複製しました。

次の値が発生します。



669
670
671
672
673
674
675
 
# ファイル 'lib/mongoid/criteria/queryable/selectable.rb' は、 669行

デフォルト with_size(criterion)
  発生 Errors::CriteriaArgmentRequired, :with_size 場合 criterion.nil?

  typed_overwrite(criterion, ' $size ') 行う |価値|
    ::整数.量用(価値)
  end
end

# with_type （基準） =選択可能

注：

http://vurl.me/PGOUには、すべての型のリストが含まれています。

選択可能に $type 選択を追加します。

例:

$type 選択を追加します。

selectable.with_type(field: 15)

where クエリで $type を実行します。

selectable.where(:field.with_type => 15)

パラメーター:

  • criterion （ハッシュ） —

    フィールドと type のペア。

次の値を返します。

  • （選択可能） —

    選択可能な を複製しました。

次の値が発生します。



693
694
695
696
697
698
699
 
# ファイル 'lib/mongoid/criteria/queryable/selectable.rb' は、 693行

デフォルト with_type(criterion)
  発生 Errors::CriteriaArgmentRequired, :with_type 場合 criterion.nil?

  typed_overwrite(criterion, '$type') 行う |価値|
    ::整数.量用(価値)
  end
end