Docs Menu

문서 쿼리 지정

이 가이드 에서는 Mongoid를 사용하여 쿼리 지정하는 방법을 학습 수 있습니다.

쿼리 필터하다 만들어 쿼리 반환하는 문서 설정하다 를 구체화할 수 있습니다. 쿼리 필터하다 는 MongoDB 읽기 또는 쓰기 (write) 작업에서 문서를 일치시키는 데 사용하는 검색 기준을 지정하는 표현식 입니다. 쿼리 필터하다 만들 때 운전자 쿼리 와 정확히 일치하는 문서를 검색 하도록 요청하거나 더 복잡한 일치 기준을 Express 하도록 쿼리 필터를 작성할 수 있습니다.

Mongoid는 Active Record에서 사용되는 것과 유사한 쿼리 DSL(도메인별 언어 )을 제공합니다.

이 가이드 의 예제에서는 밴드 또는 음악 그룹 나타내는 Band 모델을 사용합니다. Band 모델의 정의는 다양한 쿼리 기능을 보여주기 위해 각 섹션마다 다를 수 있습니다. 일부 섹션에서는 다른 모델을 사용하여 쿼리 기능을 시연할 수 있습니다.

Mongoid 쿼리 메서드는 MongoDB 쿼리 API 에 대해 체인 가능하고 느리게 평가되는 래퍼인 Mongoid::Criteria 객체를 반환합니다. 결과를 반복할 때 쿼리가 실행됩니다. 다음 예시 간단한 쿼리 의 반환 유형을 보여 줍니다.

# Creates a simple query
Band.where(name: "Deftones")
# Returns a Criteria object
# => #<Mongoid::Criteria
# selector: {"name"=>"Deftones"}
# options: {}
# class: Band
# embedded: false>
# Evaluate the query by converting to JSON
Band.where(name: "Deftones").to_json
# Returns matching documents
# => [{"_id":"...","name":"Deftones"}]

firstlast 과 같은 메서드를 사용하여 개별 문서를 반환할 수 있습니다. each 또는 map 와 같은 메서드를 사용하여 서버 에서 문서를 조회 Criteria 객체 반복할 수도 있습니다. to_json 를 사용하여 Criteria 객체 JSON 으로 변환할 수 있습니다.

체인 메서드

기존 Criteria 객체 에 다른 쿼리 메서드를 연결하면 Mongoid가 필터하다 기준을 병합합니다.

이 섹션에서는 필터하다 기준을 만드는 데 사용할 수 있는 구문 패턴에 대해 설명합니다. 다음 구문 패턴 중 하나를 사용하여 Mongoid에서 쿼리를 지정할 수 있습니다.

  • 필드 구문

  • 쿼리 API 구문

  • 기호 연산자 구문

참고

구문 동작

이러한 구문은 점 표기법 사용하여 내장된 문서를 쿼리할 수 지원 . 쿼리되는 필드 모델 클래스에 정의된 경우 구문은 필드 별칭 및 필드 유형도 준수합니다.

이 섹션의 예시에서는 다음과 같은 모델 정의를 사용합니다.

class Band
include Mongoid::Document
field :name, type: String
field :founded, type: Integer
field :m, as: :member_count, type: Integer
embeds_one :manager
end
class Manager
include Mongoid::Document
embedded_in :band
field :name, type: String
end

필드 쿼리 구문은 기본 Ruby 해시를 사용합니다. 키는 기호 또는 문자열일 수 있으며 MongoDB 문서의 필드 이름에 해당합니다.

다음 코드는 필드 쿼리 구문을 사용하여 name 필드 값이 'Depeche Mode'인 문서를 조회 두 개의 동등한 쿼리를 보여줍니다.

Band.where(name: 'Depeche Mode')
Band.where('name' => 'Depeche Mode')

다음과 같은 동등한 쿼리에서 볼 수 있듯이 해시 구문을 사용하여 모든 필드 에 Query API 연산자 지정할 수 있습니다.

Band.where(founded: {'$gt' => 1980})
Band.where('founded' => {'$gt' => 1980})

다음 코드와 같이 Query API 연산자를 각 필드 이름에 대한 기호에 대한 메서드로 지정할 수 있습니다.

Band.where(:founded.gt => 1980)

