Cerca documenti in un datastore

La pipeline di importazione gestita importa i documenti dai datastore in Agent Retrieval in Oggetti di dati e Raccolte in cui puoi eseguire ricerche con query di testo e gestisce automaticamente l'analisi, la segmentazione, l'incorporamento e l'indicizzazione per te.

Formati di documento supportati

La tabella seguente elenca i formati file e le estensioni dei file dei documenti supportati.

Tipo di documento File extension (Estensione del file)
PDF .pdf
Testo normale .txt
Microsoft Word .docx
Microsoft Excel .xlsx
Microsoft Excel con macro .xlsm (script e macro vengono ignorati)
Microsoft PowerPoint .pptx

Prerequisiti

Prima di iniziare, devi avere:

Esempi

Gli esempi in questa pagina si basano sui seguenti file di esempio.

curl

PROJECT=acme-prod
LOCATION=us-east4
BASE=https://vectorsearch.googleapis.com/v1alpha
INGEST=${BASE}/projects/${PROJECT}/locations/${LOCATION}
AUTH="Authorization: Bearer $(gcloud auth print-access-token)"

Python

import time
import google.auth
from google.auth.transport.requests import AuthorizedSession

PROJECT = "acme-prod"          # Replace with your project ID
LOCATION = "us-east4"          # Replace with your region

credentials, _ = google.auth.default(
    scopes=["https://www.googleapis.com/auth/cloud-platform"]
)
session = AuthorizedSession(credentials)

BASE = "https://vectorsearch.googleapis.com/v1alpha"
INGEST = BASE + "/projects/" + PROJECT + "/locations/" + LOCATION

def wait(operation, poll_seconds=10):
    """Poll a long-running operation until it finishes, then return it."""
    name = operation["name"]
    while True:
        op = session.get(BASE + "/" + name).json()
        if op.get("done"):
            if "error" in op:
                raise RuntimeError(op["error"])
            return op
        meta = op.get("metadata", {})
        print("in progress:", meta)
        time.sleep(poll_seconds)

La pipeline di importazione gestita

La pipeline di importazione gestita importa i documenti dal datastore in Agent Retrieval e svolge la maggior parte del lavoro di configurazione degli oggetti di dati e delle raccolte per te.

Tutto quello che devi fare è:

  1. Prepara i file.

  2. Crea un datastore.

  3. Importa i file.

  4. Cerca i tuoi file con query di testo.

1. Prepara i file

Crea un bucket e aggiungi i file in cui vuoi eseguire la ricerca. Non è necessario creare un manifest.

Importazione gestita dei documenti:

  • Salta i documenti di dimensioni superiori a 200 MB.

  • Ignora le macro e gli script nei documenti Microsoft Excel con macro abilitate (.xlsm).

  • Importa solo 100.000 documenti alla volta.

Puoi anche preparare file JSONL che definiscono i metadati per i tuoi file. Per saperne di più, consulta Aggiungi metadati ai file.

2. Crea un datastore

Dopo aver eseguito la gestione temporanea dei file in cui vuoi eseguire la ricerca, devi creare un datastore. Il datastore fornisce l'origine per la pipeline di importazione gestita e la configurazione che specifica come vengono importati i file.

L'importazione gestita è disponibile solo per i datastore situati nella regione us-east4 o europe-west4.

Per creare un datastore, invia una richiesta POST all'API dataStores e fornisci il seguente parametro:

  • data_store_id: l'ID del datastore in fase di creazione. Deve iniziare con una lettera minuscola, terminare con una lettera minuscola o una cifra, contenere solo lettere minuscole, cifre e trattini e avere una lunghezza compresa tra 1 e 63 caratteri.

Il payload JSON contiene le impostazioni di configurazione JSON che l'importazione gestita utilizza per creare il datastore ed elaborare i documenti di cui hai eseguito lo stage.

