Nach FHIR-Ressourcen suchen

Auf dieser Seite werden die grundlegenden Anleitungen zur Suche nach FHIR-Ressourcen in einem FHIR-Speicher beschrieben. Die Suche nach FHIR-Ressourcen ist die primäre Methode zum Abfragen und Abrufen von Informationen aus FHIR-Daten.

So können Sie in der Cloud Healthcare API nach FHIR-Ressourcen suchen:

Diese Seite fasst viele der häufig verwendeten Suchfunktionen zusammen, ist jedoch keine vollständige Liste der Teile der FHIR-Suchspezifikation, die von der Cloud Healthcare API unterstützt werden.

FHIR-Viewer verwenden

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

So suchen Sie Ressourcen in einem FHIR-Speicher:

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

    FHIR-Viewer aufrufen

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

  3. Um die Liste der Ressourcentypen zu filtern, suchen Sie nach den Ressourcentypen, die Sie aufrufen möchten:

    1. Klicken Sie auf das Feld Resource Type (Ressourcentyp).

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

    3. Geben Sie einen Ressourcentyp ein.

    4. Um nach einem anderen Ressourcentyp zu suchen, wählen Sie OR aus der angezeigten Drop-down-Liste Operatoren aus und geben Sie dann einen anderen Ressourcentyp ein.

  4. Wählen Sie in 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 lassen, 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 in das Suchfeld den Wert ein, nach dem Sie suchen möchten.

Mit der Methode search

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.jackson2.JacksonFactory;
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.impl.client.HttpClients;

public class FhirResourceSearchGet {
  private static final String FHIR_NAME =
      "projects/%s/locations/%s/datasets/%s/fhirStores/%s/fhir/%s";
  private static final JsonFactory JSON_FACTORY = new JacksonFactory();
  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", "store-id", "resource-type");

    // Initialize the client, which will be used to interact with the service.
    CloudHealthcare client = createClient();

    HttpClient httpClient = HttpClients.createDefault();
    String uri = String.format("%sv1/%s", client.getRootUrl(), resourceName);
    URIBuilder uriBuilder = new URIBuilder(uri).setParameter("access_token", getAccessToken());