이 섹션에서는 다양한 유형의 값이 있는 필드에 대해 쿼리를 수행하는 방법을 설명합니다.

필드 를 쿼리 위해 필드 모델 클래스 정의에 있을 필요는 없습니다. 그러나 필드 모델 클래스에 정의되어 있는 경우, Mongoid는 쿼리 구성할 때 정의된 필드 유형과 일치하도록 쿼리 값을 강제합니다.

다음 코드는 founded 필드 쿼리할 때 문자열 값을 지정합니다. founded 필드 모델 클래스에서 Integer 값을 갖도록 정의되어 있으므로 Mongoid는 쿼리 수행할 때 문자열 '2020'2020 로 강제 적용합니다.

Band.where(founded: '2020')

Mongoid에서 필드를 정의하는 방법에 대해 자세히 학습 필드 유형 가이드 참조하세요.

Mongoid의 쿼리 유형 강제 동작을 우회하고 데이터베이스 에서 원시 유형 값을 직접 쿼리 다음 코드와 같이 쿼리 값을 Mongoid::RawValue 클래스로 래핑합니다.

Band.where(founded: Mongoid::RawValue('2020'))

쿼리는 모델 클래스 정의에서 설정하다 했을 수 있는 저장 필드 이름과 필드 별칭을 따릅니다.

id_id 필드는 별칭이므로 쿼리에 두 필드 이름 중 하나를 사용할 수 있습니다.

Band.where(id: '5ebdeddfe1b83265a376a760')
Band.where(_id: '5ebdeddfe1b83265a376a760')

내장된 문서의 필드 값을 쿼리 하려면 점 표기법 사용할 수 있습니다. 다음 코드는 내장된 Manager 문서 의 name 필드 'Smith'인 문서를 검색합니다.

Band.where('manager.name' => 'Smith')

다음 코드는 포함된 필드 에서 쿼리할 때 기호 연산자 사용하는 방법을 보여줍니다.

Band.where(:'manager.name'.ne => 'Smith')

참고

쿼리는 모든 조건이 내장된 문서 필드를 참조하더라도 항상 최상위 모델 인스턴스를 반환합니다.

Mongoid는 Criteria 객체에 대해 다음과 같은 논리적 연산을 지원합니다.

  • and

  • or

  • nor

  • not

이러한 메서드는 하나 이상의 조건 해시 또는 다른 Criteria 객체 인수로 사용합니다. not 연산에는 인수가 없는 버전이 있습니다.

다음 코드는 쿼리에서 논리 연산을 사용하는 방법을 보여줍니다.

# Uses "and" to combine criteria
Band.where(label: 'Trust in Trance').and(name: 'Astral Projection')
# Uses "or" to specify criteria
Band.where(label: 'Trust in Trance').or(Band.where(name: 'Astral Projection'))
# Uses "not" to specify criteria
Band.not(label: 'Trust in Trance', name: 'Astral Projection')
# Uses "not" without arguments
Band.not.where(label: 'Trust in Trance', name: 'Astral Projection')

참고

배열 매개변수

이전 Mongoid 버전과의 호환성을 보장하기 위해 논리 연산 메서드는 기준을 얻기 위해 평면화되는 매개변수 배열을 허용합니다.

배열을 논리 연산에 전달하는 기능은 더 이상 사용되지 않으며 향후 버전에서 제거될 수 있습니다.

다음 쿼리는 동일한 조건을 생성합니다.

# Conditions passed to separate "and" calls
Band.and(name: 'Sun Kil Moon').and(member_count: 2)
# Multiple conditions in the same "and" call
Band.and({name: 'Sun Kil Moon'}, {member_count: 2})
# Multiple conditions in an array - Deprecated
Band.and([{name: 'Sun Kil Moon'}, {member_count: 2}])
# Condition in "where" and a scope
Band.where(name: 'Sun Kil Moon').and(Band.where(member_count: 2))
# Condition in "and" and a scope
Band.and({name: 'Sun Kil Moon'}, Band.where(member_count: 2))
# Scope as an array element, nested arrays - Deprecated
Band.and([Band.where(name: 'Sun Kil Moon'), [{member_count: 2}]])

논리 연산자는 Active Record와 동일한 의미 체계를 갖습니다.