Il payload JSON deve includere la proprietà di primo livello document_type. Specifica i tipi di file da importare dal datastore. I valori validi sono:

  • UNSTRUCTURED: il datastore contiene documenti. Consulta Formati dei documenti supportati per un elenco dei formati supportati.

  • VIDEO: il datastore contiene video.

Le seguenti proprietà sono facoltative:

  • display_name: (STRING) Il nome visualizzato del datastore. La dimensione massima è 1024 byte. Il valore predefinito è una stringa vuota.

  • description: (STRING) La descrizione del datastore. La dimensione massima è 1024 byte. Il valore predefinito è una stringa vuota.

  • labels: (array STRING) un array di coppie chiave-valore. Per saperne di più, consulta Organizza le risorse utilizzando le etichette. Il valore predefinito è un array vuoto.

  • processing_config (OBJECT): la configurazione del modo in cui l'importazione gestita elabora i dati nel datastore. Può essere aggiornato con una richiesta PATCH. Per le impostazioni predefinite se omesse, consulta Impostazioni facoltative per i datastore di documenti.

  • document_metadata_schema (OBJECT): lo schema dei metadati associati ai documenti nel datastore. Per saperne di più, consulta Aggiungi uno schema dei metadati. Il valore predefinito è un oggetto vuoto (nessuno schema di metadati).

Impostazioni facoltative per i file di documenti

Per i datastore di documenti sono disponibili le seguenti impostazioni facoltative:

  • processing_config.unstructured_processing_config.segmentation_config: (OBJECT) La configurazione di importazione per la segmentazione del documento (le ricerche vengono eseguite per segmento, non per documento). Per saperne di più, consulta Segmentazione dei documenti. Un oggetto vuoto comporta il rifiuto della richiesta con lo stato INVALID_ARGUMENT. Se fornito, deve includere uno dei seguenti elementi:
    • page_segmentation_config: (OBJECT) Questo oggetto non ha proprietà.
    • chunk_segmentation_config: (OBJECT) Ha le seguenti proprietà:
    • chunk_size: (INTEGER) Il numero massimo di token in un segmento. Il valore minimo è 300 e il valore massimo è 500. Il valore predefinito è 500.
    • include_ancestor_headings: (BOOL) Antepone una catena di intestazioni di sezione a ogni chunk per il contesto. Il valore predefinito è false.
  • processing_config.unstructured_processing_config.parsing_config: (OBJECT) La configurazione di importazione per l'analisi del documento. Per saperne di più, consulta Analisi dei documenti. Un oggetto vuoto comporta il rifiuto della richiesta con lo stato INVALID_ARGUMENT. Se fornito, deve includere uno dei seguenti elementi:
    • layout_parsing_config: (OBJECT) Verrà utilizzata l'analisi del layout. Questo oggetto non ha proprietà.
    • digital_parsing_config: (OBJECT) Verrà utilizzata l'analisi digitale. Questo oggetto non ha proprietà.

  • processing_config.unstructured_processing_config.embedding_config.mode: (STRING) La modalità di embedding da utilizzare. ad es.:

    • TEXT: viene incorporato solo il testo estratto. Le immagini vengono ignorate. Il valore predefinito è TEXT.

Puoi anche aggiungere metadati al datastore. Per saperne di più, consulta Aggiungi metadati per i file.

Esempi

I seguenti esempi mostrano come creare un datastore di documenti.

curl

  curl -X POST -H "${AUTH}" -H "Content-Type: application/json" \
  "${INGEST}/dataStores?data_store_id=acme-financials" \
  -d '{
    "display_name": "Acme financial reports",
    "document_type": "UNSTRUCTURED",
    "processing_config": {
      "unstructured_processing_config": {
        "segmentation_config": {
          "chunk_segmentation_config": {
            "chunk_size": 300,
            "include_ancestor_headings": true
          }
        },
        "parsing_config": {
          "layout_parsing_config": {}
        }
      }
    }
  }'

