/ /

Referência de query

Operadores e coletores

Página inicial do Docs

Operadores e coletores

`span` ( Operador de pesquisa MongoDB )

Definição

Observação

O operador span está obsoleto. Em vez disso, use a frase.

span

O operador span encontra correspondências no Atlas Search de texto em regiões de um campo de texto. Você pode usá-lo para encontrar strings próximas umas das outras com graus de precisão especificados. O operador span é mais intensivo em termos de computação do que os outros operadores, pois as queries devem manter o controle das informações de posição.

span é um operador de nível de termo, o que significa que o campo query não é analisado. Os operadores de nível de termo funcionam bem com o analisador de Palavras-chave porque o campo query é tratado como um único termo, com caracteres especiais incluídos.

span as queries não são classificadas por pontuação.

Sintaxe

span tem a seguinte sintaxe:

{
   $search: {
     "index": <index name>, // optional, defaults to "default"
     "span": {
       "term" | <positional-operator>": {
         <operator-specification>
       }
     }
   }
}

Observação

span consultas de pesquisa não podem usar o operador composto .

operador de termo

Você pode utilizar o operador term para especificar os termos para Atlas Search. O operador term é obrigatório e, quando usado com operadores posicionais span , ele deve ser o filho mais próximo dos operadores posicionais.

Sintaxe

O operador term tem a seguinte sintaxe:

"term": {
  "path": "<path-to-field>",
  "query": "<terms-to-search>"
}

Campos

O operador term utiliza os seguintes campos:

Opção	Tipo	Obrigatório?	Descrição
`path`	string	sim	Campo indexado para pesquisar.
`query`	string	sim	Termo ou frase para o Atlas Search.

Operadores posicionais

You can use the positional operators to specify the position of the terms that you want to search with the term operator. The positional operators are of type document. You must specify at least one positional operator in your span operator query. The positional operators can take other span positional operators, recursively.

Observação

Sobre os exemplos

The examples on this page use the sample_mflix.movies collection. If you load the sample data and create a dynamic index named default on the movies collection , you can run the following $search sample queries against the collection. The sample queries use the $limit stage to limit the results to 5 documents and the $project stage to exclude all fields except the title field in the results.

span usa os seguintes operadores posicionais opcionais.

`contains`

The contains positional operator matches terms that are contained within other terms. You can use positional operators recursively or just the term operator within contains to specify the search terms.

Sintaxe

O operador posicional contains tem a seguinte sintaxe:

{
  "$search": {
    "span": {
      "contains": {
        "spanToReturn": "inner"|"outer",
        "little": { <positional-or-term-operator-specification> },
        "big": { <positional-or-term-operator-specification> }
      }
    }
  }
}

Campos

O operador posicional contains usa os seguintes campos:

Campos

Tipo

Obrigatório?

Descrição

big

documento

sim

One or more positional operators specified recursively or just the term operator. The following table shows the type of query that span executes for big based on the value of spanToReturn.

`outer`	`span` corresponde a termos `big` que contêm pelo menos um termo `little`.
`inner`	`span` corresponde a termos de `little` que estão dentro de termos de `big`.

little

documento

sim

One or more positional operators specified recursively or just the term operator. The following table shows the type of query that span executes for little based on the value of spanToReturn.

`inner`	`span` corresponde a termos de `little` que estão dentro de termos de `big`.
`outer`	`span` corresponde a termos `big` que contêm pelo menos um termo `little`.

score

documento

Pontuação a ser aplicada aos resultados deste Atlas Search.

spanToReturn

string

sim

Tipo de query para executar e resultados correspondentes para retornar. O valor pode ser um dos seguintes:

inner - para executar uma query que corresponda aos termos de little que estão dentro dos termos de big
outer - para executar uma query que corresponda a termos de big que contenham pelo menos um termo de little

Exemplo

A consulta de exemplo a seguir usa span.contains para localizar documentos nos quais o termo train aparece com os termos great e robbery, onde great e robbery podem ter até 5 posições de diferença no title Campo .

