Nach FHIR-Ressourcen suchen

Auf dieser Seite wird gezeigt, wie Sie in einem FHIR-Speicher nach Ressourcen suchen. Zum Suchen von FHIR-Ressourcen haben Sie folgende Möglichkeiten:

• FHIR-Betrachter in der Cloud Console
• Die Methode projects.locations.datasets.fhirStores.fhir.search. Mit der Methode können Sie nach FHIR-Ressourcen suchen:
  • GET-Anfragen
  • POST-Anfragen

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

FHIR-Betrachter verwenden

Vorschau

In diesem Abschnitt werden Vorschaufunktionen beschrieben, die geändert werden können und möglicherweise nur eingeschränkt verfügbar sind. Änderungen an pre-GA-Produkten und -Funktionen sind möglicherweise nicht mit anderen pre-GA-Versionen kompatibel. Weitere Informationen finden Sie unter Vor dem GA-Angebot für die Cloud Healthcare API und in den Beschreibungen der Startphase.

Der FHIR-Viewer ist eine Seite in der Cloud Console, mit der Sie die Inhalte von FHIR-Ressourcen suchen und anzeigen können.

So suchen Sie in einem FHIR-Speicher nach Ressourcen:

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

   Zur FHIR-Ansicht

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 angezeigten Ressourcentypen, um die Liste der Ressourcentypen zu filtern:

   1. Klicken Sie auf das Feld Ressourcentyp.

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

   3. Geben Sie einen Ressourcentyp ein.

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

4. Wählen Sie in der Liste der Ressourcentypen den Ressourcentyp aus, in 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-Viewer zeigt die Suchergebnisse in einer Tabelle an. Nachdem Sie eine Ressource ausgewählt haben, zeigt der FHIR-Viewer den Inhalt der Ressource an.

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

So suchen Sie innerhalb einer Ressource nach Daten:

1. Wählen Sie eine Ressource aus.

2. Klicken Sie im FHIR-Viewer auf den Tab Elemente.

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

Methode search 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

Auf GitHub ansehen Feedback

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

Auf GitHub ansehen Feedback

const {google} = require('googleapis');
const healthcare = google.healthcare('v1');