동일한 필드 에 조건을 여러 번 지정하면 다음 코드의 쿼리에 표시된 대로 모든 조건이 기준에 추가됩니다.

# Combines as "and"
Band.where(name: 'Swans').where(name: 'Feist')
# Combines as "or"
Band.where(name: 'Swans').or(name: 'Feist')

any_of, none_of, nornot 작업은 유사하게 작동합니다.

and, ornor 논리 연산자를 사용하면 해당 점 까지 구성된 기준에 따라 작동합니다.

# "or" applies to the first condition, and the second is combined
# as "and"
Band.or(name: 'Sun').where(label: 'Trust')
# Same as previous example - "where" and "and" are aliases
Band.or(name: 'Sun').and(label: 'Trust')
# Same operator can be stacked any number of times
Band.or(name: 'Sun').or(label: 'Trust')
# The last label condition is added to the top level as "and"
Band.where(name: 'Sun').or(label: 'Trust').where(label: 'Feist')
# Interpreted query:
# {"$or"=>[{"name"=>"Sun"}, {"label"=>"Trust"}], "label"=>"Feist"}

인수 없이 not 메서드를 사용할 수 있으며, 이 경우 지정된 다음 조건이 무효화됩니다. not 메서드는 하나 이상의 해시 조건 또는 Criteria 객체를 사용하여 호출할 수 있으며, 이들은 모두 부정되고 기준에 추가됩니다.

다음 예시는 not의 동작을 보여줍니다.

# "not" negates "where"
Band.not.where(name: 'Best')
# The second "where" is added as "$and"
Band.not.where(name: 'Best').where(label: /Records/)
# "not" negates its argument
Band.not(name: 'Best')

참고

MongoDB 에서는 $not 연산자 문자열 인수와 함께 사용할 수 없습니다. Mongoid는 $ne 연산자 사용하여 부정을 수행합니다.

# String negation - uses "$ne"
Band.not.where(name: 'Best')
# Regex negation - uses "$not"
Band.not.where(name: /Best/)

and와 마찬가지로 not 연산은 간단한 필드 기준에 대한 개별 조건을 무효화합니다. 복잡한 조건의 경우 및 필드 에 이미 조건이 정의되어 있는 경우, Mongoid는 $not {'$and' => [{'$nor' => ...}]} 구문을 사용하여 를 에뮬레이션하는데, 이는 MongoDB $not 전역이 아닌 필드 단위로만 연산자 지원하기 때문입니다.

# Simple condition
Band.not(name: /Best/)
# Complex conditions
Band.where(name: /Best/).not(name: 'Astral Projection')
# Symbol operator syntax
Band.not(:name.ne => 'Astral Projection')

배열 또는 정규 표현식과 함께 를 사용하는 경우 not $not 서버 매뉴얼에서의 제한 사항을 참조하세요.

기본값 으로 쿼리 에 조건을 추가할 때 Mongoid는 각 조건을 완전하고 쿼리 에 있는 다른 조건과 독립적으로 간주합니다. 예시 들어 in 를 두 번 호출하면 두 개의 개별 $in 조건이 추가됩니다.

Band.in(name: ['a']).in(name: ['b'])
# Interpreted query:
# {"name"=>{"$in"=>["a"]}, "$and"=>[{"name"=>{"$in"=>["b"]}}]}

일부 연산자 메서드는 조건 작성을 점진적으로 지원 . 지원되는 연산자 중 하나를 사용하는 조건을 추가하면 Mongoid는 동일한 연산자 사용하는 동일한 필드 에 이미 조건이 있는지 확인합니다. 이 경우 지정된 병합 전략에 따라 연산자 표현식이 결합됩니다. 다음 섹션에서는 사용 가능한 병합 전략에 대해 설명합니다.

Mongoid는 다음과 같은 병합 전략을 제공합니다.

  • 재정의: 새 연산자 인스턴스 동일한 연산자 사용하여 동일한필드 의 기존 조건을 대체합니다.

  • Intersect(교차): 동일한 필드에 동일한 연산자를 사용하는 조건이 이미 있는 경우, 기존 조건의 값이 새 조건의 값과 교차되고 그 결과가 연산자 값으로 저장됩니다.

  • Union(합집합): 동일한 필드에 동일한 연산자를 사용하는 조건이 이미 있는 경우, 새 조건의 값이 기존 조건의 값에 추가되고 그 결과가 연산자 값으로 저장됩니다.