Python

  op = session.post(
    INGEST + "/dataStores",
    params={"data_store_id": "acme-financials"},
    json={
        "display_name": "Acme financial reports",
        "document_type": "UNSTRUCTURED",
        "processing_config": {
            "unstructured_processing_config": {
                "segmentation_config": {
                    "chunk_segmentation_config": {
                        "chunk_size": 300,
                        "include_ancestor_headings": True,
                    }
                },
                "parsing_config": {"layout_parsing_config": {}},
            }
        },
    },
).json()

wait(op)

Esempio di risposta

  "name": "projects/acme-prod/locations/us-east4/dataStores/acme-financials",
  "documentType": "UNSTRUCTURED",
  "state": "ACTIVE",
  "collectionName": "projects/acme-prod/locations/us-east4/collections/google-acme-financials"
}

Aggiungi metadati ai file

Puoi definire le proprietà dei metadati per i file che vuoi importare con l'importazione gestita. Queste proprietà possono essere recuperate dagli oggetti dati corrispondenti creati dalla pipeline e sono utili per filtrare i risultati di ricerca.

Per definire i metadati:

  1. Crea un file JSONL. L'estensione deve essere json o jsonl.

  2. Aggiungi un oggetto JSON a una nuova riga per ogni file che vuoi importare e includi le seguenti proprietà:

    • name: il nome del file nel datastore. L'ultimo segmento del nome viene utilizzato come ID per l'oggetto dati creato per il file.

    • content.gcsUri: l'URI del documento in Cloud Storage.

    • metadata.value: i metadati del documento. Le proprietà dei metadati sono definite in uno schema che specifichi quando crei il datastore. Per saperne di più, consulta Aggiungi uno schema dei metadati.

L'esempio seguente mostra un JSONL di metadati con le proprietà dei metadati category, year, tags e issuer.

{"name":"projects/acme-prod/locations/us-east4/dataStores/acme-financials/documents/q3-earnings","content":{"gcsUri":"gs://acme-docs/reports/2025-q3-earnings.pdf"},"metadata":{"value":{"category":"earnings","year":2025,"tags":["revenue"],"issuer":{"country":"US"}}}}
{"name":"projects/acme-prod/locations/us-east4/dataStores/acme-financials/documents/covenants","content":{"gcsUri":"gs://acme-docs/reports/covenant-summary.docx"},"metadata":{"value":{"category":"covenant","year":2024,"tags":["credit","debt"]}}}

Le proprietà devono corrispondere a uno schema che fornisci quando crei il datastore.

Utilizzerai i file JSONL che hai creato come URI di input quando importi i file.

Aggiungi uno schema di metadati

Puoi fornire uno schema dei metadati nella proprietà document_metadata_schema di primo livello nella configurazione JSON del datastore. In questo modo viene definito un contratto per i metadati che puoi associare ai tuoi documenti, che possono essere recuperati per documento o utilizzati per filtrare i risultati di ricerca.

Le proprietà dei metadati devono corrispondere allo schema fornito al momento della creazione del datastore. Lo schema segue da vicino la bozza 7 dello schema JSON. Sono supportati i seguenti tipi di dati:

  • string
  • number
  • integer
  • boolean
  • object (incluse le proprietà)
  • array

I nomi delle proprietà possono utilizzare solo lettere, cifre, trattini bassi (_) e trattini (-) e non devono iniziare con google (qualsiasi combinazione di maiuscole e minuscole). Il prefisso è riservato ai campi scritti dal servizio.

Puoi aggiungere proprietà in un secondo momento con una richiesta PATCH. Le proprietà nello schema non possono essere rimosse o avere il tipo di dati modificato. Per saperne di più, consulta Aggiorna una configurazione di elaborazione.

L'esempio seguente definisce uno schema di metadati con le proprietà dei metadati category, year, tags e issuer.

