Docs Menu
Docs Home
/
MongoDB Atlas
/
Atlas Search
/
쿼리 생성 및 실행
/
쿼리 생성
/
2. 연산자 및 수집기 사용

유사한 콘텐츠 더 보기

이 페이지의 내용

  • 정의
  • 행동
  • 사용법
  • 구문
  • 옵션
  • 제한 사항
  • 예시

정의

moreLikeThis

moreLikeThis 연산자는 입력 문서와 유사한 문서를 반환합니다. moreLikeThis 연산자를 사용하면 하나 이상의 지정된 문서를 기반으로 유사하거나 대체 가능한 결과를 표시하는 애플리케이션의 기능을 구축할 수 있습니다.

행동

moreLikeThis 쿼리를 실행하면 Atlas Search에서 이러한 작업을 수행합니다:

  • 연산자의 like 옵션에 지정한 입력 문서를 기반으로 제한된 수의 가장 대표적인 용어를 추출합니다.

  • 가장 대표적인 용어를 기반으로 유사한 문서를 찾기 위해 논리합(OR) 쿼리를 만들고 결과를 반환합니다.

moreLikeThis 연산자는 인덱스 구성에서 지정한 분석기를 사용하여 유사한 문서를 검색합니다. 인덱스 정의에서 분석기를 생략하면 moreLikeThis 연산자는 기본 표준 분석기를 사용합니다. 여러 분석기를 지정하는 경우 moreLikeThis 연산자는 각 분석기를 통해 입력 텍스트를 실행하고 모든 분석기에 대한 결과를 검색하여 반환합니다.

Atlas Search가 유사한 문서를 찾기 위해 구성하는 논리합(OR)을 보려면 moreLikeThis 연산자 쿼리와 함께 explain 을 사용합니다.

사용법

moreLikeThis 연산자 쿼리를 실행하기 전에 하나 이상의 입력 문서를 검색하는 것이 좋습니다. 입력 문서를 검색하려면 다음 중 하나를 수행하면 됩니다:

  • find() 와 같은 쿼리나 다른 MQL 쿼리를 실행하여 BSON 문서를 찾습니다.

  • BSON 문서를 반환하는 모든 애그리게이션 파이프라인을 실행합니다.

  • 애플리케이션에 다른 문서 소스를 사용하세요.

입력 문서를 식별한 후에는 이를 moreLikeThis 연산자에 전달할 수 있습니다.

moreLikeThis 연산자 쿼리를 실행하면 Atlas Search는 쿼리 결과에 원본 입력 문서를 반환합니다. 쿼리 결과에서 입력 문서를 생략하려면 복합 연산자 쿼리에서 moreLikeThis 연산자를 사용하고 mustNot 절의 equals 연산자를 사용하여 입력 문서를 _id 만큼 제외합니다.

구문

moreLikeThis 의 구문은 다음과 같습니다:

 {
   "$search": {
     "index": index name, // optional, defaults to "default"
     "moreLikeThis": {
       "like": [
         {
           <"field-name">: <"field-value">,
           ...
         },
         ...
       ],
       "score": <options>
     }
   }
 }

옵션

moreLikeThis 는 다음 옵션을 사용하여 쿼리를 작성합니다:

필드
유형
설명
필요성
like
하나의 BSON 문서 또는 문서 배열
Atlas Search가 쿼리할 대표 용어를 추출하는 데 사용하는 하나 이상의 BSON 문서입니다.
필수 사항
score
객체

일치하는 검색어 결과에 할당할 점수입니다. 다음 옵션을 사용하여 기본 점수를 수정할 수 있습니다.

  • boost결과 점수에 주어진 숫자를 곱합니다.

  • constant결과 점수를 주어진 숫자로 바꿉니다.

  • function결과 점수를 주어진 표현식으로 대체합니다.

쿼리에서 score 사용에 대한 자세한 내용은 결과에서 문서 채점하기를 참조하십시오.

배열에서 값을 쿼리할 때, Atlas Search는 배열 내 쿼리와 일치하는 값의 개수에 따라 일치하는 결과의 점수를 수정하지 않습니다. 점수는 배열 내부의 일치 항목 수에 관계없이 단일 일치 항목과 동일합니다.

옵션

제한 사항