다음 코드는 병합 전략이 예시 연산자 로 in 을 사용하여 기준을 생성하는 방법을 보여 줍니다.

Band.in(name: ['a']).override.in(name: ['b'])
# Interpreted query:
# {"name"=>{"$in"=>["b"]}}
Band.in(name: ['a', 'b']).intersect.in(name: ['b', 'c'])
# Interpreted query:
# {"name"=>{"$in"=>["b"]}}
Band.in(name: ['a']).union.in(name: ['b'])
# Interpreted query:
# {"name"=>{"$in"=>["a", "b"]}}

전략은 Criteria 인스턴스에서 override, intersect 또는 union을 호출해서 요청합니다. 요청된 전략은 쿼리에서 호출되는 다음 조건 메서드에 적용됩니다. 호출된 다음 조건 메서드가 병합 전략을 지원하지 않으면 다음 예시와 같이 전략이 재설정됩니다.

Band.in(name: ['a']).union.ne(name: 'c').in(name: ['b'])
# Interpreted query:
# {"name"=>{"$in"=>["a"], "$ne"=>"c"}, "$and"=>[{"name"=>{"$in"=>["b"]}}]}

ne 은 병합 전략을 지원 하지 않으므로 union 전략은 무시되고 재설정됩니다. 그런 다음 in 를 두 번째로 호출하면 활성 전략이 없습니다.

경고

병합 전략은 이전 조건이 쿼리 의 최상위 수준에 추가되었다고 가정합니다. 그러나 조건이 $and 절 아래에 중첩될 수 있으므로 항상 그런 것은 아닙니다. 복잡한 기준과 함께 병합 전략을 사용하면 잘못된 쿼리가 생성될 수 있습니다.

병합 전략을 지원하는 연산자 메서드는 다음과 같습니다.

  • all

  • in

  • nin

메서드 설정하다 는 Mongoid의 향후 릴리스에서 확장될 수 있습니다. 향후 호환성을 보장하려면 다음 메서드 호출이 병합 전략을 지원하는 연산자 인 경우에만 전략 메서드를 호출하세요.

병합 전략은 지정된 메서드를 통해 조건이 추가된 경우에만 적용됩니다. 다음 예시 에서는 두 번째 조건이 in을(를) 사용하지 않고 where(으)로 추가되기 때문에 병합 전략이 적용되지 않습니다.

Band.in(name: ['a']).union.where(name: {'$in' => 'b'})
# Interpreted query:
# {"foo"=>{"$in"=>["a"]}, "$and"=>[{"foo"=>{"$in"=>"b"}}]}

병합 전략을 지원 하는 연산자 메서드는 Array 을 값 유형으로 사용합니다. Mongoid는 이러한 연산자 메서드와 함께 사용될 때 Range와 같은 Array호환 유형을 확장합니다.

다음 예시 in 메서드를 사용할 때 Range 객체 쿼리 값으로 전달하는 방법을 보여 줍니다.

Band.in(year: 1950..1960)
# Interpreted query:
# {"year"=>{"$in"=>[1950, 1951, 1952, 1953, 1954, 1955, 1956, 1957, 1958, 1959, 1960]}}

Mongoid는 다음 예시 와 같이Array 이 아닌 값을 배열로 래핑합니다.

Band.in(year: 1950)
# Interpreted query: {"year"=>{"$in"=>[1950]}}

elem_match 메서드를 사용하여 지정된 모든 쿼리 기준과 일치하는 요소가 하나 이상 있는 배열 필드 포함된 문서를 일치시킬 수 있습니다.

다음 예시 배열 필드 포함된 샘플 문서 만듭니다. 그런 다음 elem_match 메서드를 사용하여 tour 배열 필드 에 city 값이 'London'인 항목이 포함된 문서를 일치시킵니다.

aerosmith = Band.create!(name: 'Aerosmith', tours: [
{city: 'London', year: 1995},
{city: 'New York', year: 1999},
])
swans = Band.create!(name: 'Swans', tours: [
{city: 'Milan', year: 2014},
{city: 'Montreal', year: 2015},
])
# Returns only "Aerosmith"
Band.elem_match(tours: {city: 'London'})

