Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.
# Ricerca di testo in Amazon CloudSearch
Puoi ricercare una stringa di testo sia nei campi di testo che in quelli di valori letterali:
+ È sempre possibile effettuare ricerche nei campi `Text` e `text-array`. Puoi cercare singoli termini o locuzioni. Le ricerche nei campi `text` e `text-array` non prevedono alcuna distinzione tra maiuscole e minuscole.
+ Puoi effettuare ricerche nei campi `Literal` e `literal-array` solo se sono configurati come ricercabili nelle opzioni di indicizzazione del dominio. Puoi ricercare una corrispondenza esatta della stringa di ricerca. Le ricerche nei campi letterali prevedono la distinzione tra maiuscole e minuscole.
Se utilizzi il parser di query semplici o non specifichi un campo durante la ricerca con il parser di query strutturate, per impostazione predefinita la ricerca viene effettuata in tutti i campi `text` e `text-array`. Per impostazione predefinita, la ricerca *non* viene effettuata nei campi letterali. Puoi specificare i campi in cui desideri eseguire la ricerca con il parametro `q.options`.
Puoi ricercare nel campo degli ID univoci dei documenti come in qualsiasi altro campo di testo. Per fare riferimento al campo degli ID dei documenti in una richiesta di ricerca, utilizza il nome di campo `_id`. I documenti vengono sempre restituiti nei risultati della ricerca. IDs
**Topics**
+ [Ricerca di singoli termini in Amazon CloudSearch](#searching-text-terms)
+ [Ricerca di frasi in Amazon CloudSearch](#searching-text-phrases)
+ [Ricerca di stringhe letterali in Amazon CloudSearch](#searching-text-literals)
+ [Ricerca di prefissi in Amazon CloudSearch](#searching-text-prefixes)
## Ricerca di singoli termini in Amazon CloudSearch
Quando cerchi `text` e `text-array` compili singoli termini, Amazon CloudSearch trova tutti i documenti che contengono i termini di ricerca ovunque all'interno del campo specificato, in qualsiasi ordine. Ad esempio, nei dati di esempio sui film, il campo `title` è configurato come campo `text`. Se nel campo `title` ricerchi il termine *star*, troverai tutti i film che contengono la parola *star* ovunque nel campo `title`, come *star*, *star wars* e *a star is born*. Questo tipo di ricerca è diverso da quello nei campi `literal`, il cui valore deve essere identico alla stringa di ricerca per poter essere considerato una corrispondenza.
Il parser di query `simple` fornisce un modo semplice di ricercare uno o più termini nei campi `text` e `text-array`. Se non utilizzi il parametro `q.parser` per specificare un parser di query diverso, per impostazione predefinita verrà utilizzato il parser `simple`.
Ad esempio, per cercare *katniss*, specifica `katniss` nella stringa di query. Per impostazione predefinita, Amazon CloudSearch include tutti i campi abilitati alla restituzione nei risultati di ricerca. Puoi specificare il parametro `return` per indicare i campi che desideri restituiscano i risultati.
```
https://search-domainname-domainid.us-east-1.cloudsearch.amazonaws.com/
2013-01-01/search?q=katniss&return=title
```
Per impostazione, la risposta viene restituita nel formato JSON.:
```
{
"status": {
"rid": "rd+5+r0oMAo6swY=",
"time-ms": 9
},
"hits": {
"found": 3,
"start": 0,
"hit": [
{
"id": "tt1951265",
"fields": {
"title": "The Hunger Games: Mockingjay - Part 1"
}
},
{
"id": "tt1951264",
"fields": {
"title": "The Hunger Games: Catching Fire"
}
},
{
"id": "tt1392170",
"fields": {
"title": "The Hunger Games"
}
}
]
}
}
```
Per specificare più termini, separa i termini con uno spazio. Ad esempio: `star wars`. Quando specifichi più termini di ricerca, per impostazione predefinita i documenti devono contenere tutti i termini per essere considerati una corrispondenza. I termini possono apparire ovunque e in qualsiasi ordine nel campo di testo.
Per impostazione predefinita, la ricerca viene effettuata in tutti i campi `text` e `text-array` quando utilizzi il parser di query semplici. Puoi indicare i campi in cui desideri eseguire la ricerca specificando il parametro `q.options`. Ad esempio, questa query limita la ricerca ai campi `title` e `description` e aumenta l'importanza delle corrispondenze nel campo `title` rispetto a quelle nel campo `description`.
```
q=star wars&q.options={fields: ['title^5','description']}
```
Quando utilizzi il parser di query semplici, puoi usare i seguenti prefissi per indicare i seguenti termini come necessari, opzionali o da escludere dai risultati di ricerca:
+ **`+`**—i documenti corrispondenti devono contenere il termine. Questa è l'impostazione predefinita; separando i termini con uno spazio equivale a precederli con il prefisso `+`.
+ **`-`**—esclude i documenti che contengono il termine dai risultati della ricerca. L'operatore `-` è applicabile solo ai singoli termini. Ad esempio, per escludere i documenti che contengono il termine *star* nel campo di ricerca predefinito, specifica: `-star`. La ricerca di `search?q=-star wars` consente di recuperare tutti i documenti che non contengono il termine *star*, ma che contengono il termine *wars*.
+ **`|`**—include documenti che contengono il termine nei risultati di ricerca, anche se non contengono gli altri termini. L'operatore `|` è applicabile solo ai singoli termini. Ad esempio, per includere i documenti che contengono uno dei due termini, specifica: `term1 |term2`. La ricerca di `search?q=star wars |trek` include i documenti che contengono sia *star* che *wars* oppure il termine *trek*.
Questi prefissi si applicano solo ai singoli termini in una query semplice. Per creare le query composte, occorre utilizzare il parser di query strutturate invece di quello delle query semplici. Ad esempio, per cercare i termini *star* e *wars* utilizzando la struttura parser di query strutturate, devi specificare:
```
(and 'star' 'wars')
```
Tieni presente che questa query rileva i documenti che contengono ciascuno dei termini in qualsiasi campo in cui stai effettuando la ricerca. I termini non devono trovarsi nello stesso campo per essere considerati una corrispondenza. Tuttavia, se specifichi `(and 'star wars' 'luke')`, *star* e *wars* devono essere presenti nello stesso campo, mentre *luke* può trovarsi in qualsiasi campo.
Se quando utilizzi il parser di query `structured` non specifichi alcun campo, per impostazione predefinita la ricerca viene effettuata in tutti i campi `text` e `text-array`, come con il parser `simple`. Analogamente, puoi utilizzare il parametro `q.options` per controllare i campi in cui effettuare le ricerche e aumentare l'importanza dei campi selezionati. Per ulteriori informazioni, consulta [Creazione di query composte](searching-compound-queries.md).
Puoi anche eseguire ricerche *fuzzy* con il parser di query semplici. Per eseguire una ricerca fuzzy, accoda l'operatore `~` e un valore che indica quanti termini possono essere diversi dalla stringa di query dell'utente pur continuando a essere considerati corrispondenze. Ad esempio, specificando `planit~1` viene ricercato il termine *planit* e consenti le corrispondenze diverse di un massimo di un carattere, vale a dire che i risultati includeranno le occorrenze di *planet*.
## Ricerca di frasi in Amazon CloudSearch
Quando cerchi una frase, Amazon CloudSearch trova tutti i documenti che contengono la frase completa nell'ordine specificato. Puoi anche eseguire ricerche di frasi *simili* in cui i termini appaiono entro la distanza specificata gli uni dagli altri.
Per individuare una locuzione completa anziché i singoli termini nella locuzione quando utilizzi il parser di query semplici, racchiude la locuzione tra virgolette doppie. Ad esempio, la query seguente cerca la locuzione *with love*.
```
q="with love"
```
Per eseguire una ricerca di frasi simili con il parser di query semplici, accoda l'operatore `~` e un valore di distanza. Il valore di distanza indica il numero massimo di parole che possono separare le parole nella locuzione. Ad esempio, la query seguente ricerca i termini *with love* entro tre parole distanti l'una dall'altra.
```
q="with love"~3
```
In una query composta, utilizza l'operatore `phrase` per specificare la locuzione che desideri trovare; ad esempio:
```
(phrase field=title 'star wars')
```
Per eseguire una ricerca di frasi simili in una query composta, utilizza l'operatore `near`. L'operatore `near` ti permette di specificare la locuzione che stai cercando e la distanza consentita tra i termini all'interno di un campo, pur continuando a considerare la locuzione una corrispondenza. Ad esempio, la seguente query restituisce i documenti contenenti i termini *star* e *wars* distanti non più di tre parole l'una dall'altra nel campo `title`.
```
(near field=title distance=3 'star wars')
```
Per ulteriori informazioni, consulta [Creazione di query composte](searching-compound-queries.md).
## Ricerca di stringhe letterali in Amazon CloudSearch
Quando cerchi una stringa in un campo letterale, Amazon CloudSearch restituisce solo i documenti che contengono una corrispondenza esatta per la stringa di ricerca completa nel campo specificato, maiuscole e minuscole. Ad esempio, se il `title` campo è configurato come campo letterale e cerchi *Star*, il valore del `title` campo deve essere *Star* per essere considerato una corrispondenza: *star, star* *wars* e a *star is born* non verranno inclusi nei risultati della ricerca. Questo principio è diverso da quello dei campi di testo, in cui le ricerche non prevedono la distinzione tra maiuscole e minuscole e i termini di ricerca specificati possono trovarsi ovunque e in qualsiasi ordine all'interno del campo.
Per effettuare una ricerca in un campo letterale, anteponi alla stringa di ricerca il nome del campo letterale che desideri seguito da due punti. La stringa di ricerca deve essere racchiusa tra virgolette singole. Ad esempio, la query seguente ricerca la stringa letterale *Sci-Fi*.
```
genres:'Sci-Fi'
```
In questo esempio, la ricerca viene effettuata nel campo del genere di ogni documento e restituisce tutti i documenti il cui campo del genere contiene il valore *Sci-Fi*. Per essere una corrispondenza, il valore del campo deve corrispondere esattamente alla stringa di ricerca, incluse maiuscole e minuscole. Ad esempio, i documenti che contengono il valore *Sci-Fi* nel campo del genere non saranno inclusi nei risultati di ricerca se cerchi i termini *sci-fi* o *young adult sci-fi*.
In una query composta, utilizza la sintassi dell'operatore `term` per effettuare la ricerca nei campi letterali. Ad esempio `(term field=genres 'Sci-Fi')`. Per ulteriori informazioni, consulta [Creazione di query composte](searching-compound-queries.md).
Puoi utilizzare i campi letterali congiuntamente al faceting per consentire agli utenti di eseguire il drill-down dei risultati in base agli attributi con facet. Per ulteriori informazioni sul faceting, consultare [Acquisizione e utilizzo delle informazioni Facet in Amazon CloudSearch](faceting.md).
## Ricerca di prefissi in Amazon CloudSearch
Puoi cercare`text`, `text-array``literal`, e `literal-array` nei campi un *prefisso* anziché un termine completo. In questo modo, vengono restituiti i risultati che contengono il prefisso seguito da zero o più caratteri. È necessario specificare almeno un carattere come prefisso (per recuperare tutti i documenti, utilizza l'operatore `matchall` in una query strutturata). In generale, dovresti utilizzare un prefisso che contenga almeno due caratteri, per evitare di ottenere un numero eccessivo di documenti.
Quando effettui una ricerca in un campo `text` o `text-array`, i termini che corrispondono al prefisso possono apparire ovunque nei contenuti del campo. Se effettui una ricerca nei campi letterali, devono corrispondere esattamente l'intera stringa di ricerca inclusi i caratteri del prefisso.
+ Parser di query semplici: utilizzare l'operatore jolly `*` (asterisco) per ricercare un prefisso, ad esempio `pre*`.
+ Parser di query strutturate: utilizzare l'operatore jolly `prefix` per ricercare un prefisso, ad esempio `prefix 'pre'`.
Ad esempio, la query seguente ricerca il prefisso *oce* nel campo del titolo e restituisce il titolo di ciascuna occorrenza:
```
q=oce*&q.options={fields:['title']}&return=title
```
Se esegui questa ricerca nei dati di esempio dei film, verranno restituiti *Ocean's Eleven* e *Ocean's Twelve*:
```
{
"status": {
"rid": "hIbIxb8oRAo6swY=",
"time-ms": 2
},
"hits": {
"found": 2,
"start": 0,
"hit": [
{
"id": "tt0240772",
"fields": {
"title": "Ocean's Eleven"
}
},
{
"id": "tt0349903",
"fields": {
"title": "Ocean's Twelve"
}
}
]
}
}
```
In una query composta, utilizza l'operatore `prefix` per ricercare i prefissi. Ad esempio, per ricercare il prefisso `title`oce* nel campo *, specifica:
```
q.parser=structured&q=(prefix field%3Dtitle 'oce')
```
Nota la codifica dell'URL. Per ulteriori informazioni, consulta [Creazione di query composte](searching-compound-queries.md).
**Nota**
Quando esegui ricerche con caratteri jolly sui campi di testo, tieni presente che Amazon CloudSearch tokenizza i campi di testo durante l'indicizzazione ed esegue lo stemming in base allo schema di analisi configurato per il campo. Normalmente, Amazon CloudSearch esegue la stessa elaborazione del testo sulla query di ricerca. tuttavia, quando ricerchi un prefisso con l'operatore jolly (\$1) o l'operatore `prefix`, lo stemming non viene eseguito per il prefisso. Ciò significa che la ricerca di un prefisso che termina con `s` non restituirà la versione al singolare del termine. Questo può accadere per qualsiasi termine che finisca con `s`, non soltanto per i plurali. Ad esempio, se ricerchi `Anders` nel campo `actor` nei dati di esempio dei film, saranno restituiti tre film. Se ricerchi `Ander*`, otterrai quei film e molti altri. Se invece ricerchi ricerchi `Anders*` non otterrai alcuna corrispondenza, in quanto il termine è archiviato nell'indice come `ander` (`anders` non appare nell'indice). Per ulteriori informazioni su come Amazon CloudSearch elabora il testo e su come può influire sulle ricerche, consulta[Elaborazione del testo in Amazon CloudSearch](text-processing.md).