Nach FHIR-Ressourcen suchen

Auf dieser Seite werden die grundlegenden Anleitungen zum Suchen nach FHIR-Ressourcen in einem FHIR-Speicher erläutert. Nach FHIR-Ressourcen suchen, ist die primäre Methode zum Abfragen und Abrufen von Informationen aus FHIR-Daten.

Sie können in der Cloud Healthcare API auf folgende Weise nach FHIR-Ressourcen suchen:

Auf dieser Seite werden viele der häufig verwendeten Suchfunktionen zusammengefasst, es handelt sich jedoch nicht um eine vollständige Liste der von der Cloud Healthcare API unterstützten Teile der FHIR-Suchspezifikation.

FHIR-Betrachter verwenden

Der FHIR-Betrachter ist eine Seite in der Google Cloud Console, auf der Sie nach den Inhalten von FHIR-Ressourcen suchen und diese ansehen können.

Führen Sie die folgenden Schritte aus, um in einem FHIR-Speicher nach Ressourcen zu suchen:

  1. Rufen Sie in der Google Cloud Console die Seite FHIR-Betrachter auf.

    Zum FHIR-Viewer

  2. Wählen Sie in der Drop-down-Liste FHIR-Speicher ein Dataset und dann einen FHIR-Speicher im Dataset aus.

  3. Suchen Sie nach den Ressourcentypen, die Sie anzeigen möchten, um die Liste der Ressourcentypen zu filtern:

    1. Klicken Sie auf das Feld Ressourcentyp.

    2. Wählen Sie in der nun angezeigten Drop-down-Liste Attribute die Option Ressourcentyp aus.

    3. Geben Sie einen Ressourcentyp ein.

    4. Wenn Sie nach einem anderen Ressourcentyp suchen möchten, wählen Sie aus der nun angezeigten Drop-down-Liste Operatoren OR aus und geben einen anderen Ressourcentyp ein.

  4. Wählen Sie aus der Liste der Ressourcentypen den Ressourcentyp aus, nach dem Sie suchen möchten.

  5. Geben Sie im Suchfeld für die angezeigte Ressourcentabelle den Wert ein, nach dem Sie suchen möchten.

Der FHIR-Betrachter zeigt die Suchergebnisse in einer Tabelle an. Nachdem Sie eine Ressource ausgewählt haben, zeigt der FHIR-Betrachter den Inhalt der Ressource an.

Wenn Sie den Inhalt einer Ressource anzeigen, können Sie nach Daten innerhalb der Ressource suchen.

So suchen Sie innerhalb einer Ressource nach Daten:

  1. Wählen Sie eine Ressource aus.

  2. Klicken Sie im Bereich FHIR-Betrachter auf den Tab Elemente.

  3. Geben Sie im Suchfeld den Wert ein, nach dem Sie suchen möchten.

Binärdaten in FHIR-Ressourcen herunterladen

So laden Sie die mit einer Ressource verknüpften FHIR-Daten im FHIR-Betrachter herunter:

  1. Wählen Sie eine Ressource aus.

  2. Klicken Sie im Bereich FHIR-Betrachter auf den Tab Elemente.

  3. Maximieren Sie bei Bedarf die Elemente, um auf das erforderliche Ressourcenelement zuzugreifen.

  4. Klicken Sie auf Datei herunterladen, um die verfügbaren Daten herunterzuladen.

Erweiterte Suchanfragen erstellen und ausführen

Sie können erweiterte Suchanfragen verwenden, um mithilfe der FHIR-Suchspezifikation nach bestimmten FHIR-Ressourcen zu suchen.

Führen Sie die folgenden Schritte aus, um eine erweiterte Suchanfrage zu erstellen:

  1. Klicken Sie auf der Seite FHIR-Betrachter auf den Tab Suchen.

  2. Klicken Sie zum Erstellen einer Suchanfrage auf Query Builder öffnen.

    Der Bereich Abfrageauswahl wird angezeigt.

  3. Wählen Sie in der Liste FHIR-Ressourcentyp auswählen den FHIR-Ressourcentyp aus, nach dem Sie suchen möchten.

  4. Klicken Sie auf Weiter.

  5. Wählen Sie in der Liste Parameter den Parameter aus, mit dem Sie nach Ressourcen suchen möchten.

  6. Wählen Sie in der Liste Modifier den Modifikator aus, der auf die Suchanfrage angewendet werden soll. Die Liste enthält nur Modifikatoren, die mit dem Datentyp des ausgewählten Parameters kompatibel sind.

    Diese Auswahl ist optional. Wenn kein Modifikator ausgewählt ist, wird eine Gleichheitsprüfung durchgeführt.

  7. Geben Sie im Feld Wert den Wert des Abfrageparameters ein.

  8. Wenn Sie mehrere Parameterwerte hinzufügen möchten, klicken Sie auf ODER. Auf diese Weise können Sie mehrere Werte Ihres Ressourcenparameters in die Suchanfrage aufnehmen.

    Wenn Sie Ihre Suchanfrage erstellen, wird die Abfrage im Bereich Abfragevorschau angezeigt. Klicken Sie auf Vollständigen Pfad anzeigen, um die vollständige URL der Suchanfrage anzuzeigen.

  9. Wenn Sie mehrere Parameter hinzufügen möchten, klicken Sie auf UND.

  10. Klicken Sie auf Weiter.

  11. Um Ressourcen aufzunehmen, auf die von den in Ihrer Suchanfrage zurückgegebenen Ressourcen verwiesen wird, wählen Sie den Ressourcenparameter aus der Drop-down-Liste Enthaltene Parameter aus.

  12. Um Ressourcen aufzunehmen, die auf die in Ihrer Suchanfrage zurückgegebenen Ressourcen verweisen, wählen Sie den Ressourcenparameter aus der Drop-down-Liste Umgekehrte eingeschlossene Parameter aus.

  13. Klicken Sie auf Fertig, um die Suchanfrage zu speichern.

    Die gespeicherte Suchanfrage wird im Feld FHIR-Suchvorgang angezeigt.

  14. Klicken Sie auf Suchen ausführen, um mit der Abfrage nach Ressourcen zu suchen.

    Die Suchergebnisse werden in der Liste Suchergebnisse angezeigt. Wenn Sie Details zu einer von der Suche zurückgegebenen Ressource anzeigen möchten, klicken Sie auf eine Ressource in der Liste.

  15. Klicken Sie zum Speichern der Abfrage als Abfragevorlage auf Vorlage speichern und wählen Sie Vorlage speichern oder Vorlage speichern als aus. Sie werden aufgefordert, einen Namen und eine Beschreibung für die Abfrage einzugeben. Die Abfrageparameter werden in einer Vorlage gespeichert, aber alle definierten Werte werden entfernt.