elem_match 메서드를 사용하여 포함된 연결을 일치시킬 수 있습니다.

이 예시 BandTour 간의 포함된 연결을 정의하는 다음 모델을 사용합니다.

class Band
include Mongoid::Document
field :name, type: String
embeds_many :tours
end
class Tour
include Mongoid::Document
field :city, type: String
field :year, type: Integer
embedded_in :band
end

다음 코드는 Band 객체 와 포함된 Tour 객체를 만든 다음 elem_match 메서드를 사용하여 city 필드 를 쿼리 .

aerosmith = Band.create!(name: 'Aerosmith')
Tour.create!(band: aerosmith, city: 'London', year: 1995)
Tour.create!(band: aerosmith, city: 'New York', year: 1999)
# Returns the "Aerosmith" document
Band.elem_match(tours: {city: 'London'})

참고

MongoDB 컬렉션에 대해 조인 작업을 수행하지 않으므로 비포함된 연결에는 elem_match 을(를) 사용할 수 없습니다. 이 쿼리 수행하면 연결의 컬렉션 이 아닌 비포함된 연결의 소스인 컬렉션 에 조건이 추가됩니다.

다음 예시 와 같이 elem_match 를 사용하여 재귀적으로 포함된 연관 관계를 쿼리 할 수 있습니다.

class Tag
include Mongoid::Document
field name:, type: String
recursively_embeds_many
end
# Creates the root Tag
root = Tag.create!(name: 'root')
# Adds embedded Tags
sub1 = Tag.new(name: 'sub_tag_1', child_tags: [Tag.new(name: 'sub_sub_tag_1')])
root.child_tags << sub1
root.child_tags << Tag.new(name: 'sub_tag_2')
root.save!
# Searches for Tag in which one child Tag tame is "sub_tag_1"
Tag.elem_match(child_tags: {name: 'sub_tag_1'})
# Searches for a child Tag in which one child Tag tame is "sub_sub_tag_1"
root.child_tags.elem_match(child_tags: {name: 'sub_sub_tag_1'})

연관 관계에 대해 자세히 학습 연관 관계 가이드 참조하세요.

Mongoid는 _id 값으로 문서를 쿼리 할 수 있는 find 메서드를 제공합니다.

다음 예시 find 메서드를 사용하여 문서 지정된 _id 필드 값과 일치시킵니다.

Band.find('6725342d4cb3e161059f91d7')

참고

유형 변환

find 메서드에 ID 값을 전달하면 메서드가 해당 값을 모델의 _id 필드 에 선언된 데이터 유형 으로 변환합니다. 기본값 으로 _id 필드 BSON::ObjectId 유형으로 정의됩니다.

앞의 예시 BSON::ObjectId 인스턴스 를 인수로 find에 전달하는 다음 코드와 동일합니다.

Band.find(BSON::ObjectId.from_string('5f0e41d92c97a64a26aabd10'))

Ruby 운전자 사용하여 _id 필드 를 쿼리 하는 경우 find 는 내부적으로 유형 변환을 수행하지 않습니다.

find 메서드는 여러 개의 인수 또는 인수의 배열 허용합니다. Mongoid는 각 인수 또는 배열 요소를 _id 값으로 해석하고 다음 예시 와 같이 배열 에 지정된 _id 값이 모두 포함된 문서를 반환합니다.

# Equivalent ways to match multiple documents
Band.find('5f0e41d92c97a64a26aabd10', '5f0e41b02c97a64a26aabd0e')
Band.find(['5f0e41d92c97a64a26aabd10', '5f0e41b02c97a64a26aabd0e'])

find 메서드는 다음과 같은 동작을 나타냅니다.

  • 동일한 _id 값을 두 번 이상 제공하면 Mongoid는 하나의 문서 만 반환합니다(있는 경우).

  • Mongoid는 문서를 순서대로 반환하지 않습니다. 문서가 제공된 _id 값의 순서와 다른 순서로 반환될 수 있습니다.

  • 데이터베이스 에서 _id 값을 찾을 수 없는 경우 결과는 raise_not_found_error 구성 옵션의 값에 따라 달라집니다.

    raise_not_found_error 옵션을 true로 설정하다 경우 _id 값 중 하나라도 발견되지 않으면 find 에서 Mongoid::Errors::DocumentNotFound 오류가 발생합니다.

    raise_not_found_error 옵션을 false 로 설정하다 하고 단일 _id 값을 쿼리 경우, Mongoid가 문서 와 일치하지 않으면 findnil 를 반환합니다. 여러 개의 _id 값을 전달했는데 일부 또는 전부가 일치하지 않는 경우, 반환 값은 일치하는 문서의 배열 이거나 일치하는 문서가 없는 경우 빈 배열 입니다.