    HttpUriRequest request =
        RequestBuilder.get()
            .setUri(uriBuilder.build())
            .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 GET FHIR resources: %s\n", response.getStatusLine().toString()));
      responseEntity.writeTo(System.err);
      throw new RuntimeException();
    }
    System.out.println("FHIR resource 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

const google = require('@googleapis/healthcare');
const healthcare = google.healthcare({
  version: 'v1',
  auth: new google.auth.GoogleAuth({
    scopes: ['https://www.googleapis.com/auth/cloud-platform'],
  }),
});

const searchFhirResourcesGet = async () => {
  // 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 parent = `projects/${projectId}/locations/${cloudRegion}/datasets/${datasetId}/fhirStores/${fhirStoreId}/fhir`;
  const request = {parent, resourceType};

  const response =
    await healthcare.projects.locations.datasets.fhirStores.fhir.search(
      request
    );
  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/master/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 = "{}/projects/{}/locations/{}".format(base_url, project_id, 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.jackson2.JacksonFactory;
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";
  private static final JsonFactory JSON_FACTORY = new JacksonFactory();
  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");

    // Initialize the client, which will be used to interact with the service.
    CloudHealthcare client = createClient();

    HttpClient httpClient = HttpClients.createDefault();
    String uri = String.format("%sv1/%s/_search", client.getRootUrl(), resourceName);
    URIBuilder uriBuilder = new URIBuilder(uri).setParameter("access_token", getAccessToken());
    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 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

const google = require('@googleapis/healthcare');
const healthcare = google.healthcare({
  version: 'v1',
  auth: new google.auth.GoogleAuth({
    scopes: ['https://www.googleapis.com/auth/cloud-platform'],
  }),
  method: 'POST',
});

const searchFhirResourcesPost = async () => {
  // 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 parent = `projects/${projectId}/locations/${cloudRegion}/datasets/${datasetId}/fhirStores/${fhirStoreId}/fhir`;
  const request = {parent, resourceType};

  const response =
    await healthcare.projects.locations.datasets.fhirStores.fhir.search(
      request
    );
  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/master/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 = "{}/projects/{}/locations/{}".format(base_url, project_id, location)

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

    resource_path = "{}/Patient/_search?family:exact=Smith".format(fhir_store_path)

    # 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 in Patientenressourcen mit den folgenden Kriterien:

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

Es gibt keine Syntax zum Ausführen von OR aus zwei name=value-Paaren.

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

Paginierung und Sortierung

Der Parameter _count steuert die maximale Anzahl von Ressourcen, die von der Suchmethode zurückgegeben werden. Beispielsweise gibt _count=10 maximal 10 Ressourcen zurück, die der Abfrage entsprechen. Die Standardeinstellung ist 100 und der maximal zulässige Wert ist 1.000.

Wenn bei einer Suche mehr Ressourcen zurückgegeben werden, als auf eine Seite passen, enthält die Antwort eine URL zur Paginierung 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 mit dem entsprechenden Bundle.link.url die nächste Seite abrufen können.

Der Wert von Bundle.total gibt die Gesamtzahl übereinstimmender Ressourcen an. Dieser Wert ist exakt, wenn die Ergebnisse vollständig auf eine Seite passen, erhalten aber eine grobe Schätzung, da die Anzahl der Ergebnisse größer als eine Seite wird. Sie können eine genaue Gesamtsumme für eine Suche abrufen, die mit vielen Ergebnissen übereinstimmt, indem Sie den Seitenumbrüchen mehrfach folgen, bis die Ergebnisse erschöpft sind.

Sie können die Ergebnisse mit dem Parameter _sort sortieren. Dabei ist eine durch Kommas getrennte Liste von Suchparameternamen in Prioritätsreihenfolge zulässig. Mit dem Präfix - können Sie die absteigende Reihenfolge anzeigen. Die folgende Abfrage sortiert beispielsweise nach Status aufsteigend, aufgeschlüsselt nach Datum absteigend und alle verbleibenden Krawatten nach Kategorie aufsteigend:

_sort=status,-date,category

Verzögerung bei der Indexierung

FHIR-Ressourcen werden asynchron indexiert. Daher kann es zu einer leichten Verzögerung zwischen dem Zeitpunkt der Erstellung oder Änderung einer Ressource und dem Zeitpunkt der Erstellung oder Änderung in den Suchergebnissen kommen.

In allen Ressourcentypen suchen

Bestimmte Suchparameter (mit einem führenden Unterstrich wie _id) gelten für alle Ressourcentypen. Diese Ressourcenparameter sind in der FHIR-Spezifikation für den Ressourcentyp aufgeführt.

Wenn Sie diese Suchparameter verwenden, können Sie eine Suche in mehreren Ressourcentypen durchführen, indem Sie den Ressourcentyp im Anfragepfad weglassen. Beispiel: Wenn Sie GET .../fhir?_id=1234 anstelle von GET .../fhir/Patient?_id=1234 verwenden, werden alle FHIR-Ressourcen statt nur eine Patientenressource durchsucht. Sie können bei dieser Art von Anfrage den speziellen Parameter _type 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

Zu den Datentypen gehören auch die folgenden komplexen Typen:

  • Token
  • Referenz
  • Menge

Jeder Datentyp hat eine eigene Syntax zum Festlegen von Werten. Jeder Datentyp unterstützt Modifikatoren, die die Art der Suche verändern.

In den folgenden Abschnitten wird erläutert, wie Sie Datentypen verwenden. Weitere Informationen zu zusätzlichen Datentypen, Wertsyntaxen und Modifikatoren finden Sie unter Erweiterte FHIR-Suchfeatures.

Zahl

Suche nach Ganzzahl- oder Gleitkommawerten. Wenn Sie den Vergleichsoperator ändern möchten, stellen Sie dem Wert einen der folgenden Modifikatoren voran:

  • ne
  • lt
  • le
  • gt
  • ge

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

Datum

Es wird anhand von Datum, Uhrzeit oder Zeitraum gesucht. 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, bei der die Groß- und Kleinschreibung, die Akzente und andere diakritische Zeichen nicht berücksichtigt werden.

Token

Sucht nach der genauen Stringübereinstimmung eines "Codes". Sie können die Suche auf den URI eines "Systems" beschränken, um anzugeben, aus dem Wert, für den der Code übernommen wird, das folgende Format ist:

[parameter]=[system]|[code]

Die folgende Suche entspricht beispielsweise dem Code 10738-3, aber nur, wenn dies 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, das die Einheiten des Werts im folgenden Format angibt:

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

Die folgende Abfrage sucht beispielsweise nach Mengenwerten unter 9, 1 mit dem angegebenen Einheitensystem und Code:

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

Referenz

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

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

Mit [parameter]=[url] können Sie Referenzen nach URL angeben, die sich möglicherweise außerhalb des FHIR-Speichers befinden.

Umgang mit Suchparametern

Bei der Suchmethode wird standardmäßig die Methode "Nachsichtig" angewendet. Dabei werden Parameter ignoriert, die von der Suche nicht erkannt werden. Bei der Suche wird die Suche mit allen verbleibenden Parametern durchgeführt, die mehr Ressourcen als erwartet zurückgeben können.

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-Header der Anfrage bei einer Suchanfrage auf Prefer: handling=strict setzen. Wenn der Header festgelegt wird, gibt der FHIR-Speicher einen Fehler für jeden nicht erkannten Parameter zurück.