Beispiel für eine Suchanfrage

Das folgende Beispiel zeigt eine Suchanfrage, die nach Anspruchsressourcen von einem bestimmten Gesundheitsdienstleister, Practitioner/12345, für den Monat August 2021 sucht:

  • Parameter: care-team
    • Wert: Practitioner/12345
  • Operator: AND
  • Parameter: created
    • Präfix: lt (lesser than)
    • Wert: 8/1/21, 12:00 AM
  • Operator: AND
  • Parameter: created
    • Präfix: gt (greater than)
    • Wert: 8/31/21, 11:59 PM

Dies wird im Bereich Abfrageauswahl wie folgt konfiguriert. Die Abfrage wird im Bereich Abfragevorschau als Vorschau angezeigt. Die Abfrage wird im Feld FHIR-Suchvorgang angezeigt.

Erweiterte FHIR-Suchanfrage

Suchanfragen bearbeiten

Führen Sie einen der folgenden Schritte aus, um eine Suchanfrage zu bearbeiten:

  • Klicken Sie zum Bearbeiten der Abfrage im Query Builder auf Query Builder öffnen.
  • Wenn Sie die Abfrage manuell bearbeiten möchten, bearbeiten Sie die Parameterwerte im Textfeld.

Abfragevorlagen ausführen

Führen Sie die folgenden Schritte aus, um eine Abfrage aus einer gespeicherten Vorlage auszuführen:

  1. Klicken Sie auf Gespeicherte Vorlagen.

    Der Tab Suchvorlagen des Steuerfelds Abfrageauswahl wird mit allen gespeicherten Abfragevorlagen angezeigt.

  2. Wählen Sie die Abfragevorlage aus, die Sie ausführen möchten, und klicken Sie auf Fertig.

    Die Suchanfrage der Vorlage wird im Feld FHIR-Suchvorgang ohne Werte angezeigt.

  3. Wenn Sie die Werte Ihrer Suchanfrage definieren möchten, bearbeiten Sie die Parameterwerte im Feld.

  4. Klicken Sie auf Run Search (Suche ausführen), um mit der Abfrage nach Ressourcen zu suchen.

search-Methode verwenden

Verwenden Sie die Methode projects.locations.datasets.fhirStores.fhir.search, um mit der REST API nach FHIR-Ressourcen zu suchen. Sie können die Methode mit GET- oder POST-Anfragen aufrufen.

search-Methode mit GET verwenden

Die folgenden Beispiele zeigen, wie Sie mit der Methode projects.locations.datasets.fhirStores.fhir.search und GET in einem bestimmten FHIR-Speicher nach Ressourcen suchen.

curl

Wenn Sie in einem FHIR-Speicher nach Ressourcen suchen möchten, senden Sie eine GET-Anfrage und geben Sie die folgenden Informationen an:

  • Der Name des Datasets
  • Der Name des FHIR-Speichers
  • Der Ressourcentyp, nach der gesucht werden soll
  • Ein Abfragestring, der die gesuchten Informationen enthält, wie im Abschnitt Suchanfrage erstellen beschrieben
  • Ein Zugriffstoken

Das folgende Beispiel zeigt eine GET-Anfrage mit curl zur Suche nach allen Patienten mit dem Nachnamen "Smith".

curl -X GET \
     -H "Authorization: Bearer $(gcloud auth application-default print-access-token)" \
     "https://healthcare.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/datasets/DATASET_ID/fhirStores/FHIR_STORE_ID/fhir/Patient?family:exact=Smith"

Wenn die Anfrage erfolgreich ist, gibt der Server die Antwort als FHIR Bundle im JSON-Format zurück. Bundle.type ist searchset und die Suchergebnisse sind Einträge im Array Bundle.entry. In diesem Beispiel gibt die Anfrage eine einzelne Patientenressource mit den Daten in dieser Ressource zurück:

{
  "entry": [
    {
      "fullUrl": "https://healthcare.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/datasets/DATASET_ID/fhirStores/FHIR_STORE_ID/fhir/Patient/PATIENT_ID",
      "resource": {
        "birthDate": "1970-01-01",
        "gender": "female",
        "id": "PATIENT_ID",
        "meta": {
          "lastUpdated": "LAST_UPDATED",
          "versionId": "VERSION_ID"
        },
        "name": [
          {
            "family": "Smith",
            "given": [
              "Darcy"
            ],
            "use": "official"
          }
        ],
        "resourceType": "Patient"
      },
      "search": {
        "mode": "match"
      }
    }
  ],
  "link": [
    {
      "url": "https://healthcare.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/datasets/DATASET_ID/fhirStores/FHIR_STORE_ID/fhir/Patient/?family%3Aexact=Smith"
    }
  ],
  "resourceType": "Bundle",
  "total": 1,
  "type": "searchset"
}

PowerShell

Wenn Sie in einem FHIR-Speicher nach Ressourcen suchen möchten, senden Sie eine GET-Anfrage und geben Sie die folgenden Informationen an:

  • Der Name des Datasets
  • Der Name des FHIR-Speichers
  • Der Ressourcentyp, nach der gesucht werden soll
  • Ein Abfragestring, der die gesuchten Informationen enthält, wie im Abschnitt Suchanfrage erstellen beschrieben
  • Ein Zugriffstoken

Das folgende Beispiel zeigt eine GET-Anfrage mit Windows PowerShell zur Suche nach allen Patienten mit dem Nachnamen "Smith".

$cred = gcloud auth application-default print-access-token
$headers = @{ Authorization = "Bearer $cred" }

Invoke-RestMethod `
  -Method Get `
  -Headers $headers `
  -Uri "https://healthcare.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/datasets/DATASET_ID/fhirStores/FHIR_STORE_ID/fhir/RESOURCE_TYPE?family:exact=Smith" | ConvertTo-Json

Wenn die Anfrage erfolgreich ist, gibt der Server die Antwort als FHIR Bundle im JSON-Format zurück. Bundle.type ist searchset und die Suchergebnisse sind Einträge im Array Bundle.entry. In diesem Beispiel gibt die Anfrage eine einzelne Patientenressource mit den Daten in dieser Ressource zurück:

{
  "entry": [
    {
      "fullUrl": "https://healthcare.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/datasets/DATASET_ID/fhirStores/FHIR_STORE_ID/fhir/Patient/PATIENT_ID",
      "resource": {
        "birthDate": "1970-01-01",
        "gender": "female",
        "id": "PATIENT_ID",
        "meta": {
          "lastUpdated": "LAST_UPDATED",
          "versionId": "VERSION_ID"
        },
        "name": [
          {
            "family": "Smith",
            "given": [
              "Darcy"
            ],
            "use": "official"
          }
        ],
        "resourceType": "Patient"
      },
      "search": {
        "mode": "match"
      }
    }
  ],
  "link": [
    {
      "url": "https://healthcare.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/datasets/DATASET_ID/fhirStores/FHIR_STORE_ID/fhir/Patient/?family%3Aexact=Smith"
    }
  ],
  "resourceType": "Bundle",
  "total": 1,
  "type": "searchset"
}

Java

import com.google.api.client.http.HttpRequestInitializer;
import com.google.api.client.http.javanet.NetHttpTransport;
import com.google.api.client.json.JsonFactory;
import com.google.api.client.json.gson.GsonFactory;
import com.google.api.services.healthcare.v1.CloudHealthcare;
import com.google.api.services.healthcare.v1.CloudHealthcareScopes;
import com.google.auth.http.HttpCredentialsAdapter;
import com.google.auth.oauth2.GoogleCredentials;
import java.io.IOException;
import java.net.URISyntaxException;
import java.util.Collections;
import org.apache.http.HttpEntity;
import org.apache.http.HttpResponse;
import org.apache.http.HttpStatus;
import org.apache.http.client.HttpClient;
import org.apache.http.client.methods.HttpUriRequest;
import org.apache.http.client.methods.RequestBuilder;
import org.apache.http.client.utils.URIBuilder;
import org.apache.http.entity.StringEntity;
import org.apache.http.impl.client.HttpClients;

public class FhirResourceSearchGet {
  private static final String FHIR_NAME =
      "projects/%s/locations/%s/datasets/%s/fhirStores/%s/fhir/%s";
  // The endpoint URL for the Healthcare API. Required for HttpClient.
  private static final String API_ENDPOINT = "https://healthcare.googleapis.com";
  private static final JsonFactory JSON_FACTORY = new GsonFactory();
  private static final NetHttpTransport HTTP_TRANSPORT = new NetHttpTransport();

  public static void fhirResourceSearchGet(String resourceName)
      throws IOException, URISyntaxException {
    // String resourceName =
    //    String.format(
    //        FHIR_NAME, "project-id", "region-id", "dataset-id", "fhir-store-id");
    // String resourceType = "Patient";

    // Instantiate the client, which will be used to interact with the service.
    HttpClient httpClient = HttpClients.createDefault();
    String uri = String.format("%s/v1/%s", API_ENDPOINT, resourceName);
    URIBuilder uriBuilder = new URIBuilder(uri).setParameter("access_token", getAccessToken());
    // To set additional parameters for search filtering, add them to the URIBuilder. For
    // example, to search for a Patient with the family name "Smith", specify the following:
    // uriBuilder.setParameter("family:exact", "Smith");

    HttpUriRequest request =
        RequestBuilder.get()
            .setUri(uriBuilder.build())
            .build();

    // Execute the request and process the results.
    HttpResponse response = httpClient.execute(request);
    HttpEntity responseEntity = response.getEntity();
    if (response.getStatusLine().getStatusCode() != HttpStatus.SC_OK) {
      System.err.print(
          String.format(
              "Exception searching GET FHIR resources: %s\n", response.getStatusLine().toString()));
      responseEntity.writeTo(System.err);
      throw new RuntimeException();
    }
    System.out.println("FHIR resource GET search results: ");
    responseEntity.writeTo(System.out);
  }

  private static CloudHealthcare createClient() throws IOException {
    // Use Application Default Credentials (ADC) to authenticate the requests
    // For more information see https://cloud.google.com/docs/authentication/production
    GoogleCredentials credential =
        GoogleCredentials.getApplicationDefault()
            .createScoped(Collections.singleton(CloudHealthcareScopes.CLOUD_PLATFORM));
    // Create a HttpRequestInitializer, which will provide a baseline configuration to all requests.
    HttpRequestInitializer requestInitializer =
        request -> {
          new HttpCredentialsAdapter(credential).initialize(request);
          request.setConnectTimeout(60000); // 1 minute connect timeout
          request.setReadTimeout(60000); // 1 minute read timeout
        };
    // Build the client for interacting with the service.
    return new CloudHealthcare.Builder(HTTP_TRANSPORT, JSON_FACTORY, requestInitializer)
        .setApplicationName("your-application-name")
        .build();
  }

  private static String getAccessToken() throws IOException {
    GoogleCredentials credential =
        GoogleCredentials.getApplicationDefault()
            .createScoped(Collections.singleton(CloudHealthcareScopes.CLOUD_PLATFORM));

    return credential.refreshAccessToken().getTokenValue();
  }
}

Node.js

// Import google-auth-library for authentication.
const {GoogleAuth} = require('google-auth-library');

const searchFhirResourcesGet = async () => {
  const auth = new GoogleAuth({
    scopes: 'https://www.googleapis.com/auth/cloud-platform',
  });
  // TODO(developer): uncomment these lines before running the sample
  // const cloudRegion = 'us-central1';
  // const projectId = 'adjective-noun-123';
  // const datasetId = 'my-dataset';
  // const fhirStoreId = 'my-fhir-store';
  // const resourceType = 'Patient';
  const url = `https://healthcare.googleapis.com/v1/projects/${projectId}/locations/${cloudRegion}/datasets/${datasetId}/fhirStores/${fhirStoreId}/fhir/${resourceType}`;

  const params = {};
  // Specify search filters in a params object. For example, to filter on a
  // Patient with the last name "Smith", set resourceType to "Patient" and
  // specify the following params:
  // params = {'family:exact' : 'Smith'};
  const client = await auth.getClient();
  const response = await client.request({url, method: 'GET', params});
  const resources = response.data.entry;
  console.log(`Resources found: ${resources.length}`);
  console.log(JSON.stringify(resources, null, 2));
};

