Gestione dei risultati di ricerca

Go Java PHP Python

Quando una chiamata di query viene completata normalmente, restituisce il risultato come oggetto SearchResults. L'oggetto dei risultati indica il numero di documenti corrispondenti trovati nell'indice e il numero di documenti corrispondenti restituiti. Include anche un elenco di ScoredDocuments corrispondenti. L'elenco di solito contiene una parte di tutti i documenti corrispondenti trovati, poiché la ricerca restituisce un numero limitato di documenti ogni volta che viene chiamata. Utilizzando un offset o un cursore, puoi recuperare tutti i documenti corrispondenti, un sottoinsieme alla volta.

Risultati

def query_results(index, query_string):
    result = index.search(query_string)
    total_matches = result.number_found
    list_of_docs = result.results
    number_of_docs_returned = len(list_of_docs)
    return total_matches, list_of_docs, number_of_docs_returned

A seconda del valore dell'limit opzione di query, il numero di documenti corrispondenti restituiti nel risultato potrebbe essere inferiore al numero trovato. Tieni presente che il numero trovato sarà una stima se l'accuratezza del numero trovato è inferiore al numero trovato. Indipendentemente da come configuri le opzioni di ricerca, una chiamata search() troverà non più di 10.000 documenti corrispondenti.

Se sono stati trovati più documenti di quelli restituiti e vuoi recuperarli tutti, devi ripetere la ricerca utilizzando un offset o un cursore, come spiegato di seguito.

Nota: il codice di chiamata deve essere pronto a gestire le eccezioni che potrebbero essere generate se la query non è valida o se si sono verificati problemi durante l'elaborazione.

Documenti con punteggio

I risultati di ricerca includeranno un elenco di [ScoredDocuments]/appengine/docs/standard/services/search/python/scoreddocumentclass) che corrispondono alla query. Puoi scorrere l'elenco per elaborare ogni documento a turno:

for scored_document in results:
        print(scored_document)

Per impostazione predefinita, un documento con punteggio contiene tutti i campi del documento originale che è stato indicizzato. Se le opzioni di query hanno specificato returned_fields , solo questi campi vengono visualizzati nella proprietà campi del documento. Se hai creato campi calcolati specificando returned_expressions o snippeted_fields , questi verranno visualizzati separatamente nella proprietà espressioni del documento.

Utilizzo degli offset

Se la ricerca trova più documenti di quelli che puoi restituire contemporaneamente, utilizza un offset per indicizzare l'elenco dei documenti corrispondenti. Ad esempio, il limite predefinito della query è di 20 documenti. Dopo aver eseguito una ricerca la prima volta (con offset 0) e recuperato i primi 20 documenti, recupera i 20 documenti successivi impostando l'offset su 20 ed eseguendo di nuovo la stessa ricerca. Continua a ripetere la ricerca, incrementando l'offset ogni volta del numero di documenti restituiti:

def query_offset(index, query_string):
    offset = 0

    while True:
        # Build the query using the current offset.
        options = search.QueryOptions(offset=offset)
        query = search.Query(query_string=query_string, options=options)

        # Get the results
        results = index.search(query)

        number_retrieved = len(results.results)
        if number_retrieved == 0:
            break

        # Add the number of documents found to the offset, so that the next
        # iteration will grab the next page of documents.
        offset += number_retrieved

        # Process the matched documents
        for document in results:
            print(document)

Gli offset possono essere inefficienti quando si itera su un set di risultati molto grande.

Utilizzo dei cursori

Puoi anche utilizzare i cursori per recuperare un intervallo secondario di risultati. I cursori sono utili quando intendi presentare i risultati di ricerca in pagine consecutive e vuoi assicurarti di non saltare alcun documento nel caso in cui un indice possa essere modificato tra le query. I cursori sono anche più efficienti quando si itera su un set di risultati molto grande.

Per utilizzare i cursori, devi creare un cursore iniziale e includerlo nelle opzioni di query. Esistono due tipi di cursori: per query e per risultato. Un cursore di query fa sì che un cursore separato venga associato all'oggetto risultati restituito dalla chiamata di ricerca. Un cursore per risultato fa sì che un cursore venga associato a ogni documento con punteggio nei risultati.

Utilizzo di un cursore di query

Per impostazione predefinita, un cursore appena creato è un cursore di query. Questo cursore contiene la posizione dell'ultimo documento restituito nei risultati della ricerca. Viene aggiornato a ogni ricerca. Per enumerare tutti i documenti corrispondenti in un indice, esegui la stessa ricerca finché il risultato non restituisce un cursore nullo:

def query_cursor(index, query_string):
    cursor = search.Cursor()

    while cursor:
        # Build the query using the cursor.
        options = search.QueryOptions(cursor=cursor)
        query = search.Query(query_string=query_string, options=options)

        # Get the results and the next cursor
        results = index.search(query)
        cursor = results.cursor

        for document in results:
            print(document)

Utilizzo di un cursore per risultato

Per creare cursori per risultato, devi impostare la proprietà del cursore per_result su true quando crei il cursore iniziale. Quando la ricerca restituisce risultati, a ogni documento è associato un cursore. Puoi utilizzare il cursore per specificare una nuova ricerca con risultati che iniziano con un documento specifico. Tieni presente che quando passi un cursore per risultato alla ricerca, non ci sarà alcuncursore di queryy associato al risultato stesso; result.getCursor() restituirà null, quindi non puoi utilizzarlo per verificare se hai recuperato tutte le corrispondenze.

def query_per_document_cursor(index, query_string):
    cursor = search.Cursor(per_result=True)

    # Build the query using the cursor.
    options = search.QueryOptions(cursor=cursor)
    query = search.Query(query_string=query_string, options=options)

    # Get the results.
    results = index.search(query)

    document_cursor = None
    for document in results:
        # discover some document of interest and grab its cursor, for this
        # sample we'll just use the first document.
        document_cursor = document.cursor
        break

    # Start the next search from the document of interest.
    if document_cursor is None:
        return

    options = search.QueryOptions(cursor=document_cursor)
    query = search.Query(query_string=query_string, options=options)
    results = index.search(query)

    for document in results:
        print(document)

Salvataggio e ripristino dei cursori

Un cursore può essere serializzato come stringa sicura per il web, salvato e poi ripristinato per un utilizzo successivo:

def saving_and_restoring_cursor(cursor):
    # Convert the cursor to a web-safe string.
    cursor_string = cursor.web_safe_string
    # Restore the cursor from a web-safe string.
    cursor = search.Cursor(web_safe_string=cursor_string)