"document_metadata_schema": {
  "schema": {
    "type": "object",
    "properties": {
      "category": {"type": "string"},
      "year":     {"type": "integer"},
      "tags":     {"type": "array", "items": {"type": "string"}},
      "issuer":   {"type": "object", "properties": {"country": {"type": "string"}}}
    }
  }
}

Aggiorna una configurazione di elaborazione

Dopo aver creato il datastore, puoi aggiornare la configurazione di elaborazione (processing_config) con una richiesta PATCH.

È possibile aggiornare le seguenti proprietà:

  • display_name
  • description
  • labels
  • document_metadata_schema (è possibile aggiungere solo proprietà aggiuntive)

Le proprietà che vengono aggiornate devono essere incluse nel parametro di query update_mask.

Gli esempi seguenti mostrano come aggiornare le proprietà display_name e document_metadata_schema di una configurazione di elaborazione.

curl

curl -X PATCH -H "${AUTH}" -H "Content-Type: application/json" \
"${INGEST}/dataStores/acme-financials?update_mask=display_name,document_metadata_schema" \
-d '{"display_name": "Acme reports",
"document_metadata_schema": {"schema": {"type": "object", "properties": {
"category": {"type": "string"}, "year": {"type": "integer"},
"region": {"type": "string"}}}}}'

Segmentazione dei documenti

Quando crei il datastore, puoi specificare in che modo la pipeline di importazione gestita deve tentare di segmentare i documenti:

  • Segmentazione delle pagine (processing_config.segmentation_config.page_segmentation_config): l'importazione gestita tenta di segmentare i documenti per pagina.

  • Segmentazione dei chunk (processing_config.segmentation_config.chunk_segmentation_config): l'importazione gestita segmenta i documenti in chunk separati.

Se non specificato, il valore predefinito è la segmentazione in blocchi. Se vengono specificati entrambi, la richiesta non va a buon fine.

Segmentazione della pagina

La specifica della segmentazione delle pagine (processing_config.segmentation_config.page_segmentation_config) indica alla pipeline di importazione gestita di segmentare i documenti per pagina o intervallo di pagine. Se un documento non contiene informazioni sulla pagina, ad esempio un file di testo, viene segmentato in pagine di dimensioni fino a 2,5 MB.

La segmentazione delle pagine è ottimizzata per il recupero dei documenti, ad esempio per le applicazioni che restituiscono PDF o documenti Word con ogni risultato di ricerca. Per saperne di più, consulta Suddividi i documenti per RAG.

Segmentazione dei blocchi

La specifica della segmentazione dei blocchi (processing_config.segmentation_config.chunk_segmentation_config) indica alla pipeline di importazione gestita di segmentare i documenti in blocchi di un massimo di processing_config.segmentation_config.chunk_segmentation_config.chunk_size token. Per impostazione predefinita, la dimensione del chunk è di 500 token (la dimensione massima del chunk). La dimensione minima del chunk è 300.

Blocchi di grandi dimensioni:

  • Portare più contesto.
  • Genera meno segmenti.
  • Possono trattare diversi argomenti che non corrispondono a una query, nascondendo potenzialmente informazioni pertinenti.

Piccoli blocchi:

  • Contengono parti di testo più strette.
  • È più probabile che contengano solo le informazioni corrispondenti a una query.
  • Contengono meno contesto, con la potenziale suddivisione delle informazioni pertinenti in più segmenti.

Per la maggior parte dei contenuti nel formato lungo, una dimensione dei chunk di 500 token funziona bene. I chunk di dimensioni più piccole sono più adatti per contenuti brevi e basati su fatti o per recuperare passaggi di testo compatti e precisi.

URI di input

La proprietà JSON gcs_source.input_uris è un array di stringhe che specifica gli input per una richiesta di importazione gestita, ad esempio i file da importare dal datastore o gli elementi da eliminare dal recupero dell'agente.