searchFhirResourcesGet();

Python

def search_resources_get(
    project_id,
    location,
    dataset_id,
    fhir_store_id,
    resource_type,
):
    """
    Uses the searchResources GET method to search for resources in the given FHIR store.

    See https://github.com/GoogleCloudPlatform/python-docs-samples/tree/main/healthcare/api-client/v1/fhir
    before running the sample."""
    # Imports Python's built-in "os" module
    import os

    # Imports the google.auth.transport.requests transport
    from google.auth.transport import requests

    # Imports a module to allow authentication using a service account
    from google.oauth2 import service_account

    # Gets credentials from the environment.
    credentials = service_account.Credentials.from_service_account_file(
        os.environ["GOOGLE_APPLICATION_CREDENTIALS"]
    )
    scoped_credentials = credentials.with_scopes(
        ["https://www.googleapis.com/auth/cloud-platform"]
    )
    # Creates a requests Session object with the credentials.
    session = requests.AuthorizedSession(scoped_credentials)

    # URL to the Cloud Healthcare API endpoint and version
    base_url = "https://healthcare.googleapis.com/v1"

    # TODO(developer): Uncomment these lines and replace with your values.
    # project_id = 'my-project'  # replace with your GCP project ID
    # location = 'us-central1'  # replace with the parent dataset's location
    # dataset_id = 'my-dataset'  # replace with the parent dataset's ID
    # fhir_store_id = 'my-fhir-store' # replace with the FHIR store ID
    # resource_type = 'Patient'  # replace with the FHIR resource type
    url = f"{base_url}/projects/{project_id}/locations/{location}"

    resource_path = "{}/datasets/{}/fhirStores/{}/fhir/{}".format(
        url, dataset_id, fhir_store_id, resource_type
    )

    response = session.get(resource_path)
    response.raise_for_status()

    resources = response.json()

    print(
        "Using GET request, found a total of {} {} resources:".format(
            resources["total"], resource_type
        )
    )
    print(json.dumps(resources, indent=2))

    return resources

search-Methode mit POST verwenden

Die folgenden Beispiele zeigen, wie Sie mit der Methode projects.locations.datasets.fhirStores.fhir.search und POST in einem bestimmten FHIR-Speicher nach Ressourcen suchen.

curl

Wenn Sie in einem FHIR-Speicher nach Ressourcen suchen möchten, senden Sie eine POST-Anfrage und geben Sie die folgenden Informationen an:

  • Der Name des Datasets
  • Der Name des FHIR-Speichers
  • Der Ressourcentyp, nach der gesucht werden soll
  • Ein Abfragestring, der die gesuchten Informationen enthält, wie im Abschnitt Suchanfrage erstellen beschrieben
  • Ein Zugriffstoken

Das folgende Beispiel zeigt eine POST-Anfrage mit curl zur Suche nach allen Patienten mit dem Nachnamen "Smith".