이 섹션에서는 이전 섹션에서 설명한 find 메서드와 유사한 메서드에 대해 설명합니다.

find_by 메서드를 사용하여 제공된 기준에 따라 문서를 조회 할 수 있습니다. 문서를 찾을 수 없으면 raise_not_found_error 구성 옵션을 설정하다 방법에 따라 오류가 발생하거나 nil 를 반환합니다.

다음 코드는 find_by 메서드를 사용하는 방법을 보여줍니다.

# Simple equality query
Band.find_by(name: "Photek")
# Performs an action on each returned result
Band.find_by(name: "Tool") do |band|
band.fans += 1
end

find_or_create_by 메서드를 사용하여 제공된 기준에 따라 문서를 조회 할 수 있습니다. 문서를 찾을 수 없으면 MongoDB 에 저장된 인스턴스 를 생성하고 반환합니다.

다음 코드는 find_or_create_by 메서드를 사용하는 방법을 보여줍니다.

# If no matches, creates a Band with just the "name" field
Band.find_or_create_by(name: "Photek")
# If no matches, creates a Band with just the "name" field because the
# query condition is not a literal
Band.where(:likes.gt => 10).find_or_create_by(name: "Photek")
# Creates a Band in which the name is Aerosmith because there is no
# document in which "name" is Photek and Aerosmith at the same time
Band.where(name: "Photek").find_or_create_by(name: "Aerosmith")

find_or_initialize_by 메서드를 사용하여 제공된 기준에 따라 문서를 조회 할 수 있습니다. 문서를 찾을 수 없으면 MongoDB 에 유지하지 않고 새 문서를 반환합니다. find_or_create_by 메서드에서와 동일한 구문을 find_or_initialize_by 에 사용합니다.

Mongoid를 사용하면 필터하다 기준에 정규 표현식을 사용하여 문서를 쿼리 할 수 있습니다.

다음 코드는 샘플 Band 모델을 생성합니다.

Band.create!(name: 'Tame Impala', description: "Tame\nImpala is an American band")

다음 코드와 같이 Ruby 정규 표현식을 사용하여 쿼리를 수행할 수 있습니다.

# Matches documents in which the "name" field includes the string "impala"
Band.where(name: /impala/i)
# => Returns sample document

PCRE( 펄 (Perl) 호환 정규 표현식) 구문과 BSON::Regexp::Raw 객체를 사용하여 쿼리를 수행할 수도 있습니다.

# Matches "description" values that start exactly with "Impala"
Band.where(description: /\AImpala/)
# => nil
# Matches "description" values that start exactly with "Impala"
Band.where(description: BSON::Regexp::Raw.new('^Impala'))
# => nil
# Matches "description" values that start exactly with "Impala" with
# the multiline option
Band.where(description: BSON::Regexp::Raw.new('^Impala', 'm'))
# => Returns sample document

모델에 정의된 필드 에 쿼리 지정할 때 필드 에 지정된 데이터 유형 있는 경우 Mongoid는 필드 정의 방식에 따라 쿼리 값을 변환합니다.

Date값 필드, Time값 필드 및 암시적 Object값 필드 포함하는 다음 Album 모델 정의를 고려하세요. 또한 이 모델은 라는 필드 의도적으로 정의하지 last_reviewed 않습니다.

class Album
include Mongoid::Document
field :release_date, type: Date
field :last_commented, type: Time
field :last_purchased
end

다음 코드에 표시된 대로 DateTime 값을 사용하여 release_datelast_commented 필드를 쿼리 할 수 있습니다.

Album.where(release_date: Date.today)
# Interpreted query:
# {"release_date"=>2024-11-05 00:00:00 UTC}
Album.where(last_commented: Time.now)
# Interpreted query:
# {"last_commented"=>2024-11-04 17:20:47.329472 UTC}