1 db.movies.aggregate([
2   {
3     "$search": {
4       "span": {
5         "contains": {
6           "spanToReturn": "outer",
7           "little": {
8             "term": {
9               "path": "title",
10               "query": "train"
11             }
12           },
13           "big": {
14             "near": {
15               "clauses": [
16                 {
17                   "term": {
18                     "path": "title",
19                     "query": "great"
20                   }
21                 },
22                 {
23                   "term": {
24                     "path": "title",
25                     "query": "robbery"
26                   }
27                 }
28               ],
29               "slop": 5
30             }
31           }
32         }
33       }
34     }
35   },
36   {
37     "$limit": 5
38   },
39   {
40     "$project": {
41       "_id": 0,
42       "title": 1
43     }
44   }
45 ])

[
  { title: 'The Great Train Robbery' },
  { title: 'The Great Train Robbery' },
  { title: "The Great St. Trinian's Train Robbery" }
]

A Pesquisa do MongoDB retorna documentos que contêm o termo train (especificado usando little) dentro dos termos great e robbery (especificados usando big). Se você definir spanToReturn na linha 6 como inner, o MongoDB Search retornará os mesmos documentos porque o termo train (especificado usando little) aparece dentro dos termos great e robbery (especificados usando big).

`first`

The first positional operator identifies the position of the search term by using a specified number. You can specify the search terms using positional operators recursively, or just the term operator. span matches documents where the position of the search term is less than or equal to the specified number.

Sintaxe

O operador posicional first tem a seguinte sintaxe:

{
  "$search": {
    "span": {
      "first": {
        "endPositionLte": <term-position>,
        "operator": { <span-positional-or-term-operator-specification> },
        "score": { <score-options> }
      }
    }
  }
}

Campos

O operador posicional first usa os seguintes campos:

Opção	Tipo	Obrigatório?	Descrição
`endPositionLte`	int	no	Número que especifica a posição do termo do Atlas Search . Se você especificar um Atlas Search para vários termos, o último termo deverá ser menor ou igual a esse valor. Se omitido, o padrão é `3`.
`operator`	documento	sim	Document that contains the positional operators or term operator options.
`score`	documento	no	Pontuação a ser aplicada aos resultados deste Atlas Search.

Exemplo

As seguintes queries de exemplo utilizam span.first para encontrar documentos nos quais a string especificada aparece no campo title . O parâmetro endPositionLte tem um valor de 2, o que significa que o termo do Atlas Search especificado utilizando o operador term deve ser a primeira ou segunda palavra no campo.

1 db.movies.aggregate([
2   {
3     "$search": {
4       "span": {
5         "first": {
6           "endPositionLte": 2,
7           "operator": {
8             "term": {
9               "path": "title",
10               "query": "dance"
11             }
12           }
13         }
14       }
15     }
16   },
17   {
18     "$limit": 5
19   },
20   {
21     "$project": {
22       "_id": 0,
23       "title": 1
24     }
25   }
26 ])

[
  { title: 'Dance Program' },
  { title: 'Slam Dance' },
  { title: 'Last Dance' },
  { title: 'War Dance' },
  { title: 'Delhi Dance' }
]

A pesquisa do MongoDB retorna os documentos que contêm a palavra de pesquisa dance na primeira ou segunda posição do campo title.

1 db.movies.aggregate([
2   {
3     "$search": {
4       "span": {
5         "first": {
6           "endPositionLte": 2,
7           "operator": {
8             "or": {
9               "clauses": [
10                 { "term": { "path": "title", "query": "man" } },
11                 { "term": { "path": "title", "query": "woman" } }
12               ]
13             }
14           }
15         }
16       }
17     }
18   },
19   {
20     "$limit": 5
21   },
22   {
23     "$project": {
24       "_id": 0,
25       "title": 1
26     }
27   }
28 ])

[
  { title: "Everybody's Woman" },
  { title: 'Marked Woman' },
  { title: 'Wonder Man' },
  { title: 'Designing Woman' },
  { title: 'Watermelon Man' }
]

A pesquisa do MongoDB retorna documentos que contenham a palavra de pesquisa man ou woman na primeira ou segunda posição do campo title. O MongoDB Search não retorna ambos os termos de pesquisa no mesmo title porque o exemplo inclui o operador or clauses para especificar os termos de pesquisa.

`near`