curl -X POST \
    --data "" \
    -H "Authorization: Bearer $(gcloud auth application-default print-access-token)" \
    -H "Content-Type: application/fhir+json; charset=utf-8" \
    "https://healthcare.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/datasets/DATASET_ID/fhirStores/FHIR_STORE_ID/fhir/Patient/_search?family:exact=Smith"

Wenn die Anfrage erfolgreich ist, gibt der Server die Antwort als FHIR Bundle im JSON-Format zurück. Bundle.type ist searchset und die Suchergebnisse sind Einträge im Array Bundle.entry. In diesem Beispiel gibt die Anfrage eine einzelne Patientenressource mit den Daten in dieser Ressource zurück:

{
  "entry": [
    {
      "fullUrl": "https://healthcare.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/datasets/DATASET_ID/fhirStores/FHIR_STORE_ID/fhir/Patient/PATIENT_ID",
      "resource": {
        "birthDate": "1970-01-01",
        "gender": "female",
        "id": "PATIENT_ID",
        "meta": {
          "lastUpdated": "LAST_UPDATED",
          "versionId": "VERSION_ID"
        },
        "name": [
          {
            "family": "Smith",
            "given": [
              "Darcy"
            ],
            "use": "official"
          }
        ],
        "resourceType": "Patient"
      },
      "search": {
        "mode": "match"
      }
    }
  ],
  "link": [
    {
      "url": "https://healthcare.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/datasets/DATASET_ID/fhirStores/FHIR_STORE_ID/fhir/Patient/?family%3Aexact=Smith"
    }
  ],
  "resourceType": "Bundle",
  "total": 1,
  "type": "searchset"
}

PowerShell

Wenn Sie in einem FHIR-Speicher nach Ressourcen suchen möchten, senden Sie eine POST-Anfrage und geben Sie die folgenden Informationen an:

  • Der Name des Datasets
  • Der Name des FHIR-Speichers
  • Der Ressourcentyp, nach der gesucht werden soll
  • Ein Abfragestring, der die gesuchten Informationen enthält, wie im Abschnitt Suchanfrage erstellen beschrieben
  • Ein Zugriffstoken

Das folgende Beispiel zeigt eine POST-Anfrage mit Windows PowerShell zur Suche nach allen Patienten mit dem Nachnamen "Smith".

$cred = gcloud auth application-default print-access-token
$headers = @{ Authorization = "Bearer $cred" }

Invoke-RestMethod `
  -Method Post `
  -Headers $headers `
  -ContentType: "application/fhir+json; charset=utf-8" `
  -Uri "https://healthcare.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/datasets/DATASET_ID/fhirStores/FHIR_STORE_ID/fhir/Patient/_search?family:exact=Smith" | ConvertTo-Json

Wenn die Anfrage erfolgreich ist, gibt der Server die Antwort als FHIR Bundle im JSON-Format zurück. Bundle.type ist searchset und die Suchergebnisse sind Einträge im Array Bundle.entry. In diesem Beispiel gibt die Anfrage eine einzelne Patientenressource mit den Daten in dieser Ressource zurück:

{
  "entry": [
    {
      "fullUrl": "https://healthcare.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/datasets/DATASET_ID/fhirStores/FHIR_STORE_ID/fhir/Patient/PATIENT_ID",
      "resource": {
        "birthDate": "1970-01-01",
        "gender": "female",
        "id": "PATIENT_ID",
        "meta": {
          "lastUpdated": "LAST_UPDATED",
          "versionId": "VERSION_ID"
        },
        "name": [
          {
            "family": "Smith",
            "given": [
              "Darcy"
            ],
            "use": "official"
          }
        ],
        "resourceType": "Patient"
      },
      "search": {
        "mode": "match"
      }
    }
  ],
  "link": [
    {
      "url": "https://healthcare.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/datasets/DATASET_ID/fhirStores/FHIR_STORE_ID/fhir/Patient/?family%3Aexact=Smith"
    }
  ],
  "resourceType": "Bundle",
  "total": 1,
  "type": "searchset"
}

Java

import com.google.api.client.http.HttpRequestInitializer;
import com.google.api.client.http.javanet.NetHttpTransport;
import com.google.api.client.json.JsonFactory;
import com.google.api.client.json.gson.GsonFactory;
import com.google.api.services.healthcare.v1.CloudHealthcare;
import com.google.api.services.healthcare.v1.CloudHealthcareScopes;
import com.google.auth.http.HttpCredentialsAdapter;
import com.google.auth.oauth2.GoogleCredentials;
import java.io.IOException;
import java.net.URISyntaxException;
import java.util.Collections;
import org.apache.http.HttpEntity;
import org.apache.http.HttpResponse;
import org.apache.http.HttpStatus;
import org.apache.http.client.HttpClient;
import org.apache.http.client.methods.HttpUriRequest;
import org.apache.http.client.methods.RequestBuilder;
import org.apache.http.client.utils.URIBuilder;
import org.apache.http.entity.StringEntity;
import org.apache.http.impl.client.HttpClients;

public class FhirResourceSearchPost {
  private static final String FHIR_NAME =
      "projects/%s/locations/%s/datasets/%s/fhirStores/%s/fhir/%s";
  // The endpoint URL for the Healthcare API. Required for HttpClient.
  private static final String API_ENDPOINT = "https://healthcare.googleapis.com";
  private static final JsonFactory JSON_FACTORY = new GsonFactory();
  private static final NetHttpTransport HTTP_TRANSPORT = new NetHttpTransport();