그러나 다른 유형으로 정의된 필드에서 Date 값만 사용하여 쿼리 경우 생성된 쿼리는 다음 예시 와 같이 기본값 변환 동작을 표시합니다.

Album.where(last_commented: Date.today)
# Interpreted query:
# {"last_commented"=>Mon, 04 Nov 2024 00:00:00.000000000 EST -05:00}
Album.where(last_purchased: Date.today)
# Interpreted query:
# {"last_purchased"=>"2024-11-04"}
Album.where(last_reviewed: Date.today)
# Interpreted query:
# {"last_reviewed"=>2024-11-04 00:00:00 UTC}

앞의 예시 에서는 다음과 같은 변환이 적용.

  • 값을 사용하여 값 필드 쿼리 Date Timelast_commented 때 Mongoid는 날짜가 현지 시간으로 해석되고 구성된 구역 적용합니다.

  • 명시적 유형이 없는 last_purchased 필드 에서 쿼리할 때 날짜는 구성된 쿼리 에서 수정되지 않은 상태로 사용됩니다.

  • 정의되지 않은 last_reviewed 필드 에서 쿼리할 때 Mongoid는 Date 이 UTC에 있다고 해석하고 release_date와 같은 Date값 필드 쿼리하는 동작과 일치하는 시간으로 변환합니다.

이 섹션에서는 Mongoid에서 사용할 수 있는 더 많은 쿼리 메서드에 대해 설명합니다.

countestimated_count 메서드를 사용하여 컬렉션 의 문서 수를 계산할 수 있습니다.

count 메서드를 사용하여 필터하다 기준과 일치하는 문서 수를 계산할 수 있습니다.

# Counts all documents in collection
Band.count
# Counts documents that match criteria
Band.where(country: 'England').count

길이 및 크기 메서드

length 또는 size 메서드를 사용하여 문서 수를 계산할 수도 있습니다. 이러한 메서드는 데이터베이스 에 대한 후속 호출을 캐시 성능이 향상될 수 있습니다.

estimated_count 메서드를 사용하여 컬렉션 메타데이터 에서 컬렉션 의 대략적인 문서 수를 가져올 수 있습니다.

Band.estimated_count

메서드는 estimated_count 모델의 범위로 설정하다 조건을 포함한 쿼리 조건을 허용하지 않습니다. 기본값 범위가 있는 모델에서 이 메서드를 호출하는 경우 먼저 unscoped 메서드를 호출하여 범위를 비활성화해야 합니다.

다음 목록에 설명된 메서드를 사용하면 반환된 문서 목록에서 위치에 따라 특정 결과를 선택할 수 있습니다.

  • first: 일치하는 첫 번째 문서 반환합니다. 정수 값 매개변수를 전달하여 첫 번째 n 개 문서를 가져올 수 있습니다. 이 메서드는 자동으로 _id 필드 에서 정렬을 사용합니다. 예제는 다음 코드의 - 줄을 참조하세요.18

  • last: 마지막으로 일치하는 문서 반환합니다. 정수 값 매개변수를 전달하여 마지막 n 개 문서를 가져올 수 있습니다. 이 메서드는 자동으로 _id 필드 에서 정렬을 사용합니다. 예시 는 다음 코드의 줄을 참조하세요.11

  • first_or_create: 일치하는 첫 번째 문서 반환합니다. 일치하는 문서 없는 경우 새로 저장한 문서를 만들어 반환합니다.

  • first_or_initialize: 일치하는 첫 번째 문서 반환합니다. 일치하는 문서 없으면 새 문서를 반환합니다.

  • second: 일치하는 두 번째 문서 반환합니다. _id 필드 에서 자동으로 정렬을 사용합니다.

  • third: 일치하는 세 번째 문서 반환합니다. _id 필드 에서 자동으로 정렬을 사용합니다.

  • fourth: 네 번째 일치하는 문서 반환합니다. _id 필드 에서 자동으로 정렬을 사용합니다.

  • fifth: 일치하는 다섯 번째 문서 반환합니다. _id 필드 에서 자동으로 정렬을 사용합니다.

  • second_to_last: 마지막에서 두 번째로 일치하는 문서 반환합니다. _id 필드 에서 자동으로 정렬을 사용합니다. 예시 는 다음 코드의 줄을 참조하세요.14

  • third_to_last: 마지막에서 세 번째로 일치하는 문서 반환합니다. _id 필드 에서 자동으로 정렬을 사용합니다.