const searchFhirResourcesGet = async () => {
  const auth = await google.auth.getClient({
    scopes: ['https://www.googleapis.com/auth/cloud-platform'],
  });
  google.options({auth});

  // 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

Auf GitHub ansehen Feedback

def search_resources_get(
    base_url, project_id, cloud_region, dataset_id, fhir_store_id, resource_type,
):
    """
    Searches resources in the given FHIR store.

    It uses the searchResources GET method.
    """
    url = "{}/projects/{}/locations/{}".format(base_url, project_id, cloud_region)

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

    # Make an authenticated API request
    session = get_session()

    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

Auf GitHub ansehen Feedback

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

Auf GitHub ansehen Feedback

const {google} = require('googleapis');
const healthcare = google.healthcare('v1');

const searchFhirResourcesPost = async () => {
  const auth = await google.auth.getClient({
    scopes: ['https://www.googleapis.com/auth/cloud-platform'],
  });
  google.options({auth, method: 'POST'});

  // 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

Auf GitHub ansehen Feedback

def search_resources_post(
    base_url, project_id, cloud_region, dataset_id, fhir_store_id
):
    """
    Searches resources in the given FHIR store.

    It 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.
    """
    url = "{}/projects/{}/locations/{}".format(base_url, project_id, cloud_region)

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

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

    # Make an authenticated API request
    session = get_session()

    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. Beispiel:

Patient?key1=value1&key2=value2,value3

ist eine Suche in Patient-Ressourcen nach folgenden Kriterien:

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

Es gibt keine Syntax, um ein OR von zwei name=value-Paaren durchzufü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, z. B. FHIR R4 Patienten, und können programmatisch über die Capability-Anweisung abgerufen werden. 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 maximale Anzahl der von der Suchmethode zurückgegebenen Ressourcen wird durch den Parameter _count gesteuert. _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.

Wenn bei der Suche mehr Ressourcen gefunden wurden, 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 der entsprechende Bundle.link.url zum Abrufen der nächsten Seite verwendet werden kann. 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, da die Anzahl der Ergebnisse deutlich größer als eine Seite wird. Eine genaue Gesamtzahl für eine Suche, die mit einer großen Anzahl von Ergebnissen übereinstimmt, kann nur durch wiederholtes Folgen von Paginierungslinks erhalten werden, bis die Ergebnisse erschöpft sind.

Die Ergebnisse können mit dem Parameter _sort sortiert werden, der eine durch Kommas getrennte Liste von Suchparameternamen in Prioritätsreihenfolge akzeptiert, optional mit dem Präfix -, um die absteigende Reihenfolge anzugeben. Beispiel:

_sort=status,-date,category

sortiert nach Status aufsteigend, Bindungen nach Datum absteigend und alle verbleibenden Bindungen nach Kategorie aufsteigend.

Hinweis: Ein FHIR-Speicher, der für die Verwendung der DSTU2-Version konfiguriert ist, verwendet eine andere _sort-Syntax, die in dieser Version der Spezifikation vorhanden war, wobei jede Instanz von _sort einen Suchparameter und einen optionalen Modifikator von :asc oder :desc verwendet. Verwenden Sie beispielsweise _sort=status&_sort:desc=date&_sort=category, um dieselbe Sortierreihenfolge wie im vorherigen Beispiel in DSTU2 zu erreichen:

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.

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 Resource 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: GET .../fhir?_id=1234 sucht statt GET .../fhir/Patient?_id=1234 in allen Ressourcen und nicht nur in "Patienten". Der spezielle Parameter _type kann mit diesem Anfragetyp verwendet werden, um die Ergebnisse auf eine durch Kommas getrennte Liste von Ressourcentypen zu beschränken. Beispiel:

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

gibt nur übereinstimmende Ergebnisse für die Ressourcen Observation und Condition zurück.

Datentypen

Jeder von FHIR definierte Suchparameter hat einen Datentyp, der einfache Typen wie String, Zahl und Datum sowie komplexe Typen wie Token, Referenz und Menge umfasst. Jeder Datentyp verfügt über eine eigene Syntax zur Angabe von Werten und unterstützt Modifikatoren, die die Art und Weise der Suche ändern.

Hier einige einfache Beispiele für die Verwendung von Datentypen:

• Number sucht nach Ganzzahl- oder Gleitkommawerten. Dem Wert kann ein Modifikator wie ne, lt, le, gt, ge vorangestellt werden, um den Komparator zu ändern, z. B. [parameter]=100 für Gleichheit, [parameter]=ge100 für größer oder gleich 100.
• Datum sucht nach beliebigen Datums-, Zeit- oder Zeitraumarten. Das Datumsparameterformat ist yyyy-mm-ddThh:mm:ss[Z|(+|-)hh:mm]. Hier gelten dieselben Präfixmodifikatoren wie für Zahlen.
• String verwendet standardmäßig eine Präfixsuche, die nicht zwischen Groß- und Kleinschreibung, Akzenten oder anderen diakritischen Zeichen unterscheidet.
• Token sucht nach einer genauen Stringübereinstimmung eines "Codes", die optional auf den URI eines "Systems" beschränkt ist und angibt, aus welchem Wertesatz der Code im Format [parameter]=[system]|[code] stammt. Zum Beispiel würde code=http://hl7.org/fhir/ValueSet/observation-codes|10738-3 einen Code mit 10738-3 aber nur dann erhalten, wenn er als Wert aus einem Codierungssystem mit dem angegebenen URI qualifiziert ist.
• Menge sucht nach einem numerischen Wert mit den gleichen Präfix-Modifikatoren wie Zahl, optional mit einem bestimmten System und Code, der die Einheiten des Werts im Format [parameter]=[prefix][number]|[system]|[code] angibt. value-quantity=lt9.1|http://unitsofmeasure.org|mg sucht beispielsweise nach Mengenwerten unter 9,1 mit dem angegebenen Einheitensystem und -code.
• Referenz sucht nach Verweisen zwischen Ressourcen, die bei Verweisen auf Ressourcen im FHIR-Speicher mit [parameter]=[id] oder [parameter]=[type]/[id] oder bei Verweisen durch URLs außerhalb des FHIR-Speichers mit [parameter]=[url] angegeben werden können.

Weitere Informationen zu zusätzlichen Datentypen, Wertesyntaxen und Modifikatoren finden Sie unter Erweiterte FHIR-Suchfunktionen.

Umgang mit Suchparametern

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

Die Antwort enthält einen Wert in Bundle.link mit dem Wert Bundle.link.relation = self und einem Bundle.link.url einer URL, die nur Parameter enthält, die erfolgreich auf die Suche angewendet wurden. Dieser Wert kann geprüft werden, um festzustellen, ob Parameter ignoriert wurden.

Wenn Sie alternativ den HTTP-Header Prefer: handling=strict für eine Suchanfrage festlegen, gibt der FHIR-Speicher einen Fehler bei einem nicht erkannten Parameter zurück.

Hinweis: Wenn Sie die FHIR-Speicheroption defaultSearchHandlingStrict einstellen, wird diese Standardeinstellung in strict für alle Suchanfragen geändert, es sei denn, eine einzelne Anfrage verwendet den HTTP-Header Prefer: handling=lenient um "nachsichtig" auszuwählen.