  public static void fhirResourceSearchPost(String resourceName)
      throws IOException, URISyntaxException {
    // String resourceName =
    //    String.format(
    //        FHIR_NAME, "project-id", "region-id", "dataset-id", "store-id", "resource-type");

    // Instantiate the client, which will be used to interact with the service.
    HttpClient httpClient = HttpClients.createDefault();
    String uri = String.format("%s/v1/%s/_search", API_ENDPOINT, resourceName);
    URIBuilder uriBuilder = new URIBuilder(uri).setParameter("access_token", getAccessToken());
    // To set additional parameters for search filtering, add them to the URIBuilder. For
    // example, to search for a Patient with the family name "Smith", specify the following:
    // uriBuilder.setParameter("family:exact", "Smith");

    // Set a body otherwise HttpClient complains there is no Content-Length set.
    StringEntity requestEntity = new StringEntity("");

    HttpUriRequest request =
        RequestBuilder.post()
            .setUri(uriBuilder.build())
            .setEntity(requestEntity)
            .addHeader("Content-Type", "application/fhir+json")
            .addHeader("Accept-Charset", "utf-8")
            .addHeader("Accept", "application/fhir+json; charset=utf-8")
            .build();

    // Execute the request and process the results.
    HttpResponse response = httpClient.execute(request);
    HttpEntity responseEntity = response.getEntity();
    if (response.getStatusLine().getStatusCode() != HttpStatus.SC_OK) {
      System.err.print(
          String.format(
              "Exception searching POST FHIR resources: %s\n",
              response.getStatusLine().toString()));
      responseEntity.writeTo(System.err);
      throw new RuntimeException();
    }
    System.out.println("FHIR resource POST search results: ");
    responseEntity.writeTo(System.out);
  }

  private static CloudHealthcare createClient() throws IOException {
    // Use Application Default Credentials (ADC) to authenticate the requests
    // For more information see https://cloud.google.com/docs/authentication/production
    GoogleCredentials credential =
        GoogleCredentials.getApplicationDefault()
            .createScoped(Collections.singleton(CloudHealthcareScopes.CLOUD_PLATFORM));

    // Create a HttpRequestInitializer, which will provide a baseline configuration to all requests.
    HttpRequestInitializer requestInitializer =
        request -> {
          new HttpCredentialsAdapter(credential).initialize(request);
          request.setConnectTimeout(60000); // 1 minute connect timeout
          request.setReadTimeout(60000); // 1 minute read timeout
        };

    // Build the client for interacting with the service.
    return new CloudHealthcare.Builder(HTTP_TRANSPORT, JSON_FACTORY, requestInitializer)
        .setApplicationName("your-application-name")
        .build();
  }

  private static String getAccessToken() throws IOException {
    GoogleCredentials credential =
        GoogleCredentials.getApplicationDefault()
            .createScoped(Collections.singleton(CloudHealthcareScopes.CLOUD_PLATFORM));

    return credential.refreshAccessToken().getTokenValue();
  }
}

Node.js

// Import google-auth-library for authentication.
const {GoogleAuth} = require('google-auth-library');

const searchFhirResourcesPost = async () => {
  const auth = new GoogleAuth({
    scopes: 'https://www.googleapis.com/auth/cloud-platform',
    // Set application/fhir+json header because this is a POST request.
    headers: {'Content-Type': 'application/fhir+json'},
  });
  // TODO(developer): uncomment these lines before running the sample
  // const cloudRegion = 'us-central1';
  // const projectId = 'adjective-noun-123';
  // const datasetId = 'my-dataset';
  // const fhirStoreId = 'my-fhir-store';
  // const resourceType = 'Patient';
  const url = `https://healthcare.googleapis.com/v1/projects/${projectId}/locations/${cloudRegion}/datasets/${datasetId}/fhirStores/${fhirStoreId}/fhir/${resourceType}/_search`;

  const params = {};
  // Specify search filters in a params object. For example, to filter on a
  // Patient with the last name "Smith", set resourceType to "Patient" and
  // specify the following params:
  // params = {'family:exact' : 'Smith'};
  const client = await auth.getClient();
  const response = await client.request({url, method: 'POST', params});
  const resources = response.data.entry;
  console.log(`Resources found: ${resources.length}`);
  console.log(JSON.stringify(resources, null, 2));
};

searchFhirResourcesPost();

Python

def search_resources_post(project_id, location, dataset_id, fhir_store_id):
    """
    Searches for resources in the given FHIR store. Uses the
    _search POST method and a query string containing the
    information to search for. In this sample, the search criteria is
    'family:exact=Smith' on a Patient resource.

    See https://github.com/GoogleCloudPlatform/python-docs-samples/tree/main/healthcare/api-client/v1/fhir
    before running the sample."""
    # Imports Python's built-in "os" module
    import os

    # Imports the google.auth.transport.requests transport
    from google.auth.transport import requests

    # Imports a module to allow authentication using a service account
    from google.oauth2 import service_account

    # Gets credentials from the environment.
    credentials = service_account.Credentials.from_service_account_file(
        os.environ["GOOGLE_APPLICATION_CREDENTIALS"]
    )
    scoped_credentials = credentials.with_scopes(
        ["https://www.googleapis.com/auth/cloud-platform"]
    )
    # Creates a requests Session object with the credentials.
    session = requests.AuthorizedSession(scoped_credentials)

    # URL to the Cloud Healthcare API endpoint and version
    base_url = "https://healthcare.googleapis.com/v1"

    # TODO(developer): Uncomment these lines and replace with your values.
    # project_id = 'my-project'  # replace with your GCP project ID
    # location = 'us-central1'  # replace with the parent dataset's location
    # dataset_id = 'my-dataset'  # replace with the parent dataset's ID
    # fhir_store_id = 'my-fhir-store' # replace with the FHIR store ID
    url = f"{base_url}/projects/{project_id}/locations/{location}"

    fhir_store_path = "{}/datasets/{}/fhirStores/{}/fhir".format(
        url, dataset_id, fhir_store_id
    )

    resource_path = f"{fhir_store_path}/Patient/_search?family:exact=Smith"

    # Sets required application/fhir+json header on the request
    headers = {"Content-Type": "application/fhir+json;charset=utf-8"}

    response = session.post(resource_path, headers=headers)
    response.raise_for_status()

    resources = response.json()
    print(
        "Using POST request, found a total of {} Patient resources:".format(
            resources["total"]
        )
    )

    print(json.dumps(resources, indent=2))

    return resources