Se gcs_source.source_format non è specificato o è impostato su SOURCE_FORMAT_UNSPECIFIED (valore predefinito), gli URI di input possono essere:

  • Uno o più URI specifici.
  • Uno o più pattern con caratteri jolly.
  • Uno o più file di testo.
    • Gli ID documento vengono definiti uno per riga. Le righe vuote vengono ignorate e gli spazi vuoti vengono rimossi da ogni riga.

Se gcs_source.source_format è impostato su SOURCE_FORMAT_DOCUMENT_JSON, gli URI di input vengono definiti in formato JSONL. Per maggiori dettagli, consulta Aggiungi metadati ai documenti.

Caratteri jolly

Pattern Corrisponde a
gs://acme/files/hello_world.xyz Il file specificato.
gs://acme/files/* Ogni file corrispondente al document_type specificato direttamente in gs://acme/files/.
gs://acme/files/*.xyz Ogni file con estensione .xyz.

I caratteri jolly non sono ricorsivi. Ad esempio, se specifichi gs://acme/files/*, i file in gs://acme/files/2025/ non verranno importati. Il carattere jolly ** viene interpretato allo stesso modo di *. Per aggirare il problema, puoi semplificare la gerarchia o passare un pattern per livello.

Se un pattern non corrisponde, la richiesta non va a buon fine. Ad esempio, se passi quattro URI e uno contiene un errore di battitura, l'importazione non continua con gli altri tre URI. Assicurati che ogni URI sia corretto prima di effettuare una richiesta di importazione.

3. Importa i tuoi file

La fase successiva della pipeline consiste nel chiamare importDocuments con gli URI dei file nel datastore di cui vuoi eseguire l'importazione.

I seguenti esempi mostrano come importare i documenti.

curl

curl -X POST -H "${AUTH}" -H "Content-Type: application/json" \
  "${INGEST}/dataStores/acme-financials:importDocuments" \
  -d '{
    "gcs_source": {
      "input_uris": ["gs://acme-docs/reports/*"]
    },
    "import_output_config": {
      "error_gcs_prefix": "gs://acme-docs/import-errors/"
    }
  }'

Python

op = session.post(
    INGEST + "/dataStores/acme-financials:importDocuments",
    json={
        "gcs_source": {"input_uris": ["gs://acme-docs/reports/*"]},
        "import_output_config": {
            "error_gcs_prefix": "gs://acme-docs/import-errors/"
        },
    },
).json()

result = wait(op)
print(result["metadata"]["successCount"], "imported")
# failureCount is not set on import metadata; check error files instead.

Se vuoi, puoi importarle con i metadati. Per saperne di più, consulta Aggiungi metadati ai documenti.

Gli esempi seguenti mostrano come importare i file JSONL dei metadati.

curl

gcloud storage cp docs.jsonl gs://acme-docs/manifests/docs.jsonl
curl -X POST -H "${AUTH}" -H "Content-Type: application/json" \
  "${INGEST}/dataStores/acme-financials:importDocuments" \
  -d '{
    "gcs_source": {
      "input_uris": ["gs://acme-docs/manifests/docs.jsonl"],
      "source_format": "SOURCE_FORMAT_DOCUMENT_JSON"
    },
    "import_output_config": {
      "error_gcs_prefix": "gs://acme-docs/import-errors-json/"
    }
  }'

Python

op = session.post(
    INGEST + "/dataStores/acme-financials:importDocuments",
    json={
        "gcs_source": {
            "input_uris": ["gs://acme-docs/manifests/docs.jsonl"],
            "source_format": "SOURCE_FORMAT_DOCUMENT_JSON",
        },
        "import_output_config": {
            "error_gcs_prefix": "gs://acme-docs/import-errors-json/"
        },
    },
).json()

result = wait(op)

La raccolta di importazione gestita crea

Quando crei il datastore, l'importazione gestita crea una raccolta in Agent Retrieval utilizzando le API Agent Retrieval pubbliche e può essere utilizzata come qualsiasi altra raccolta di Agent Retrieval. La raccolta è vuota finché l'operazione di importazione non viene completata.