O operador posicional near corresponde a duas ou mais cláusulas que contêm o termo Atlas Search próximo uma da outra. Você pode especificar os termos do Atlas Search usando uma lista de operadores posicionais recursivamente ou apenas o operador de termo .

Sintaxe

O operador posicional near tem a seguinte sintaxe:

{
  "$search": {
    "span": {
      "near": {
        "clauses": [
          { <span-positional-or-term-operator-specification> },
          ...
        ],
        "slop": <distance-number>,
        "inOrder": true|false
      }
    }
  }
}

Campos

O operador posicional near usa os seguintes campos:

Campo	Tipo	Obrigatório?	Descrição
`clauses`	matriz de documentos	sim	Span clauses that must be near one another. Clauses can't be empty. Each document contains `span` positional or just the term operator options.
`inOrder`	booleano	no	Sinalizador que especifica se o Atlas Search para termos nas cláusulas deve estar na ordem especificada e não deve estar sobreposto. O valor pode ser um dos seguintes: `true` - para Atlas Search termos nas cláusulas na ordem especificada especificada, sem sobreposição `false` - para o Atlas Search termos nas cláusulas em qualquer ordem Se omitido, o padrão é `false`.
`score`	documento	no	Pontuação a ser aplicada aos resultados deste Atlas Search.
`slop`	inteiro	no	Distância permitida entre os termos nas cláusulas. Valores mais baixos permitem uma distância posicional menor entre os termos e valores maiores permitem uma distância maior entre as palavras para satisfazer a query. O padrão é `0`, o que significa que as palavras nas diferentes cláusulas devem ser adjacentes para serem consideradas correspondentes.

Exemplo

O exemplo de query a seguir usa span.near para o Atlas Search para documentos nos quais as strings prince e pauper são encontradas próximas uma da outra. O parâmetro inOrder é definido como false, para que os termos do Atlas Search possam estar em qualquer ordem. O parâmetro slop é definido como 4, de modo que os termos do Atlas Search possam ser separados por apenas 4 palavras.

1 db.movies.aggregate([
2   {
3     "$search" : {
4       "span": {
5         "near": {
6           "clauses": [
7             { "term": { "path": "title", "query": "prince" } },
8             { "term": { "path": "title", "query": "pauper" } }
9           ],
10           "slop": 4,
11           "inOrder": false
12         }
13       }
14     }
15   },
16   {
17     "$limit": 5
18   },
19   {
20     "$project": {
21       "_id": 0,
22       "title": 1
23     }
24   }
25 ])

[ { title: 'The Prince and the Pauper' } ]

O MongoDB Search retorna um documento que contém as palavras de pesquisa prince e pauper, separadas por menos de quatro palavras, no campo title.

`or`

O operador posicional or corresponde a qualquer uma de duas ou mais cláusulas. Você pode especificar os termos do Atlas Search usando uma lista de operadores posicionais recursivamente ou apenas o operador de termo .

Sintaxe

O operador posicional or tem a seguinte sintaxe:

{
  "$search": {
    "span": {
      "or": {
        "clauses": [
          { <span-positional-or-term-operator-specification> },
          ...
        ],
        "score": { <scoring-options> }
      }
    }
  }
}

Campos

O operador posicional or usa os seguintes campos:

Opção	Tipo	Obrigatório?	Descrição
`clauses`	matriz de documentos	sim	Span clauses that specify the search terms. One of the clauses must match, and clauses can't be empty. Each document must contain `span` positional operators specified recursively or just the term operator options.
`score`	documento	no	Pontuação a ser aplicada aos resultados deste Atlas Search.

Exemplo

The following example query uses span.or clauses to specify two term operator queries that search for documents in which the title field has either city or country.

1 db.movies.aggregate([
2   {
3     "$search" : {
4       "span": {
5         "or": {
6           "clauses": [
7             { "term": { "path": "title", "query": "city" } },
8             { "term": { "path": "title", "query": "country" } }
9           ],
10         }
11       }
12     }
13   },
14   {
15     "$limit": 5
16   },
17   {
18     "$project": {
19       "_id": 0,
20       "title": 1
21     }
22   }
23 ])

[
  { title: 'Country' },
  { title: 'City Lights' },
  { title: 'King & Country' },
  { title: 'Fat City' },
  { title: 'Atlantic City' }
]