Suchanfrage erstellen

Der Abfragestring besteht aus einer Reihe von name=value-Paaren, die in URL-Form codiert sind. Bei einer Suche werden alle Paare mit einem logischen AND kombiniert. Jeder Wert kann eine durch Kommas getrennte Liste von Werten sein, die als logisches OR dieser Werte behandelt werden. Beispielsweise ist Patient?key1=value1&key2=value2,value3 eine Suche nach Patientenressourcen nach den folgenden Kriterien:

(key1 = value1) AND (key2 = value2 OR key2 = value3)

Es gibt keine Syntax, um einen OR von zwei name=value-Paaren auszuführen.

Jeder FHIR-Ressourcentyp definiert in jeder Version von FHIR seine eigenen Suchparameter. Die verfügbaren Parameter sind in der FHIR-Spezifikation für jede Ressource dokumentiert. Ein Beispiel finden Sie unter FHIR R4 Patienten. Sie können die Parameter programmatisch über die Capability-Anweisung abrufen. Die Cloud Healthcare API unterstützt die meisten Suchparameter. Ausschlüsse finden Sie in der Funktionserklärung oder der FHIR-Konformitätserklärung.

Paginierung und Sortierung

Die Anzahl der Ressourcen, die auf jeder Seite der FHIR-Suchergebnisse zurückgegeben werden, hängt von den folgenden Faktoren ab:

  • Der Parameter _count. Er steuert die maximale Anzahl an Ressourcen, die von der Suchmethode zurückgegeben werden. _count=10 gibt beispielsweise höchstens zehn Ressourcen zurück, die der Abfrage entsprechen. Der Standardwert ist 100 und der maximal zulässige Wert ist 1.000.
  • Die Größe der Antwortdaten. Eine Suchergebnisseite kann weniger Ressourcen als der im Parameter _count angegebene Wert zurückgeben, wenn die Antwort groß ist.

Wenn eine Suche mehr Ressourcen zurückgibt, als auf eine Seite passen, enthält die Antwort eine Paginierungs-URL im Feld Bundle.link. In diesem Feld können mehrere Werte zurückgegeben werden. Der Wert mit Bundle.link.relation = next gibt an, dass Sie den entsprechenden Bundle.link.url verwenden können, um die nächste Seite abzurufen.

Der Wert von Bundle.total gibt die Gesamtzahl der übereinstimmenden Ressourcen an. Dieser Wert ist genau, wenn die Ergebnisse vollständig in eine Seite passen, aber eine grobe Schätzung wird, wenn die Anzahl der Ergebnisse größer als eine Seite wird. Sie können eine genaue Gesamtzahl für eine Suche abrufen, die mit vielen Ergebnissen übereinstimmt, indem Sie den Paginierungslinks wiederholt folgen, bis die Ergebnisse erschöpft sind.

Weitere Informationen zu Paginierung und Suchergebnissen finden Sie unter Paginierung und Suchergebnisse mit der FHIR-Suche implementieren.

Sie können die Ergebnisse mit dem Parameter _sort sortieren, der eine durch Kommas getrennte Liste von Suchparameternamen in Prioritätsreihenfolge akzeptiert. Sie können ein Präfix - verwenden, um die absteigende Reihenfolge anzugeben. Die folgende Abfrage sortiert beispielsweise nach Status aufsteigend, Bindungen nach Datum absteigend und alle verbleibenden Bindungen nach Kategorie aufsteigend:

_sort=status,-date,category

Verzögerung bei der Indexierung

FHIR-Ressourcen werden asynchron indexiert. Daher kann es zu einer geringfügigen Verzögerung zwischen dem Erstellen oder Ändern einer Ressource und dem Zeitpunkt kommen, an dem die Änderung in den Suchergebnissen angezeigt wird. Die einzige Ausnahme sind Daten zu Ressourcen-IDs, die synchron als spezieller Index indexiert werden. Daher ist bei der Suche mithilfe der Ressourcen-ID keine Indexierungsverzögerung zu erwarten. Wenn Sie den speziellen synchronen Index verwenden möchten, muss der Suchbegriff für die Kennung dem Muster identifier=[system]|[value] oder identifier=[value] entsprechen. Außerdem können Sie einen der folgenden Suchergebnisparameter verwenden:

  • _count
  • _include
  • _revinclude
  • _summary
  • _elements