다음 코드는 앞의 목록에 설명된 몇 가지 메서드를 사용하는 방법을 보여줍니다.

1# Returns the first document in the collection
2Band.first
3
4# Returns the first matching document
5Band.where(founded: {'$gt' => 1980}).first
6
7# Returns the first two matching documents
8Band.first(2)
9
10# Returns the last matching document
11Band.where(founded: {'$gt' => 1980}).last
12
13# Returns the second to last document
14Band.second_to_last

오류 생성

이 섹션에서 설명하는 각 메서드에는 Mongoid가 어떤 문서와도 일치하지 않는 경우 오류를 반환하는 ! 접미사가 붙은 변형이 있습니다. 예시 들어, 쿼리 결과를 반환하지 않을 때 애플리케이션 에서 오류 처리를 구현 하려면 first 대신 first! 메서드를 사용합니다.

컬렉션 문서의 지정된 필드 값을 검사하려면 다음 방법을 사용할 수 있습니다.

  • distinct: 단일 필드 에 대한 고유 값 목록을 가져옵니다. 예제는 다음 코드의 - 줄을 참조하세요.17

  • pick: 제공된 필드에 대해 한 문서 에서 값을 가져옵니다. 설정되지 않은 필드와 존재하지 않는 필드에 대해 nil 을 반환합니다. 예시 는 다음 코드의 줄을 참조하세요.10

  • pluck: 제공된 필드 의 모든 값을 가져옵니다. 설정되지 않은 필드와 존재하지 않는 필드에 대해 nil 을 반환합니다. 예시 는 다음 코드의 줄을 참조하세요.13

  • tally: 지정된 필드 의 개수에 대한 값 매핑을 가져옵니다. 예시 는 다음 코드의 줄을 참조하세요.16

앞의 메서드는 점 표기법 사용하여 참조된 필드 이름을 허용하므로 내장된 연관 관계에서 필드를 참조할 수 있습니다. 또한 내장된 문서에 정의된 별칭을 포함하여 필드 별칭을 준수합니다.

다음 코드는 이러한 메서드를 사용하는 방법을 보여줍니다.

1Band.distinct(:name)
2# Example output: "Ghost Mountain" "Hello Goodbye" "She Said"
3
4Band.where(:members.gt => 2).distinct(:name)
5# Example output: "Arctic Monkeys" "The Smiths"
6
7Band.distinct('tours.city')
8# Example output: "London" "Sydney" "Amsterdam"
9
10Band.all.pick(:name)
11# Example output: "The Smiths"
12
13Band.all.pluck(:country)
14# Example output: "England" "Spain" "England" "Japan"
15
16Band.all.tally(:country)
17# Example output: ["England",2] ["Italy",3]

다음 목록에서는 다른 카테고리에 속하지 않는 Mongoid 메서드에 대해 설명합니다:

  • each: 일치하는 모든 문서를 반복합니다.

# Print each matching document "name" to console
Band.where(:members.gt => 1).each do |band|
p band.name
end
  • exists?: 일치하는 문서가 있는지 확인하고, 일치하는 문서 하나 이상 발견되면 true 를 반환합니다.

# Checks existence of any document
Band.exists?
# Checks existence based on query
Band.where(name: "Le Tigre").exists?
Band.exists?(name: "Le Tigre")
# Checks existence based on "_id" value
Band.exists?('6320d96a3282a48cfce9e72c')
# Always returns false
Band.exists?(false)
Band.exists?(nil)

Mongoid가 결과를 반환하는 방식을 수정하는 방법을 학습 쿼리 결과 수정을 참조하세요.

모델에서 범위를 정의하는 방법에 대해 자세히 학습 범위 지정을 참조하세요.

데이터를 유지하기 위해 쿼리에 연결할 수 있는 메서드에 대해 학습 쿼리에서 데이터 유지를 참조하세요.

쿼리 캐시 기능 에 대해 학습 쿼리 캐시를 참조하세요.

비동기 쿼리를 수행하는 방법을 학습 비동기 쿼리를 참조하세요.