moreLikeThis연산자를 사용하여 문자열이 아닌 값을 쿼리할 수 없습니다. 문자열이 아닌 값을 검색하기 위해 moreLikeThis 쿼리를 복합 연산자 쿼리의 근거리 , 범위 또는 기타 연산자와 결합할 수 있습니다.

embeddedDocument 연산자 내부의 moreLikeThis 연산자를 사용하여 배열의 문서를 쿼리할 수 없습니다.

예시

이 예시에서는 sample_mflix 데이터베이스의 movies 컬렉션을 사용합니다. 이 섹션의 각 예에서는 다양한 인덱스 정의를 사용하여 연산자의 다양한 기능을 보여줍니다.

cluster에서 예시 쿼리를 실행하기 전에, Atlas 클러스터에 샘플 데이터를 로드하고 제안된 인덱스를 만드세요. UI, API 또는 CLI를 사용하여 Atlas Search 인덱스를 만드는 방법에 대해 자세히 알아보려면 Atlas 검색 인덱스 만들기를 참조하세요. 인덱스 정의는 default라는 이름을 사용합니다.

인덱스 이름을 default로 지정하면 $search 파이프라인 단계에서 index 매개변수를 지정할 필요가 없습니다. 인덱스에 사용자 지정 이름을 지정하는 경우 index 매개변수에 이 이름을 지정해야 합니다.

예시 1: 여러 필드가 있는 단일 문서

다음 예시에서는 moreLikeThis 연산자를 사용하여 여러 필드 값과 유사한 문서를 찾습니다. 이 예시에서 인덱스 정의에는 컬렉션 내 모든 동적으로 인덱싱 가능한 필드 유형을 동적으로 인덱싱하는동적 매핑 포함되어 있습니다. sample_mflix.movies 컬렉션에 대한 인덱스 정의는 다음과 유사해야 합니다.

{
  "mappings": {
    "dynamic": true
  }
}

예시

다음 쿼리는 입력한 영화 제목 "대부" 및 입력한 영화 장르 '액션'과 유사한 영화를 검색합니다. 여기에는 출력을 5개의 결과로 제한하는 $limit 단계와 title, released 및 genres를 제외한 모든 필드를 제외하는 $project 단계가 포함됩니다.

1db.movies.aggregate([
2  {
3    "$search": {
4    moreLikeThis: {
5     like:
6      {
7        "title": "The Godfather",
8        "genres": "action"
9      }
10    }
11   }
12  },
13  { "$limit": 5},
14  {
15    $project: {
16      "_id": 0,
17      "title": 1,
18      "released": 1,
19      "genres": 1
20    }
21  }
22])
[
 { genres: [ 'Comedy', 'Drama', 'Romance' ], title: 'Godfather' },
 {
  genres: [ 'Crime', 'Drama' ],
  title: 'The Godfather',
  released: ISODate("1972-03-24T00:00:00.000Z")
 },
 {
  genres: [ 'Crime', 'Drama' ],
  title: 'The Godfather: Part II',
  released: ISODate("1974-12-20T00:00:00.000Z")
 },
 {
  genres: [ 'Crime', 'Drama' ],
  title: 'The Godfather: Part III',
  released: ISODate("1990-12-26T00:00:00.000Z")
 },
 {
  genres: [ 'Action' ],
  title: 'The Defender',
  released: ISODate("1994-07-28T00:00:00.000Z")
 }
]

Atlas Search 결과에는 입력한 영화 제목 "The Godfather" 및 입력한 영화 장르 "action"과 유사한 영화가 포함됩니다.

예시 2: 결과에서 제외된 입력 문서

다음 예시에서는 find() 를 사용하여 입력 문서를 식별한 다음 moreLikeThis 연산자를 사용하여 유사한 문서를 찾습니다. 이 예시에서 인덱스 정의는 정적 매핑을 사용하여 title, genres , _id 필드만 인덱싱합니다.

1{
2  "mappings": {
3    "dynamic": false,
4    "fields": {
5      "title": {
6        "type": "string"
7      },
8      "genres": {
9        "type": "string"
10      },
11      "_id": {
12        "type": "objectId"
13      }
14    }
15  }
16}

예시

다음 find() 쿼리는 제목이 "The Godfather"인 영화를 찾고 그 결과를 movie 안에 저장합니다. 이 쿼리는 일치하는 문서에 대해 title 및 genres 필드만 결과에 포함하도록 지정합니다. 기본적으로 find () 명령은 항상 _id 필드를 반환하며, 이 값은 클러스터에 따라 다를 수 있습니다.