A Pesquisa do MongoDB retorna os documentos que contêm as palavras de pesquisa city ou country no campo title, mas não ambas no mesmo title.

`subtract`

The subtract positional operator removes matches that overlap with another match. You can specify the search terms using a list of positional operators recursively or just the term operator. The subtract clause can be used to exclude certain strings from your search results.

Sintaxe

O operador posicional subtract tem a seguinte sintaxe:

{
  "$search": {
    "span": {
      "subtract": {
        "include": { <span-positional-or-term-operator-specification> },
        "exclude": { <span-positional-or-term-operator-specification> }
      }
    }
  }
}

Campos

O operador posicional subtract usa os seguintes campos:

Opção	Tipo	Obrigatório?	Descrição
`exclude`	documento	sim	Document that specifies the term or phrase matches to remove that overlap with the term or phrase matches specified in the `include` field. You can specify the term or phrase using any span positional operators and the term operator.
`include`	documento	sim	Documento que especifica as correspondências de termo para incluir o uso de quaisquer operadores posicionais ou apenas o operador do termo.
`score`	documento	no	Pontuação a ser aplicada aos resultados deste Atlas Search.

Exemplo

O exemplo de query a seguir usa span.subtract para o Atlas Search para documentos nos quais o campo title contém as palavras father e son, em qualquer ordem, dentro de 3 palavras uma da outra. Exclui qualquer documento no qual a palavra like ocorra entre father e son.

1 db.movies.aggregate([
2   {
3     "$search" : {
4       "span": {
5         "subtract": {
6           "include": {
7             "near": {
8               "clauses": [
9                 { "term": { "path": "title", "query": "father" } },
10                 { "term": { "path": "title", "query": "son" } }
11               ],
12               "inOrder": false,
13               "slop": 3
14             }
15           },
16           "exclude": { "term": { "path": "title", "query": "like" } }
17         }
18       }
19     }
20   },
21   {
22     "$limit": 5
23   },
24   {
25     "$project": {
26       "_id": 0,
27       "title": 1
28     }
29   }
30 ])

[
  { title: 'Father, Son & Holy Cow' },
  { title: 'My Father and My Son' },
  { title: 'Jimmy Rosenberg: The Father, the Son & the Talent' }
]

A Pesquisa do MongoDB não retorna o documento com o título Like Father Like Son porque, embora o campo title inclua as palavras father e son, ele também tem like entre elas, que está nos critérios exclude de a query.

Voltar

regex

text

1	db.movies.aggregate([
2	{
3	"$search": {
4	"span": {
5	"contains": {
6	"spanToReturn": "outer",
7	"little": {
8	"term": {
9	"path": "title",
10	"query": "train"
11	}
12	},
13	"big": {
14	"near": {
15	"clauses": [
16	{
17	"term": {
18	"path": "title",
19	"query": "great"
20	}
21	},
22	{
23	"term": {
24	"path": "title",
25	"query": "robbery"
26	}
27	}
28	],
29	"slop": 5
30	}
31	}
32	}
33	}
34	}
35	},
36	{
37	"$limit": 5
38	},
39	{
40	"$project": {
41	"_id": 0,
42	"title": 1
43	}
44	}
45	])

1	db.movies.aggregate([
2	{
3	"$search" : {
4	"span": {
5	"near": {
6	"clauses": [
7	{ "term": { "path": "title", "query": "prince" } },
8	{ "term": { "path": "title", "query": "pauper" } }
9	],
10	"slop": 4,
11	"inOrder": false
12	}
13	}
14	}
15	},
16	{
17	"$limit": 5
18	},
19	{
20	"$project": {
21	"_id": 0,
22	"title": 1
23	}
24	}
25	])

span ( Operador de pesquisa MongoDB )

Definição

Observação

Sintaxe

Observação

operador de termo

Sintaxe

Campos

Operadores posicionais

Observação

Sobre os exemplos

contains

Sintaxe

Campos

Exemplo

first

Sintaxe

Campos

Exemplo

near

Sintaxe

Campos

Exemplo

or

Sintaxe

Campos

Exemplo

subtract

Sintaxe

Campos

Exemplo

`span` ( Operador de pesquisa MongoDB )

`contains`

`first`

`near`

`or`

`subtract`