Wenn Ihre Abfrage andere Suchparameter enthält, wird stattdessen der standardmäßige asynchrone Index verwendet. Die Suche im speziellen Index ist für die Auflösung einer kleinen Anzahl von Übereinstimmungen optimiert. Die Suche ist nicht optimiert,wenn Ihre Suchkriterien für die Kennung mit einer großen Anzahl (d. h. mehr als 2.000) von Ressourcen übereinstimmen. Wenn eine Suchanfrage mit einer großen Anzahl von Ressourcen übereinstimmt, können Sie die Verwendung des speziellen synchronen Index vermeiden, indem Sie Ihrer Abfrage einen zusätzlichen _sort-Parameter hinzufügen. Verwenden Sie _sort=-_lastUpdated, wenn Sie die Standardsortierreihenfolge beibehalten möchten.

In allen Ressourcentypen suchen

Bestimmte Suchparameter, die durch einen vorangestellten Unterstrich wie _id gekennzeichnet sind, gelten für alle Ressourcentypen. Diese Parameter für alle Ressourcen sind in der FHIR-Spezifikation für den Typ aufgeführt.

Wenn Sie diese Suchparameter verwenden, können Sie eine Suche in mehreren Ressourcentypen durchführen, indem Sie den Ressourcentyp im Anfragepfad weglassen. Wenn Sie beispielsweise GET .../fhir?_id=1234 anstelle von GET .../fhir/Patient?_id=1234 verwenden, wird in allen FHIR-Ressourcen gesucht, nicht nur in einer Patientenressource. Sie können den speziellen Parameter _type mit diesem Anfragetyp verwenden, um die Ergebnisse auf eine durch Kommas getrennte Liste von Ressourcentypen zu beschränken. Die folgende Abfrage gibt beispielsweise nur übereinstimmende Ergebnisse für die Ressourcen Observation und Condition zurück:

GET .../fhir?_tag=active&_type=Observation,Condition

Datentypen

Jeder von FHIR definierte Suchparameter hat einen Datentyp, der einfache Typen wie die folgenden enthält:

  • String
  • Zahl
  • Datum

Datentypen umfassen auch die folgenden komplexen Typen:

  • Token
  • Referenz
  • Menge

Jeder Datentyp verfügt über eine eigene Syntax zur Angabe von Werten. Jeder Datentyp unterstützt Modifikatoren, die die Art und Weise der Suche ändern.

In den folgenden Abschnitten wird die Verwendung von Datentypen veranschaulicht. Weitere Informationen zu zusätzlichen Datentypen, Wertesyntaxen und Modifikatoren finden Sie unter Erweiterte FHIR-Suchfunktionen.

Zahl

Sucht nach Ganzzahl- oder Gleitkommawerten. Stellen Sie dem Wert einen der folgenden Modifikatoren voran, um den Komparator zu ändern:

  • ne
  • lt
  • le
  • gt
  • ge

Verwenden Sie beispielsweise [parameter]=100 für Gleichheit oder [parameter]=ge100 für größer oder gleich 100.

Datum

Datum sucht nach beliebigen Datums-, Zeit- oder Zeitraumarten. Das Datumsparameterformat sieht so aus:

yyyy-mm-ddThh:mm:ss[Z|(+|-)hh:mm]

Es gelten dieselben Präfixmodifikatoren wie für number.

String

Die Standardeinstellung ist eine Präfixsuche, die nicht zwischen Groß- und Kleinschreibung, Akzenten oder anderen diakritischen Zeichen unterscheidet.

Token

Sucht nach einer genauen Stringübereinstimmung eines "Codes". Sie können die Suche auf den URI eines "Systems" beschränken, der angibt, aus welchem Wertesatz der Code im folgenden Format stammt:

[parameter]=[system]|[code]

Die folgende Suche entspricht beispielsweise dem Code 10738-3, aber nur, wenn er als Wert aus einem Codierungssystem mit dem angegebenen URI qualifiziert ist:

code=http://hl7.org/fhir/ValueSet/observation-codes|10738-3

Menge

Sucht nach einem numerischen Wert mit denselben Präfixmodifikatoren wie number. Sie können die Suche mit einem bestimmten System und Code qualifizieren, der die Einheiten des Werts im folgenden Format angibt:

[parameter]=[prefix][number]|[system]|[code]

Die folgende Abfrage sucht beispielsweise nach Mengenwerten unter 9,1, die das angegebene Einheitensystem und den angegebenen Code haben:

value-quantity=lt9.1|http://unitsofmeasure.org|mg

Referenz

Sucht nach Verweisen zwischen Ressourcen. Sie können die folgenden Abfragen für Verweise auf Ressourcen in einem FHIR-Speicher verwenden:

  • [parameter]=[id]
  • [parameter]=[type]/[id]

Sie können [parameter]=[url] verwenden, um Verweise nach URL anzugeben, die sich außerhalb des FHIR-Speichers befinden kann.

Umgang mit Suchparametern

Standardmäßig wendet die Suchmethode "nachsichtige" Behandlung an. Dabei werden Parameter ignoriert, die die Suche nicht erkennt. Die Suchmethode führt die Suche mit den verbleibenden Parametern in der Anfrage durch, die möglicherweise mehr Ressourcen als erwartet zurückgeben.

Die Antwort umfasst Folgendes:

  • Ein Wert in Bundle.link mit dem Wert Bundle.link.relation = self
  • Ein Bundle.link.url einer URL, die nur die Parameter enthält, die erfolgreich auf die Suche angewendet wurden. Sie können diesen Wert prüfen, um festzustellen, ob Parameter ignoriert wurden.

Sie können den HTTP-Anfrage-Header bei einer Suchanfrage auf Prefer: handling=strict setzen. Wenn Sie den Header festlegen, gibt der FHIR-Speicher einen Fehler bei einem nicht erkannten Parameter zurück.