movie = db.movies.find( { title: "The Godfather" }, { genres: 1, title: 1} ).toArray()
[
 {
  _id: ObjectId("573a1396f29313caabce4a9a"),
  genres: [ 'Crime', 'Drama' ],
  title: 'The Godfather'
 }
]

다음 쿼리는 moreLikeThis 연산자와 함께 복합 연산자를 사용하여 title 및 genres 필드를 쿼리하고 등호 연산자를 사용하여 다음 절을 통해 입력 문서를 제외합니다.

  • must 절은 movie에 저장된 동영상과 유사한 동영상을 쿼리합니다.

  • mustNot 절은 _id 값으로 입력 문서를 결과에서 제외합니다. 쿼리에 사용된 _id 값은 이전 find() 쿼리 결과의 _id 값과 일치합니다.

이 쿼리는 출력 결과를5개로 제한합니다. 쿼리는 $project 단계를 사용하여 _id, title, released, genres 필드를 결과에 포함합니다.

참고

이 쿼리를 실행하기 전에 13번째 줄의 _id 필드 값을 쿼리 결과의 _id 필드 값으로 바꾸세요.

1db.movies.aggregate([
2  {
3    "$search": {
4       "compound":{
5          "must":[{
6            "moreLikeThis": {
7              "like": movie
8            }
9          }],
10          "mustNot":[{
11            "equals": {
12               "path": "_id",
13               "value": ObjectId ("573a1396f29313caabce4a9a")
14            }
15          }]
16         }
17       }
18     },
19{"$limit": 5},
20{
21 "$project": {
22   "_id": 1,
23   "title": 1,
24   "released": 1,
25   "genres": 1
26  }
27 }
28])
[
 {
  _id: ObjectId("573a13acf29313caabd27afc"),
  genres: [ 'Comedy', 'Drama', 'Romance' ],
  title: 'Godfather'
 },
 {
  _id: ObjectId("573a1396f29313caabce557f"),
  genres: [ 'Crime', 'Drama' ],
  title: 'The Godfather: Part II',
  released: ISODate("1974-12-20T00:00:00.000Z")
 },
 {
  _id: ObjectId("573a1398f29313caabcebf7b"),
  genres: [ 'Crime', 'Drama' ],
  title: 'The Godfather: Part III',
  released: ISODate("1990-12-26T00:00:00.000Z")
 },
 {
  _id: ObjectId("573a1399f29313caabceed8d"),
  genres: [ 'Action' ],
  title: 'The Defender',
  released: ISODate("1994-07-28T00:00:00.000Z")
 },
 {
  _id: ObjectId("573a139af29313caabcef2a0"),
  genres: [ 'Action' ],
  title: 'The Enforcer',
  released: ISODate("1995-03-02T00:00:00.000Z")
 }
]

Atlas Search 결과에는 action 장르의 쿼리 용어 The Godfather 와 유사한 문서가 포함됩니다. 그러나 _id에 의해 제외된 문서인 ObjectId("573a1396f29313caabce4a9a")는 결과에 포함되지 않습니다.

예시 3: 여러 분석기

다음 예시에서는 find() 를 사용하여 입력 문서를 식별한 다음 moreLikeThis 연산자를 사용하여 유사한 문서를 찾습니다. 이 예시에서 인덱스 정의는 정적 매핑을 사용하여 sample_mflix.movies 컬렉션의 필드를 다른 분석기로 인덱싱합니다. 인덱스 정의는 다음과 같습니다.

  • _id, title, genres 필드에 대한 인덱스를 구성합니다.

  • lucene.standard 분석기 및 keywordAnalyzer라는 대체 분석기(lucene.keyword 분석기 사용)를 사용하여 title 필드를 분석합니다.

  • lucene.english 분석기를 사용하여 필드를 분석하고 검색합니다.

1{
2  "mappings": {
3    "dynamic": false,
4    "fields": {
5      "title": {
6        "type": "string",
7        "analyzer": "lucene.standard",
8        "multi": {
9          "keywordAnalyzer": {
10            "type": "string",
11            "analyzer": "lucene.keyword"
12          }
13        }
14      },
15      "genres": {
16        "type": "string"
17      },
18      "_id": {
19        "type": "objectId"
20      }
21    }
22  },
23  "analyzer": "lucene.english"
24}

