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 nei tuoi dati con Amazon CloudSearch
Puoi specificare i termini o i valori che desideri ricercare con il parametro `q`. Il modo in cui specifichi i criteri di ricerca dipende dal parser di query utilizzato. Amazon CloudSearch supporta quattro parser di query:
+ `simple`—cerca in tutti `text` i `text-array` campi la stringa specificata. Questo tipo di parser di query consente di ricercare locuzioni, singoli termini e prefissi. Puoi indicare i termini come necessari o facoltativi oppure escludere le corrispondenze che contengono termini particolari. Per cercare campi particolari, puoi specificare i campi da individuare utilizzando il parametro `q.options`. Il parser di query `simple` viene utilizzato per impostazione predefinita se il parametro `q.parser` non è specificato.
+ `structured`: per ricercare campi specifici, creare query composte utilizzando gli operatori booleani e utilizzare caratteristiche avanzate come il boosting dei termini e la ricerca per prossimità.
+ `lucene`—specifica i criteri di ricerca utilizzando la sintassi del parser di query Apache Lucene. Se attualmente utilizzi la sintassi Lucene, l'utilizzo del parser di `lucene` query ti consente di migrare i tuoi servizi di ricerca su un CloudSearch dominio Amazon senza dover riscrivere completamente le query di ricerca nella sintassi di ricerca strutturata di Amazon. CloudSearch
+ `dismax`—specifica i criteri di ricerca utilizzando il sottoinsieme semplificato della sintassi del parser di query Apache Lucene definita dal parser di query. DisMax Se attualmente utilizzi la DisMax sintassi, l'utilizzo del parser di `dismax` query ti consente di migrare i tuoi servizi di ricerca su un CloudSearch dominio Amazon senza dover riscrivere completamente le query di ricerca nella sintassi di ricerca strutturata di Amazon CloudSearch .
Puoi utilizzare ulteriori parametri di ricerca per [controllare il modo in cui vengono restituiti i risultati di ricerca](controlling-search-results.md) e [includere informazioni aggiuntive](querying-for-more-info.md) come facet, evidenziazioni e suggerimenti nei tuoi risultati di ricerca.
Per informazioni su tutti i parametri di CloudSearch ricerca di Amazon, consulta la[Informazioni di riferimento sull'API di ricerca](search-api.md).
**Topics**
+ [Invio di richieste di ricerca a un dominio Amazon CloudSearch](submitting-search-requests.md)
+ [Creazione di query composte in Amazon CloudSearch](searching-compound-queries.md)
+ [text](searching-text.md)
+ [Ricerca di numeri in Amazon CloudSearch](searching-numbers.md)
+ [Ricerca di date e orari su Amazon CloudSearch](searching-dates.md)
+ [Ricerca di un intervallo di valori in Amazon CloudSearch](searching-ranges.md)
+ [location-based searching and sorting](searching-locations.md)
+ [Ricerca di dati DynamoDB con Amazon CloudSearch](searching-dynamodb-data.md)
+ [Filtraggio dei documenti corrispondenti in Amazon CloudSearch](filtering-results.md)
+ [Ottimizzazione delle prestazioni delle richieste di ricerca in Amazon CloudSearch](tuning-search.md)
# Invio di richieste di ricerca a un dominio Amazon CloudSearch
Ti consigliamo di utilizzare uno degli AWS SDKs o il AWS CLI per inviare richieste di ricerca. La SDKs e AWS CLI gestisce la firma delle richieste per te e fornisce un modo semplice per eseguire tutte le CloudSearch azioni di Amazon. Puoi anche utilizzare Search Tester nella CloudSearch console Amazon per cercare i tuoi dati, sfogliare i risultati e visualizzare la richiesta generata e le risposte JSON URLs e XML. Per ulteriori informazioni, consulta [Ricerca con il test di ricerca](getting-started-search.md#searching-console).
**Importante**
Gli endpoint di ricerca non cambiano: il documento e gli endpoint di ricerca di un dominio rimangono gli stessi per tutta la durata del dominio. Dovresti memorizzare gli endpoint nella cache invece di recuperarli prima di ciascuna richiesta di ricerca o caricamento. È probabile che interrogare il servizio di CloudSearch configurazione Amazon chiamando `aws cloudsearch describe-domains` o `DescribeDomains` prima di ogni richiesta comporti una limitazione delle richieste.
Gli indirizzi IP **cambiano**: l'indirizzo IP del tuo dominio *può* cambiare nel tempo, quindi è importante memorizzare nella cache l'endpoint come mostrato nella console e restituito dal `aws cloudsearch describe-domains` comando anziché dall'indirizzo IP. Inoltre, dovresti risolvere nuovamente il DNS dell'endpoint in un indirizzo IP con regolarità. Per ulteriori informazioni, vedere [Impostazione del TTL JVM per le ricerche dei](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/java-dg-jvm-ttl.html) nomi DNS.
Ad esempio, la richiesta seguente invia una semplice ricerca testuale per `wolverine` utilizzare AWS CLI e restituisce solo i documenti corrispondenti. IDs
```
aws cloudsearchdomain --endpoint-url http://search-movies-y6gelr4lv3jeu4rvoelunxsl2e.us-east-1.cloudsearch.amazonaws.com search --search-query wolverine --return _no_fields
{
"status": {
"rid": "/rnE+e4oCAqfEEs=",
"time-ms": 6
},
"hits": {
"found": 3,
"hit": [
{
"id": "tt1430132"
},
{
"id": "tt0458525"
},
{
"id": "tt1877832"
}
],
"start": 0
}
}
```
Per impostazione predefinita, Amazon CloudSearch restituisce la risposta in JSON. Puoi ottenere i risultati formattati in XML specificando il parametro. `format` L'impostazione del formato della risposta interessa solo le risposte alle richieste riuscite. Il formato di una risposta di errore dipende dall'origine dell'errore. Gli errori restituiti dal servizio di ricerca vengono sempre restituiti in JSON. Gli errori 5xx dovuti a timeout del server e ad altri problemi di routing delle richieste vengono restituiti in formato XML.
**Nota**
AWS SDKs restituisce i campi come array. I campi a valore singolo vengono restituiti come array con un elemento, ad esempio:
```
"fields": {
"plot": ["Katniss Everdeen reluctantly becomes the symbol of a mass rebellion against the autocratic Capitol."]
}
```
Per scopi di sviluppo e test, puoi consentire l'accesso anonimo al servizio di ricerca del tuo dominio e inviare richieste HTTP GET o POST non firmate direttamente all'endpoint di ricerca del tuo dominio. In un ambiente di produzione, limita l'accesso al tuo dominio a ruoli, gruppi o utenti IAM specifici e invia richieste firmate utilizzando AWS SDKs o AWS CLI. Per informazioni sul controllo degli accessi per Amazon CloudSearch, consulta[Configurazione di Access per Amazon CloudSearch](configuring-access.md). Per ulteriori informazioni sulla firma delle richieste, consulta [Signing AWS API Requests](https://docs.aws.amazon.com/general/latest/gr/signing_aws_api_requests.html).
Puoi utilizzare qualsiasi metodo desideri per inviare richieste HTTP direttamente all'endpoint di ricerca del tuo dominio: puoi inserire l'URL della richiesta direttamente in un browser Web, utilizzare cURL per inviare la richiesta o generare una chiamata HTTP utilizzando la tua libreria HTTP preferita. Per specificare i criteri di ricerca, specificate una stringa di query che specifica i vincoli per la ricerca e il risultato che desiderate ottenere nella risposta. La stringa di query deve essere codificata come URL. La dimensione massima di una richiesta di ricerca inviata tramite GET è di 8190 byte, inclusi il metodo HTTP, l'URI e la versione del protocollo. Puoi inviare richieste più grandi utilizzando HTTP POST; tuttavia, tieni presente che le richieste grandi e complesse richiedono più tempo per essere elaborate e hanno maggiori probabilità di scadere. Per ulteriori informazioni, consulta [Ottimizzazione delle prestazioni delle richieste di ricerca in Amazon CloudSearch](tuning-search.md).
Ad esempio, la richiesta seguente invia una query strutturata al `search-movies-rr2f34ofg56xneuemujamut52i.us-east-1.cloudsearch.amazonaws.com` dominio e ottiene il contenuto del `title` campo.
```
http://search-movies-rr2f34ofg56xneuemujamut52i.us-east-1.cloudsearch.
amazonaws.com/2013-01-01/search?q=(and+(term+field%3Dtitle+'star')
(term+field%3Dyear+1977))&q.parser=structured&return=title
```
**Importante**
I caratteri speciali nella stringa di query devono essere codificati come URL. Ad esempio, è necessario codificare l'`=`operatore in una query strutturata come:. `%3D` `(term+field%3Dtitle+'star')` Se non codifichi i caratteri speciali quando invii la richiesta di ricerca, riceverai un `InvalidQueryString` errore.
# Ricerca con il test di ricerca
Il tester di ricerca nella CloudSearch console Amazon ti consente di inviare richieste di ricerca di esempio utilizzando uno qualsiasi dei parser di query supportati: simple, structured, lucene o dismax. Per impostazione predefinita, le richieste vengono elaborate con il semplice parser di query. È possibile specificare le opzioni per il parser selezionato, filtrare e ordinare i risultati e sfogliare i facet configurati. I risultati della ricerca vengono evidenziati automaticamente nei risultati della ricerca. Per informazioni su come eseguire questa operazione, vedere[Evidenziazione dei risultati di ricerca su Amazon CloudSearch](highlighting.md). Puoi anche selezionare un suggeritore per ricevere suggerimenti man mano che inserisci i termini nel campo **di ricerca**. (È necessario configurare un suggeritore prima di poter ricevere suggerimenti. Per ulteriori informazioni, vedere[Ottenere suggerimenti per il completamento automatico in Amazon CloudSearch](getting-suggestions.md).)
*Per impostazione predefinita, i risultati vengono ordinati in base a un punteggio di pertinenza generato automaticamente, \$1score.* Per informazioni sulla personalizzazione della classificazione dei risultati, consulta. [Ordinamento dei risultati in Amazon CloudSearch](sorting-results.md)
**Per cercare nel tuo dominio**
1. Vai alla CloudSearch console Amazon a [https://console.aws.amazon.com/cloudsearch/casa](https://console.aws.amazon.com/cloudsearch/home).
1. Nel pannello di navigazione a sinistra, scegli il nome del tuo dominio per aprirne la configurazione.
1. Scegli **Esegui una ricerca di prova**.
1. Per eseguire una semplice ricerca testuale, inserisci una query di ricerca e scegli **Esegui**. Per impostazione predefinita, la ricerca viene effettuata in tutti `text` `text-array` i campi.
Per cercare campi particolari, espandi **Opzioni** e inserisci un elenco separato da virgole dei campi da cercare nel campo Campi di **ricerca**. Puoi aggiungere un peso a ciascun campo con un cursore (^) per controllare l'importanza relativa di ogni campo nei risultati della ricerca. Ad esempio, quando si calcolano i punteggi di pertinenza per ogni documento corrispondente, è possibile specificare i `title^5, description` pesi ottenuti nel `title` `description` campo cinque volte in più rispetto ai risultati ottenuti nel campo.
**Per utilizzare la sintassi delle query strutturate, selezionate **Structured** dal menu Query parser.** **Dopo aver selezionato il parser di query strutturato, inserisci la query strutturata nel campo **Cerca** e scegli Esegui.** Ad esempio, per trovare tutti i film con *protagonista* nel titolo usciti nel 2000 o prima, puoi inserire:`(and title:'star' year:{,2000])`. Per ulteriori informazioni, consulta [Creazione di query composte](searching-compound-queries.md). Per inviare Lucene o DisMax delle domande, seleziona il parser di interrogazione appropriato.
È possibile specificare opzioni aggiuntive per il parser di query selezionato per configurare l'operatore predefinito e controllare quali operatori possono essere utilizzati in una query. Per ulteriori informazioni, consulta [Parametri delle richieste di ricerca](search-api.md#search-request-parameters).
È possibile copiare e incollare l'URL della richiesta per inviare la richiesta e visualizzare la risposta da un browser Web. Le richieste possono essere inviate tramite HTTP o HTTPS.
# Creazione di query composte in Amazon CloudSearch
Puoi utilizzare il parser delle query strutturate per combinare le espressioni di corrispondenza utilizzando gli operatori booleani `and`, `or` e `not`. Per selezionare il parser delle query strutturate, includi `q.parser=structured` nella query. Gli operatori delle query strutturate vengono specificati come operatori *prefisso*. La sintassi è:
+ `(and boost=N EXPRESSION1 EXPRESSION2 ... EXPRESSIONn)`
+ `(or boost=N EXPRESSION1 EXPRESSION2 ... EXPRESSIONn)`
+ `(not boost=N EXPRESSION)`
Ad esempio, nella seguente query vengono rilevati tutti i film nel set di dati di esempio contenente *star* nel titolo e Harrison Ford o William Shatner appaiono nel campo `actors`, ma non Zachary Quinto.
```
(and title:'star' (or actors:'Harrison Ford' actors:'William Shatner')(not actors:'Zachary Quinto'))
```
Quando utilizzi gli operatori delle query strutturate, devi specificare il nome dell'operatore, le relative opzioni e l'espressione di corrispondenza a cui viene applicato l'operatore, `(OPERATOR OPTIONS EXPRESSION)`. L'espressione di corrispondenza può essere una stringa di testo semplice oppure una sottoclausola della query composta. Qualsiasi opzione deve essere specificata prima dei termini. Ad esempio `(and (not field=genres 'Sci-Fi')(or (term field=title boost=2 'star')(term field=plot 'star')))`.
Le parentesi controllano l'ordine di valutazione delle espressioni. Se è racchiusa tra parentesi, un'espressione viene valutata per prima, quindi il valore risultante viene utilizzato nella valutazione della parte rimanente della query composta.
**Importante**
I caratteri speciali nella stringa di query devono essere codificati in formato URL. Ad esempio, devi codificare l'`=`operatore in una query strutturata come`%3D`:). `(term+field%3Dtitle+'star'` Amazon CloudSearch restituisce un `InvalidQueryString` errore se i caratteri speciali non sono codificati nell'URL. Per un riferimento completo delle codifiche nel formato URL, consultare il documento [HTML URL Encoding Reference](http://www.w3schools.com/tags/ref_urlencode.asp) di W3C.
Ad esempio, la query seguente ricerca nel campo `title` la locuzione `star wars` ed esclude le corrispondenze con un valore inferiore a 2000 nel campo `year`.
```
(and (phrase field='title' 'star wars') (not (range field=year {,2000})))
```
Per inviare questa richiesta di ricerca, devi codificare la stringa della query e specificare il parser di query `structured` con il parametro `q.parser`.
```
http://search-movies-rr2f34ofg56xneuemujamut52i.us-east-1.cloudsearch.
amazonaws.com/2013-01-01/search?q=(and+(phrase+field='title'+'star wars')+(not+(range+field%3Dyear+{,2000})))&q.parser=structured
```
La sintassi delle query strutturate ti consente di combinare le ricerche rispetto a più campi. Se non specifichi un campo, la ricerca verrà effettuata in tutti i campi `text` e `text-array`. Ad esempio, la query seguente consente di ricercare in tutti i campi `text` e `text-array` il termine *star* e di escludere i documenti che contengono *Zachary Quinto* nel campo `actors`.
```
(and 'star' (not actors:'Zachary Quinto'))
```
Puoi specificare un valore `boost` (potenziamento) per aumentare l'importanza di un'espressione in una query composta rispetto alle altre. Il valore boost aumenta i punteggi dei documenti corrispondenti. Ad esempio, la seguente query aumenta le corrispondenze del termine *star* se presenti nel campo `title` anziché nel campo `description`.
```
(and (range field=year [2013,}) (or (term field=title boost=2 'star') (term field=plot 'star'))
```
I valori boost devono essere maggiori di zero.
Oltre a`and`, and `or``not`, la sintassi di ricerca CloudSearch strutturata di Amazon supporta diversi operatori specializzati:
+ `matchall`—Corrisponde a tutti i documenti del dominio. Sintassi: `matchall`.
+ `near`—Supporta interrogazioni con frasi sciatte. Il valore `distance` specifica il numero massimo di parole che possono separare le parole nella locuzione; ad esempio, `(near field='plot' distance=4 'naval mutiny demonstration')`. Utilizza l'operatore `near` per consentire il rilevamento delle corrispondenze se i termini specificati si trovano vicini, ma non sono adiacenti. Per ulteriori informazioni sulle ricerche di frasi simili, consultare [Ricerca di frasi](searching-text.md#searching-text-phrases). Sintassi: `(near field=FIELD distance=N boost=N 'STRING')`.
+ `phrase`—Cerca una frase in uno `text` o `text-array` più campi, ad esempio. `(phrase field="title" 'teenage mutant ninja')` Supporta il boosting dei documenti che corrispondono all'espressione. Per ulteriori informazioni sulle ricerche di frasi, consultare [Ricerca di frasi](searching-text.md#searching-text-phrases). Sintassi: `(phrase field=FIELD boost=N 'STRING')`.
+ `prefix`—Cerca in un campo di testo, una matrice di testo, una matrice letterale o una matrice letterale il prefisso specificato seguito da zero o più caratteri; ad esempio,. `(prefix field='title' 'wait')` Supporta il boosting dei documenti che corrispondono all'espressione. Per ulteriori informazioni sulle ricerche di prefissi, consultare [Ricerca di prefissi](searching-text.md#searching-text-prefixes). Sintassi: `(prefix field=FIELD boost=N 'STRING')`.
+ `range`—Cerca un intervallo di valori in un campo numerico, ad esempio:. `(range field=year [2000,2013])` Per ulteriori informazioni sulle ricerche di intervalli, consultare [Ricerca di un intervallo di valori](searching-ranges.md). Sintassi: `(range field=FIELD boost=N RANGE)`.
+ `term`—Cerca un singolo termine o valore in qualsiasi campo; per esempio:. `(and (term field=title 'star')(term field=year 1977))` Sintassi: `(term field=FIELD boost=N 'STRING'|VALUE)`.
Per ulteriori informazioni sulla ricerca di tipi particolari di dati, consultare le sezioni seguenti. Per ulteriori informazioni sulla sintassi di ricerca strutturata, consultare [Sintassi di ricerca strutturata](search-api.md#structured-search-syntax).
# 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).
# Ricerca di numeri in Amazon CloudSearch
Puoi utilizzare query strutturate per cercare in qualsiasi campo numerico abilitato alla ricerca un particolare valore o [intervallo di](searching-ranges.md) valori. Amazon CloudSearch supporta quattro tipi di campi numerici:`double`, `double-array``int`, e`int-array`. Per ulteriori informazioni, consulta [Configurazione dei campi dell'indice](configuring-index-fields.md).
La sintassi di base per la ricerca di un singolo valore in un campo è **FIELD**:**VALUE**. Ad esempio, `year:2010` consente di ricercare nei dati di esempio dei film i film del 2010.
Per utilizzare la sintassi dei campi devi usare il parser di query strutturate. Tieni presente che i valori numerici *non* sono racchiusi tra virgolette: le virgolette designano un valore come stringa. Per ricercare un intervallo di valori, utilizza una virgola (,) per separare i limiti superiore e inferiore e inserisci l'intervallo tra parentesi tonde o parentesi graffe. Per ulteriori informazioni, consulta [Ricerca di un intervallo di valori](searching-ranges.md).
In una query composta, utilizza la sintassi dell'operatore `term` per ricercare un singolo valore: `(term field=year 2010)`.
# Ricerca di date e orari su Amazon CloudSearch
Puoi utilizzare query strutturate per cercare in qualsiasi campo di data abilitato alla ricerca una data e ora particolari o un intervallo di [data](searching-ranges.md) e ora. Amazon CloudSearch supporta due tipi di campi data, `date` e`date-array`. Per ulteriori informazioni, consulta [Configurazione dei campi dell'indice](configuring-index-fields.md).
Le date e gli orari sono specificati in UTC (Coordinated Universal Time) secondo [IETF RFC3339](http://tools.ietf.org/html/rfc3339):. `yyyy-mm-ddTHH:mm:ss.SSSZ` In UTC, ad esempio, le 17:00 del 23 agosto 1970 sono:. `1970-08-23T17:00:00Z` Tieni presente che puoi anche specificare frazioni di secondo quando specifichi gli orari in UTC. Ad esempio, `1967-01-31T23:20:50.650Z.`.
Per cercare una data (o ora) in un campo `date` devi racchiudere la stringa della data tra virgolette singole. Ad esempio, entrambe le seguenti query ricercano i dati di tutti i film usciti alla mezzanotte del 25 dicembre 2001:
```
q.parser=structured&q=release_date:'2001-12-25T00:00:00Z'
q.parser=structured&q=(term field%3Drelease_date '2001-12-25T00:00:00Z')
```
Per eseguire la ricerca di un intero giorno, vedi [Ricerca di un intervallo di date](searching-ranges.md#searching-ranges-dates).
# Ricerca di un intervallo di valori in Amazon CloudSearch
Puoi utilizzare le query strutturate per cercare un intervallo di valori in un campo. Per specificare un intervallo di valori, utilizza una virgola (,) per separare i limiti superiore e inferiore e inserisci l'intervallo tra parentesi tonde o parentesi graffe. Una parentesi quadra, [ o ], indica che il limite è incluso nell'intervallo, una parentesi graffa, \$1 o \$1, esclude il limite.
Ad esempio, per ricercare nel set di dati di esempio dei film usciti dal 2008 al 2010 (incluso), specifica l'intervallo come `[2008,2010]`.
Per specificare un intervallo aperto, ometti il limite. Ad esempio, `year:[2002,}` individua tutti i film dal 2002 in poi e `year:{,1970]` corrisponde a tutti i film usciti nel 1970. Per omettere un limite, devi utilizzare una parentesi graffa.
In una query composta, utilizza la sintassi dell'operatore `range` per ricercare un intervallo di valori; ad esempio: `(range field=year [1967,})`.
## Ricerca di un intervallo di date
Per cercare un intervallo di date (o ore) in un campo `date`, puoi utilizzare la stessa sintassi degli intervalli con parentesi utilizzata per i valori numerici, ma devi racchiudere la stringa della data tra virgolette singole. Ad esempio, la seguente richiesta ricerca i dati di tutti i film usciti il 1° gennaio 2013 o dopo questa data:
```
q.parser=structured&q=release_date:['2013-01-01T00:00:00Z',}
```
Utilizza la sintassi seguente per cercare un determinato intervallo:
```
q.parser=structured&q=release_date:['2013-01-01T00:00:00Z','2013-01-02T23:59:59Z']
```
## Ricerca di un intervallo di posizioni
Puoi eseguire una ricerca in un riquadro di delimitazione cercando un intervallo di posizioni. Per cercare un intervallo di posizioni in un campo `latlon`, puoi utilizzare la stessa sintassi degli intervalli con parentesi utilizzata per i valori numerici, ma devi racchiudere la coppia latitudine-longitudine tra virgolette singole.
Ad esempio, se includi un campo `location` in ogni documento, potresti specificare il filtro del riquadro di delimitazione come `location:['nn.n,nn.n','nn.n,nn.n']`. Nel seguente esempio, le corrispondenze di *restaurant* sono filtrate in modo che solo le occorrenze nell'area del centro città di Paso Robles, California, siano incluse nei risultati.
```
q='restaurant'&fq=location:['35.628611,-120.694152','35.621966,-120.686706']&q.parser=structured
```
Per ulteriori informazioni, consulta [Risultati di ricerca e classificazione per posizione geografica in Amazon CloudSearch](searching-locations.md).
## Ricerca di un intervallo di testo
Puoi cercare anche un intervallo di valori in un campo di testo o letterale utilizzando la sintassi degli intervalli con parentesi. Come per le date, le stringhe di testo deve essere racchiuse tra virgolette singole. Ad esempio, la seguente richiesta cerca nei dati del film una serie di documenti IDs. Per fare riferimento all'ID di un documento, utilizza il nome di campo speciale `_id`.
```
_id:['tt1000000','tt1005000']
```
# Risultati di ricerca e classificazione per posizione geografica in Amazon CloudSearch
Se memorizzi le posizioni nei dati del documento utilizzando un `latlon` campo, puoi utilizzare la `haversin` funzione in un' CloudSearch espressione Amazon per calcolare la distanza tra due posizioni. L'archiviazione delle posizioni nei dati dei documenti ti permette anche di effettuare ricerche con facilità all'interno di determinate aree.
**Topics**
+ [Ricerca all'interno di un'area su Amazon CloudSearch](#within-area)
+ [Ordinamento dei risultati per distanza in Amazon CloudSearch](#sorting-by-distance)
## Ricerca all'interno di un'area su Amazon CloudSearch
Per associare una posizione a un documento di ricerca, puoi archiviare la latitudine e la longitudine della posizione in un campo `latlon` utilizzando la notazione in gradi decimali. I valori sono specificati come elenco separato da virgole, `lat,lon` ad esempio. `35.628611,-120.694152` L'associazione di una posizione con un documento ti consente di limitare facilmente le occorrenze di ricerca a una data area con il parametro `fq`.
**Per utilizzare un riquadro di delimitazione per limitare i risultati a una particolare area**
1. Determina la latitudine e la longitudine degli angoli superiore sinistro e inferiore destro dell'area interessata.
1. Utilizza il parametro `fq` per filtrare i documenti corrispondenti utilizzando le coordinate del riquadro di delimitazione. Ad esempio, se includi un campo `location` in ogni documento, potresti specificare il filtro del riquadro di delimitazione come `fq=location:['nn.n,nn.n','nn.n,nn.n'] `. Nel seguente esempio, le corrispondenze di *restaurant* sono filtrate in modo che solo le occorrenze nell'area del centro città di Paso Robles, California, siano incluse nei risultati.
```
q='restaurant'&fq=location:['35.628611,-120.694152','35.621966,-120.686706']&q.parser=structured
```
## Ordinamento dei risultati per distanza in Amazon CloudSearch
Puoi definire un'espressione come parte della tua richiesta di ricerca per ordinare i risultati in base alla distanza. CloudSearch Le espressioni Amazon supportano la `haversin` funzione, che calcola la distanza del grande cerchio tra due punti su una sfera utilizzando la latitudine e la longitudine di ciascun punto. Per ulteriori informazioni, vedere [Haversine formula](http://en.wikipedia.org/wiki/Haversine_formula). La distanza risultante viene restituita in chilometri.
Per calcolare la distanza tra ogni documento corrispondente e l'utente, trasmetti la posizione dell'utente alla funzione `haversin` e fai riferimento alle posizioni dei documenti archiviate in un campo `latlon`. Puoi specificare la latitudine e la longitudine dell'utente in gradi decimali e accedere alla latitudine e alla longitudine archiviate in un campo `latlon` come `FIELD.latitude` e `FIELD.longitude`. Ad esempio, `expr.distance=haversin(userlat,userlon, location.latitude,location.longitude)`.
Per usare l'espressione per ordinare i risultati di ricerca, specifica il parametro `sort`.
Ad esempio, la seguente query ricerca i ristoranti e ordina i risultati in base alla distanza rispetto all'utente.
```
q=restaurant&expr.distance=haversin(35.621966,-120.686706,location.latitude,location.longitude)&sort=distance asc
```
Tieni presente che devi specificare in modo esplicito la direzione dell'ordinamento, ossia `asc` o `desc`.
Puoi includere nei risultati di ricerca la distanza calcolata per ogni documento specificando il nome dell'espressione con il parametro `return`. Ad esempio, `return=distance`.
Inoltre, puoi usare il valore della distanza in espressioni più complesse per tenere conto di altre caratteristiche, come la rilevanza di un documento `_score`. Nel seguente esempio, un'espressione di seconda classificazione utilizza entrambi il valore di `distance` calcolato per il documento e il relativo valore `_score` di rilevanza.
```
expr.distance=haversin(38.958687,-77.343149,latitude,longitude)&expr.myrank=_score/log10(distance)&sort=myrank+desc
```
**Suggerimento**
Perché queste query di esempio funzionino, devi [configurare l'indice](configuring-index-fields.md) con un campo `latlon` e disporre dei dati `location` nei documenti:
```
{
"fields": {
"location": "40.05830,-74.40570"
}
}
```
Se il campo non esiste, quando esegui una ricerca potresti ricevere il seguente messaggio di errore:
```
Syntax error in query: field (location) does not exist.
```
Per ulteriori informazioni sull'utilizzo di espressioni per ordinare risultati di ricerca, consultare [Controllo dei risultati delle ricerche](controlling-search-results.md).
# Ricerca di dati DynamoDB con Amazon CloudSearch
È possibile specificare una tabella DynamoDB come origine durante la configurazione delle opzioni di indicizzazione o il caricamento di dati in un dominio di ricerca tramite la console. Ciò consente di configurare rapidamente un dominio di ricerca per sperimentare la ricerca dei dati archiviati nelle tabelle del database DynamoDB.
Per mantenere il tuo dominio di ricerca sincronizzato con le modifiche che vengono apportate alla tabella, puoi inviare gli aggiornamenti sia alla tabella sia al dominio di ricerca oppure puoi caricare periodicamente l'intera tabella in un nuovo dominio di ricerca.
**Topics**
+ [Configurazione di un CloudSearch dominio Amazon per la ricerca di dati DynamoDB](#searching-dynamodb-data.configuring)
+ [Caricamento di dati su Amazon CloudSearch da DynamoDB](#searching-dynamodb-data.uploading)
+ [Sincronizzazione di un dominio di ricerca con una tabella DynamoDB](#searching-dynamodb-data.sync)
## Configurazione di un CloudSearch dominio Amazon per la ricerca di dati DynamoDB
Il modo più semplice per configurare un dominio di ricerca per la ricerca di dati DynamoDB è utilizzare la console Amazon. CloudSearch La configurazione guidata della console analizza i dati della tabella e suggerisce opzioni di indicizzazione in base agli attributi della tabella. È possibile modificare la configurazione suggerita per specificare gli attributi di tabella che devono essere indicizzati.
**Nota**
Per caricare dati da DynamoDB, devi disporre dell'autorizzazione per accedere sia al servizio che alle risorse che desideri caricare. Per ulteriori informazioni, consultare l'argomento relativo all'[utilizzo di IAM per controllare l'accesso alle risorse di DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/UsingIAMWithDDB.html).
Quando si configura automaticamente un dominio di ricerca da una tabella DynamoDB, è possibile mappare un massimo di 200 attributi univoci ai campi indice. (Non è possibile configurare più di 200 campi per un dominio di ricerca, quindi è possibile caricare solo dati da tabelle DynamoDB con 200 o meno attributi.) Quando Amazon CloudSearch rileva un attributo con un numero limitato di valori distinti, il campo viene abilitato per i facet nella configurazione suggerita.
**Importante**
Quando si utilizza una tabella DynamoDB per configurare un dominio, i dati non vengono caricati automaticamente nel dominio per l'indicizzazione. È necessario caricare i dati per l'indicizzazione come fase separata dopo aver configurato il dominio.
### Configurazione di un dominio per la ricerca in DynamoDB utilizzando la console Amazon CloudSearch
Puoi utilizzare la CloudSearch console Amazon per analizzare i dati da una tabella DynamoDB per configurare un dominio di ricerca. Dalla tabella viene letto un massimo di 5 MB, indipendentemente dalle dimensioni della tabella. Per impostazione predefinita, Amazon CloudSearch legge dall'inizio della tabella. Puoi specificare un punto di partenza per iniziare a leggere da una determinata voce.
**Per configurare un dominio di ricerca utilizzando una tabella DynamoDB**
1. Apri la CloudSearch console Amazon a [https://console.aws.amazon.com/cloudsearch/casa](https://console.aws.amazon.com/cloudsearch/home).
1. Dal riquadro di navigazione a sinistra, scegli **Domini**.
1. Scegli il nome del dominio per aprirne il pannello dei dettagli.
1. Vai alla scheda **Opzioni di indicizzazione** e scegli **Configurazione** guidata.
1. Seleziona **Amazon DynamoDB**.
1. Seleziona la tabella DynamoDB che desideri analizzare.
+ Per limitare le unità di capacità di lettura che possono essere utilizzate durante la lettura dalla tabella, immettere la percentuale massima di unità utilizzabile.
+ Per iniziare a leggere da un particolare elemento, specifica una chiave **hash Start**. Se la tabella utilizza un hash e una chiave primaria di tipo intervallo, specificare sia l'attributo hash sia l'attributo intervallo per la voce.
1. Scegli **Next (Successivo)**.
1. Rivedi la configurazione suggerita. È possibile modificare questi campi e aggiungere campi aggiuntivi.
1. Al termine, scegli **Conferma**.
1. Se non hai ancora caricato dati sul tuo dominio, deseleziona la casella di controllo **Esegui l'indicizzazione ora** per uscire senza indicizzare. Se hai finito di apportare modifiche alla configurazione e sei pronto per indicizzare i tuoi dati con la nuova configurazione, assicurati che sia selezionata l'opzione **Esegui** l'indicizzazione ora. **Quando sei pronto per applicare le modifiche, scegli Fine.**
## Caricamento di dati su Amazon CloudSearch da DynamoDB
Puoi caricare dati DynamoDB su un dominio di ricerca tramite la console CloudSearch Amazon o con gli strumenti della riga di comando di CloudSearch Amazon. Quando carichi dati da una tabella DynamoDB, CloudSearch Amazon li converte in batch di documenti in modo che possano essere indicizzati. Selezionare campi di indice specifici per ciascuno degli attributi di configurazione nel proprio dominio. Per ulteriori informazioni, consulta [Configurazione di un CloudSearch dominio Amazon per la ricerca di dati DynamoDB](#searching-dynamodb-data.configuring).
Puoi caricare dati da più di una tabella DynamoDB sullo stesso dominio Amazon. CloudSearch Tuttavia, tieni presente che è possibile caricare un massimo di 200 attributi da tutte le tabelle combinate. Se una voce con la stessa chiave appare in più di una tabella caricata, l'ultimo elemento applicato sovrascrive tutte le versioni precedenti.
Quando converte i dati della tabella in batch di documenti, Amazon CloudSearch genera un documento per ogni articolo che legge dalla tabella e rappresenta ogni attributo dell'articolo come campo del documento. L'ID univoco per ogni documento o viene letto dall'attributo della voce `docid` (se esistente) oppure gli viene assegnato un valore alfanumerico in base alla chiave primaria.
Quando Amazon CloudSearch genera documenti per gli elementi della tabella:
+ I set di stringhe e i set di numeri vengono rappresentati come campi multi-valore. Se un set DynamoDB contiene più di 100 valori, solo i primi 100 valori vengono aggiunti al campo multivalore.
+ Gli attributi binari di DynamoDB vengono ignorati.
+ I nomi degli attributi vengono modificati per conformarsi alle convenzioni di CloudSearch denominazione di Amazon per i nomi dei campi:
+ Tutti i caratteri maiuscoli vengono convertiti in minuscolo.
+ Se il nome dell'attributo DynamoDB non inizia con una lettera, il nome del campo è preceduto da. `f_`
+ Tutti i caratteri diversi da a-z, 0-9, e \$1 (carattere di sottolineatura) vengono sostituiti da un carattere di sottolineatura. Se questa trasformazione determina nomi di campo duplicati, viene aggiunto un numero per rendere il nome di campo univoco. Ad esempio, i nomi di attributo `håt`, `h-t`, `hát` verrebbero mappati rispettivamente a `h_t`, `h_t1` e `h_t2`.
+ Se il nome dell'attributo DynamoDB supera i 64 caratteri, i primi 56 caratteri del nome dell'attributo vengono concatenati con l'hash di MD5 8 caratteri del nome completo dell'attributo per formare il nome del campo.
+ Se il nome di attributo è `body`, viene mappato al nome del campo `f_body`.
+ Se il nome di attributo è ` _score`, viene mappato al nome del campo ` f_ _score`.
+ Gli attributi numerici vengono mappati ai campi Amazon CloudSearch int e i valori vengono trasformati in numeri interi senza segno a 32 bit:
+ Se un attributo numerico contiene un valore decimale, viene memorizzata solo la parte intera del valore. Tutto ciò che si trova a destra del separatore decimale viene eliminato.
+ Se il valore è più grande di quello che può essere memorizzato come un numero intero senza segno, viene troncato.
+ I numeri interi negativi vengono trattati come numeri interi positivi senza firma.
### Caricamento di dati DynamoDB su un dominio tramite la console Amazon CloudSearch
Puoi utilizzare la CloudSearch console Amazon per caricare fino a 5 MB di dati da una tabella DynamoDB in un dominio di ricerca.
**Per caricare dati DynamoDB utilizzando la console**
1. Apri la CloudSearch console Amazon a [https://console.aws.amazon.com/cloudsearch/casa](https://console.aws.amazon.com/cloudsearch/home).
1. Dal riquadro di navigazione a sinistra, scegli **Domini**.
1. Scegli il nome del dominio per aprirne la configurazione.
1. Scegli **Azioni**, **Carica documenti**.
1. Seleziona **Amazon DynamoDB**.
1. Dal menu a discesa, seleziona la tabella DynamoDB che contiene i tuoi dati.
+ Per limitare le unità di capacità di lettura che possono essere utilizzate durante la lettura dalla tabella, immettere la percentuale massima di unità utilizzabili.
+ Per iniziare a leggere da un elemento particolare, specifica una chiave hash **Start**. Se la tabella utilizza un hash e una chiave primaria di tipo intervallo, specificare sia l'attributo hash sia l'attributo intervallo per la voce.
1. **Dopo aver specificato le opzioni della tabella, scegliete Avanti.**
1. Controlla gli elementi che verranno caricati. Puoi anche salvare il batch di documenti generato scegliendo **Scarica il batch di documenti generato**. Quindi scegli **Carica documenti**.
## Sincronizzazione di un dominio di ricerca con una tabella DynamoDB
Per mantenere il dominio di ricerca sincronizzato con gli aggiornamenti della tabella DynamoDB, puoi monitorare e applicare gli aggiornamenti al tuo dominio a livello di codice oppure creare periodicamente un nuovo dominio e caricare nuovamente l'intera tabella. Se la quantità di dati è significativa, consigliabile tenere traccia degli aggiornamenti e applicarli in modo programmatico.
### Sincronizzazione programmatica degli aggiornamenti
Per sincronizzare le modifiche e le aggiunte alla tabella DynamoDB, puoi creare una tabella di aggiornamento separata per tenere traccia delle modifiche alla tabella che stai cercando e caricare periodicamente il contenuto della tabella di aggiornamento nel dominio di ricerca corrispondente.
Per rimuovere i documenti dal dominio di ricerca, è necessario generare e caricare i batch di documenti che contengono un'operazione di eliminazione per ogni documento eliminato. Un'opzione consiste nell'utilizzare una tabella DynamoDB separata per tenere traccia degli elementi eliminati, elaborare periodicamente la tabella per generare un batch di operazioni di eliminazione e caricare il batch nel dominio di ricerca.
Per essere scuri di non perdere le modifiche apportate durante il caricamento iniziale dei dati, è necessario iniziare a raccogliere il rilevamento delle modifiche prima di caricare i dati iniziali. Sebbene tu possa aggiornare alcuni CloudSearch documenti Amazon con dati identici, ti assicuri che nessuna modifica vada persa e che il tuo dominio di ricerca contenga una up-to-date versione di ogni documento.
La frequenza di sincronizzazione degli aggiornamenti dipende dal volume delle modifiche e dalla tolleranza della latenza di aggiornamento. Un approccio consiste nell'accumulare le modifiche per un periodo di tempo fisso al termine del quale si caricano le modifiche e si eliminano le tabelle di rilevamento del periodo.
Ad esempio, per sincronizzare le modifiche e le aggiunte una volta al giorno, all'inizio di ogni giorno puoi creare una tabella denominata aggiornamenti\$1AAAA\$1MM\$1GG per raccogliere gli aggiornamenti giornalieri. Al termine della giornata, puoi caricare la tabella aggiornamenti\$1AAAA\$1MM\$1GG nel tuo dominio di ricerca. Una volta completato il caricamento, puoi eliminare la tabella di aggiornamento e crearne una nuova per il giorno successivo.
### Passaggio a un nuovo dominio di ricerca
Se non desideri tenere traccia dei singoli aggiornamenti e applicarli alla tabella, puoi caricare periodicamente l'intera tabella in un nuovo dominio di ricerca e quindi passare il traffico di query al nuovo dominio.
**Per passare a un nuovo dominio di ricerca**
1. Creare un nuovo dominio di ricerca e copiare la configurazione dal dominio esistente.
1. Carica l'intera tabella DynamoDB nel nuovo dominio. Per ulteriori informazioni, consulta [Caricamento di dati su Amazon CloudSearch da DynamoDB](#searching-dynamodb-data.uploading).
1. Quando il nuovo dominio è attivo, aggiornare la voce DNS che indirizza il traffico di query nel dominio di ricerca precedente in modo che punti al nuovo dominio. Ad esempio, se utilizzi [Amazon Route 53](https://aws.amazon.com/route53/), puoi semplicemente aggiornare il recordset con il tuo nuovo endpoint del servizio di ricerca.
1. Eliminare il dominio precedente.
# Filtraggio dei documenti corrispondenti in Amazon CloudSearch
Puoi utilizzare il parametro `fq` per filtrare i documenti che corrispondono ai criteri di ricerca specificati con il parametro `q` senza compromettere i punteggi di pertinenza dei documenti inclusi nei risultati di ricerca. L'applicazione di un filtro consente semplicemente di controllare i documenti corrispondenti che vengono inclusi nei risultati, senza influenzare il modo in cui vengono valutati e ordinati.
Il parametro `fq` supporta la sintassi delle query strutturate descritta in [Informazioni di riferimento sull'API di ricerca](search-api.md).
Ad esempio, potresti aggiungere un campo `available` ai tuoi documenti per indicare se un articolo è in magazzino o meno e applicare un filtro a tale campo per limitare i risultati agli articoli disponibili in magazzino:
```
search?q=star+wars&fq=available:'true'&return=title
```
# Ottimizzazione delle prestazioni delle richieste di ricerca in Amazon CloudSearch
Durante l'elaborazione, le richieste di ricerca possono richiedere un uso intensivo delle risorse, influendo sulle prestazioni e i costi di esecuzione del dominio di ricerca. In generale, le ricerche che restituiscono un grande volume di occorrenze e le query strutturate complesse richiedono un uso ancora più massiccio delle risorse rispetto alle query di testo semplici, che restituiscono una piccola percentuale dei documenti presenti nel dominio di ricerca.
Qualora si verificassero rallentamenti dei tempi di risposta, frequenti errori interni del server (tipicamente 507 o 509) o un aumento del consumo di ore di istanze nel dominio di ricerca senza un sostanziale aumento del volume di dati ricercati, puoi ottimizzare le richieste di ricerca per contribuire a ridurre i costi di elaborazione. Questa sezione esamina cosa cercare e le fasi da seguire per ottimizzare le richieste di ricerca.
## Analisi della latenza delle query
Prima di ottimizzare le tue richieste, devi analizzare le prestazioni correnti delle ricerche. Registra le tue richieste di ricerca e i tempi di risposta, in modo da poter capire quali richieste richiedono più tempo per l'elaborazione. Le ricerche lente possono influire in modo sproporzionato sulle prestazioni complessive vincolando le risorse del tuo dominio di ricerca. L'ottimizzazione delle richieste di ricerca più lente consente di accelerare *tutte* le tue ricerche.
**Topics**
+ [Riduzione del numero di occorrenze](#tuning-search-numdocs)
+ [Semplificazione delle query strutturate](#simplifying-structured-queries)
### Riduzione del numero di occorrenze
La latenza delle query è direttamente proporzionale al numero di documenti corrispondenti. Le ricerche che restituiscono la maggior parte dei documenti solitamente sono le più lente.
Eliminando i due tipi di ricerca che solitamente restituiscono un elevato numero di documenti corrispondenti, puoi migliorare notevolmente le prestazioni complessive:
+ Le query che restituiscono ogni documento nel corpus (`matchall`). Sebbene questo tipo di ricerca sia un modo utile per elencare tutti i documenti nel tuo dominio, si tratta di una query a uso intensivo delle risorse. Se disponi di molti documenti, non solo si potrebbe verificare il time out delle altre richieste, ma potrebbe verificarsi anche per la richiesta in corso.
+ Le ricerche di prefissi (caratteri jolly) solo con uno o due caratteri specificati. Se utilizzi questo tipo di ricerca per offrire risultati istantanei durante la digitazione, attendi finché l'utente non ha digitato almeno due caratteri prima di iniziare a inviare le richieste e visualizzare le corrispondenze possibili.
Per ridurre il numero di documenti che corrispondono alle tue richieste, puoi anche procedere nel modo seguente:
+ Elimina le parole irrilevanti dal tuo corpus affinché non vengano utilizzate per la ricerca. Il modo più semplice per farlo è aggiungerle al dizionario di elenco delle stopword per gli schemi di analisi che stai utilizzando. In alternativa, puoi pre-elaborare i dati per rimuovere le parole irrilevanti, azione che ha anche il vantaggio di ridurre le dimensioni dell'indice e di conseguenza i costi.
+ Filtra in modo esplicito i risultati in base al valore di un campo particolare utilizzando il parametro `fq`.
Se le richieste restituiscono ancora molti documenti, puoi ridurre la latenza riducendo al minimo l'elaborazione del set di risultati:
+ Riduci le informazioni sui facet della richiesta. La generazione dei numeri di facet si aggiunge al tempo necessario a elaborare la richiesta e aumenta la probabilità di timeout di altre richieste. Se richiedi le informazioni sui facet, tieni presente che più facet specifichi e maggiore sarà il tempo di elaborazione della richiesta.
+ Evita di utilizzare espressioni personalizzate per l'ordinamento. L'elaborazione aggiuntiva necessaria per ordinare i risultati aumenta la probabilità di time out delle richieste. Se devi personalizzare la modalità di ordinamento dei risultati, solitamente risulta più veloce utilizzare una campo che non un'espressione.
Tieni presente che la restituzione di una grande quantità di dati nei risultati di ricerca può aumentare i tempi di trasporto e influire sulla latenza delle query. Riduci al minimo il numero dei campi di restituzione che utilizzi per migliorare le prestazioni e ridurre le dimensioni dell'indice.
### Semplificazione delle query strutturate
Maggiore è il numero di clausole nei criteri delle query e maggiore sarà il tempo richiesto per la loro elaborazione.
Se rilevi query strutturate complesse che non funzionano adeguatamente, devi individuare un modo per ridurre il numero delle clausole. In alcuni casi, potresti semplicemente essere in grado di impostare un limite o riformulare la query. In altri casi, potresti dover modificare la configurazione del tuo dominio per tenere conto delle query più semplici.