Nach FHIR-Ressourcen suchen

Auf dieser Seite wird gezeigt, wie Sie mit der Methode projects.locations.datasets.fhirStores.fhir.search nach Ressourcen in einem bestimmten FHIR-Speicher suchen. Sie können die Methode auf verschiedene Arten mit GET- oder POST-Anfragen aufrufen. Die FHIR-Suchspezifikation umfasst eine Vielzahl von Abfragefunktionen. 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.

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

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": "2018-01-01T00:00:00+00:00",
          "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": "2018-01-01T00:00:00+00:00",
          "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');
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

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

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": "2018-01-01T00:00:00+00:00",
          "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": "2018-01-01T00:00:00+00:00",
          "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');
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

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.

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.