예시

다음 find() 쿼리는 제목이 "Alice in Wonderland"인 영화를 조회하고 결과를 movie 에 저장합니다. 이 쿼리는 일치하는 문서에 대해 title 및 genres 필드만 결과에 포함하도록 지정합니다. 기본적으로 find() 명령은 항상 _id 필드를 반환하며, 이 값은 클러스터에 따라 다를 수 있습니다.

movie = db.movies.find( { title: "Alice in Wonderland" }, { genres: 1, title: 1} ).toArray
[
  {
   _id: ObjectId("573a1394f29313caabcde9ef"),
   plot: 'Alice stumbles into the world of Wonderland. Will she get home? Not if the Queen of Hearts has her way.',
   title: 'Alice in Wonderland'
  },
  {
   _id: ObjectId("573a1398f29313caabce963d"),
   plot: 'Alice is in Looking Glass land, where she meets many Looking Glass creatures and attempts to avoid the Jabberwocky, a monster that appears due to her being afraid.',
   title: 'Alice in Wonderland'
  },
  {
   _id: ObjectId("573a1398f29313caabce9644"),
   plot: 'Alice is in Looking Glass land, where she meets many Looking Glass creatures and attempts to avoid the Jabberwocky, a monster that appears due to her being afraid.',
   title: 'Alice in Wonderland'
  },
  {
   _id: ObjectId("573a139df29313caabcfb504"),
   plot: `The wizards behind The Odyssey (1997) and Merlin (1998) combine Lewis Carroll's "Alice in Wonderland" and "Through the Looking Glass" into a two-hour special that just gets curiouser and curiouser.`,
   title: 'Alice in Wonderland'
  },
  {
   _id: ObjectId("573a13bdf29313caabd5933b"),
   plot: "Nineteen-year-old Alice returns to the magical world from her childhood adventure, where she reunites with her old friends and learns of her true destiny: to end the Red Queen's reign of terror.",
   title: 'Alice in Wonderland'
  }
]

다음 예시에서는 복합 연산자를 사용하여 title 및 genres 필드를 쿼리하며, 다음 절을 사용합니다.

  • should 절은 moreLikeThis 연산자를 사용하여 movie 의 문서와 유사한 문서를 검색합니다. title 필드는 lucene.standard 및 lucene.keyword 분석기를 모두 사용하여 분석됩니다.

  • mustNot 절은 _id 값으로 지정된 입력 문서 중 하나가 결과에 포함되지 않도록 지정합니다.

이 쿼리는 결과 목록을 10개의 문서로 제한합니다. 이 쿼리는 $project 단계를 사용하여 _id, title, genres 필드를 결과에 포함합니다.

예시

1db.movies.aggregate([
2{
3   $search: {
4     "compound": {
5       "should": [{
6          "moreLikeThis": {
7             "like": movie
8          }
9       }],
10     "mustNot": [
11     {
12     "equals": {
13     "path": "_id",
14      "value": ObjectId ("573a1394f29313caabcde9ef")
15    }
16   }]
17 }
18  }
19  },
20 { $limit: 10 },
21          {
22 $project: {
23     "title": 1,
24     "genres": 1,
25     "_id": 1
26   }
27  }
28 ])
[
  {
   _id: ObjectId("573a1398f29313caabce963d"),
   genres: [ 'Adventure', 'Family', 'Fantasy' ],
   title: 'Alice in Wonderland'
  },
  {
   _id: ObjectId("573a1398f29313caabce9644"),
   genres: [ 'Adventure', 'Family', 'Fantasy' ],
   title: 'Alice in Wonderland'
  },
  {
   _id: ObjectId("573a139df29313caabcfb504"),
   genres: [ 'Adventure', 'Comedy', 'Family' ],
   title: 'Alice in Wonderland'
  },
  {
   _id: ObjectId("573a13bdf29313caabd5933b"),
   genres: [ 'Adventure', 'Family', 'Fantasy' ],
   title: 'Alice in Wonderland'
  },
  {
   _id: ObjectId("573a1396f29313caabce3e7e"),
   genres: [ 'Comedy', 'Drama' ],
   title: 'Alex in Wonderland'
  },
  {
   _id: ObjectId("573a13bdf29313caabd5a44b"),
   genres: [ 'Drama' ],
   title: 'Phoebe in Wonderland'
  },
  {
   _id: ObjectId("573a139af29313caabcf0e23"),
   genres: [ 'Documentary' ],
   title: 'Wonderland'
  },
  {
   _id: ObjectId("573a139ef29313caabcfcebc"),
   genres: [ 'Drama' ],
   title: 'Wonderland'
  },
  {
   _id: ObjectId("573a13a0f29313caabd03dab"),
   genres: [ 'Drama' ],
   title: 'Wonderland'
  },
  {
   _id: ObjectId("573a13abf29313caabd2372a"),
   genres: [ 'Crime', 'Drama', 'Mystery' ],
   title: 'Wonderland'
  }
]