Per informazioni su come eseguire query sulla raccolta, consulta Esegui ricerche nei documenti.

L'esempio seguente mostra come ottenere il nome della raccolta dal datastore.

curl

curl -H "${AUTH}" "${INGEST}/dataStores/acme-financials"

Python

data_store = session.get(INGEST + "/dataStores/acme-financials").json()
collection_name = data_store["collectionName"]
print(collection_name)

Monitoraggio dell'avanzamento dell'importazione

Per monitorare l'avanzamento del job di importazione, esegui il polling dell'operazione anziché controllare lo stato del bucket. Il campo successCount nella risposta fornisce il numero di file importati correttamente.

Puoi correggere gli errori ed effettuare un'altra richiesta di importazione per riprovare. Per saperne di più, consulta Esecuzione di un'operazione di importazione.

I seguenti esempi mostrano come eseguire il polling dell'operazione.

curl

curl -H "${AUTH}" "${BASE}/{OPERATION_NAME}"

Python

# To check once, without blocking, using the op returned by the import call:
status = session.get(BASE + "/" + op["name"]).json()
print(status.get("done"), status.get("metadata", {}))

L'esempio seguente mostra come ottenere un elenco dei file importati al termine dell'operazione di importazione.

curl

curl -H "${AUTH}" "${INGEST}/dataStores/acme-financials/documents"

Python

docs = session.get(INGEST + "/dataStores/acme-financials/documents").json()
print(len(docs.get("documents", [])))

Esecuzione di un'operazione di importazione

L'esecuzione di ulteriori operazioni di importazione sullo stesso bucket elabora solo i file che sono stati modificati o aggiunti. Un file che è già stato importato e non è stato modificato viene ignorato.

La raccolta creata dall'importione gestita è esattamente come una normale raccolta di recupero agentico. Puoi eseguire query e filtrare i risultati, eseguire il reranking, indicizzare e altro ancora.

Esempi

L'esempio seguente mostra come cercare i contenuti dei file importati da un datastore.

curl

COLLECTION=projects/${PROJECT}/locations/${LOCATION}/collections/google-acme-financials

curl -X POST -H "${AUTH}" -H "Content-Type: application/json" \
  "https://vectorsearch.googleapis.com/v1/${COLLECTION}/dataObjects:search" \
  -d '{
    "semantic_search": {
      "search_text": "what is the total revenue?",
      "search_field": "multimodal_embedding",
      "task_type": "RETRIEVAL_QUERY",
      "top_k": 10,
      "output_fields": {
        "data_fields": ["google_document_id", "google_customer_uri", "google_unstructured_details.content_snippet"]
      }
    }
  }'

Python

from google.cloud import vectorsearch_v1

# Create the client
search_client = vectorsearch_v1.DataObjectSearchServiceClient()

# Initialize request argument(s)
semantic_search = vectorsearch_v1.SemanticSearch(
    search_text="what is the total revenue?",
    search_field="multimodal_embedding",
    task_type=vectorsearch_v1.EmbeddingTaskType.RETRIEVAL_QUERY,
    top_k=10,
    output_fields=vectorsearch_v1.OutputFields(
        data_fields=["google_document_id", "google_customer_uri", "google_unstructured_details.content_snippet"],
    ),
)
request = vectorsearch_v1.SearchDataObjectsRequest(
    parent="projects/PROJECT_ID/locations/LOCATION/collections/COLLECTION_ID",
    semantic_search=semantic_search,
)

# Make the request
response = search_client.search_data_objects(request=request)

# Handle the response
for hit in response.results:
    data = dict(hit.data_object.data)
    print(hit.distance, data["google_customer_uri"][0])
    print(data["google_unstructured_details"]["content_snippet"][:200])

Risultati di ricerca

Ogni risultato di ricerca contiene le seguenti proprietà:

Proprietà Tipo Descrizione
google_document_id string Il documento da cui proviene il segmento.
google_customer_uri string L'URI gs:// originale per la citazione.
google_modality string UNSTRUCTURED o VIDEO.
google_unstructured_details.content_snippet string Il testo del segmento.
google_unstructured_details.start_page/end_page integer Intervallo di pagine del chunk. Compilato solo con la segmentazione delle pagine, che richiede l'analisi digitale; vuoto per la segmentazione dei blocchi.
google_video_details.start_offset_nanos/end_offset_nanos integer Intervallo di tempo di un segmento video.
multimodal_embedding Vettore, denso, 768 dimensioni L'embedding del segmento da gemini-embedding-2.
metadata oggetto Copiati dal documento in ciascuno dei suoi segmenti, senza prefisso e nidificati come dichiarato (ad esempio category o issuer.country).

Le proprietà start_page, end_page, start_offset_nanos e end_offset_nanos vengono sempre restituite, indipendentemente dal tipo di documento specificato.

Per i documenti di testo, start_page e end_page vengono compilati solo se la segmentazione delle pagine è stata specificata al momento della creazione del datastore.

Le proprietà in metadata corrispondono allo schema JSON fornito durante l'importazione.

Elimina definitivamente i file

Per eliminare definitivamente un file da un datastore, carica uno o più file di testo in Cloud Storage con ogni riga contenente l'ID di un file che vuoi eliminare definitivamente. Passa gli URI dei file di testo a un purgeDocuments.

La risposta non indica quali file vengono eliminati. Per verificare che un file sia stato eliminato definitivamente, chiama GetDocument. La risposta restituirà 404.

Imposta force su false per testare prima l'operazione di eliminazione. In questo modo, i file che verranno eliminati verranno registrati nel error_gcs_prefix specificato.

Una volta eliminati i file, puoi eliminare il datastore che contiene i file eliminati.

I seguenti esempi mostrano come eliminare definitivamente i file.

curl

curl -X POST -H "${AUTH}" -H "Content-Type: application/json" \
"${INGEST}/dataStores/acme:purgeDocuments" \
-d '{
  "gcs_source": {
    "input_uris": ["gs://acme/purge/purge-ids.txt"]
  },
  "purge_output_config": {
    "error_gcs_prefix": "gs://acme/purge-force-errors/"
  },
  "force": true
}'

Python

op = session.post(
  INGEST + "/dataStores/acme:purgeDocuments",
  json={
      "gcs_source": {
            "input_uris": ["gs://acme/purge/purge-ids.txt"],
        },
        "purge_output_config": {
            "error_gcs_prefix": "gs://acme/purge-force-errors/",
        },
        "force": True,
    },
).json()

result = wait(op)

Elimina un datastore

Invia una richiesta DELETE con l'URI del datastore per eliminarlo. Se force è impostato su true e il datastore contiene ancora file, la richiesta non andrà a buon fine con lo stato FAILED_PRECONDITION e il messaggio DataStore deletion is not allowed because it still contains documents. Set force=true to delete the DataStore and all its Documents..

Imposta backing_collection_deleted su true per eliminare la raccolta e gli oggetti dati creati dopo l'importazione del datastore. In caso contrario, la raccolta e gli oggetti dati rimangono e continuano a utilizzare la quota, mentre qualsiasi richiesta di creazione di un nuovo datastore con lo stesso ID non andrà a buon fine e verrà visualizzato il messaggio FAILED_PRECONDITION (BACKING_COLLECTION_ALREADY_EXISTS).

Quando la richiesta di eliminazione è in esecuzione, una richiesta get restituisce lo stato DELETING e un errore 404 al termine.

L'esempio seguente mostra come eliminare un datastore.

curl

curl -X DELETE -H "${AUTH}" \
  "${INGEST}/dataStores/acme-financials?force=true&backing_collection_deleted=true"

Python

op = session.delete(
  INGEST + "/dataStores/acme-financials",
  params={"force": "true", "backing_collection_deleted": "true"},
).json()

result = wait(op)