다음 쿼리는 앞의 쿼리와 함께 explain을 사용하여 Atlas Search가 유사한 문서를 찾기 위해 구성하는 분리(OR)를 표시합니다.

db.movies.explain("queryPlanner").aggregate([
 {
   $search: {
     "compound": {
       "should": [{
          "moreLikeThis": {
             "like": [{
                "title": "Alice in Wonderland"
             }]
          }
       }],
     "mustNot": [
     {
     "equals": {
     "path": "_id",
      "value": ObjectId ("573a1394f29313caabcde9ef")
    }
   }]
 }
  }
  },
{ $limit: 10 },
          {
$project: {
     "title": 1,
     "genres": 1,
     "_id": 1
   }
 }
])
{
 explainVersion: '1',
   stages: [
     {
      '$_internalSearchMongotRemote': {
         mongotQuery: {
         compound: {
         should: [
          {
            moreLikeThis: { like: [ { title: 'Alice in Wonderland' } ] }
          }
         ],
         mustNot: [
          {
            equals: {
              path: '_id',
              value: ObjectId("573a1394f29313caabcde9ef")
            }
          }
         ]
      }
     },
     explain: {
      type: 'BooleanQuery',
        args: {
         must: [],
         mustNot: [
           {
             path: 'compound.mustNot',
             type: 'ConstantScoreQuery',
             args: {
               query: {
               type: 'TermQuery',
             args: {
                path: '_id',
                value: '[57 3a 13 94 f2 93 13 ca ab cd e9 ef]'
               }
              }
            }
           }
         ],
         should: [
          {
            path: 'compound.should',
            type: 'BooleanQuery',
            args: {
             must: [],
             mustNot: [],
             should: [
              {
               type: 'TermQuery',
               args: { path: 'title', value: 'in' }
              },
              {
                type: 'TermQuery',
                args: {
                  path: 'title.keywordAnalyzer',
                  value: 'Alice in Wonderland'
                }
               },
              {
                type: 'TermQuery',
                args: { path: 'title', value: 'wonderland' }
              },
              {
                type: 'TermQuery',
                args: { path: 'title', value: 'alice' }
              }
             ],
             filter: [],
              minimumShouldMatch: 0
             }
            }
          ],
            filter: [],
             minimumShouldMatch: 0
            }
           }
          }
         },
 { '$_internalSearchIdLookup': {} },
 { '$limit': Long("10") },
 { '$project': { _id: true, title: true, genres: true } }
  ],
 serverInfo: {
 ...
 },
 serverParameters: {
 ...
 },
 command: {
   aggregate: 'movies',
     pipeline: [
       {
        '$search': {
           compound: {
             should: [
               {
                 moreLikeThis: { like: [ { title: 'Alice in Wonderland' } ] }
               }
             ],
             mustNot: [
              {
                equals: {
                  path: '_id',
                  value: ObjectId("573a1394f29313caabcde9ef")
                }
              }
             ]
           }
          }
        },
  { '$limit': 10 },
  { '$project': { title: 1, genres: 1, _id: 1 } }
  ],
  cursor: {},
  '$db': 'sample_mflix'
  },
  ok: 1,
  '$clusterTime': {
  clusterTime: Timestamp({ t: 1659133479, i: 1 }),
  signature: {
     hash: Binary(Buffer.from("865d9ef1187ae1a74c4a0da1e29882aebcf2be7c", "hex"), 0),
     keyId: Long("7123262728533180420")
  }
 },
 operationTime: Timestamp({ t: 1659133479, i: 1 })
 }

돌아가기

KNNBeta (더 이상 사용되지 않음)

다음

가깝다