Abfragen von Daten, die durch differentielle Privatsphäre geschützt sind

Dieses Anleitung hilft dem Analysten, Abfragen gegen Daten durchzuführen, die durch differentielle Privatsphäre geschützt sind (d. h. datenschutzgeschützte Tabellen und Ansichten), und die von den Abfragen zurückgegebenen Ergebnisse zu verstehen und anzupassen.

Um eine Abfrage auf eine datenschutzgeschützte Tabelle auszuführen, muss ein Benutzer die SELECT-Berechtigung für die Tabelle haben.

Einschränkungen

  • Differential Privacy (differentielle Privatsphäre) unterstützt eine Teilmenge der Datentypen, Operatoren, Abfragesyntax und Funktionen von Snowflake. Eine Auflistung der unterstützten SQL, die Sie in einer Abfrage verwenden können, finden Sie unter SQL-Referenz für Differential Privacy (differentielle Privatsphäre).

  • Abfragen auf datenschutzgeschützte Tabellen dauern länger, weil Snowflake zusätzliche Berechnungen durchführen muss, um zu bestimmen, wie viel Rauschen hinzugefügt werden soll. Bei einfachen Abfragen beträgt diese Latenzzeit mindestens 7 Sekunden. Komplexe Abfragen, wie die folgende, können viel länger dauern:

    • Abfragen mit vielen Verknüpfungen und Unterabfragen

    • Abfragen, die mehrere Zeilen im Ergebnis ausgeben, z. B. bei Verwendung von GROUP BY-Klauseln, die zu Hunderten oder Tausenden von Gruppen führen.

Abfragegrundlagen

In diesem Abschnitt werden die grundlegenden Komponenten einer Abfrage erläutert, die erfolgreich ist, wenn sie auf eine datenschutzgeschützte Tabelle ausgeführt wird. Der Abschnitt umfasst folgende Themen:

Aggregieren von Daten

Alle Abfragen auf eine datenschutzgeschützte Tabelle müssen die Ergebnisse aggregieren, anstatt einzelne Datensätze abzurufen. Nicht jeder Teil einer Abfrage muss eine Aggregatfunktion verwenden, solange das Endergebnis aggregiert ist.

Mit Ausnahme der Funktion COUNT kann eine Abfrage eine Spalte nur dann aggregieren, wenn die Spalte einen Datenschutzbereich hat.

Eine Auflistung der unterstützten Aggregationen finden Sie unter Aggregatfunktionen.

Verwenden von Verknüpfungen

Die folgenden Abschnitte enthalten Richtlinien für die Verwendung von Verknüpfungen in einer Abfrage, die Differential Privacy (differentieller Privatsphäre) unterliegt:

Informationen über die Auswirkungen des Verknüpfens von zwei datenschutzgeschützten Tabellen auf die Datenschutzbereiche finden Sie unter Datenschutzbereiche und Verknüpfungen.

Join-Operatoren

Jeder Join muss ein Equi Join sein, der einen einzelnen Operator verwendet. Zum Beispiel wird t1.c1 == t2.c1 unterstützt, col1 > col2 und col1 + 10 = col2 jedoch nicht. Unbedingte Verknüpfungen werden nicht unterstützt.

Verknüpfungen müssen den Operator JOIN verwenden. Die WHERE-Syntax für Verknüpfungen wird nicht unterstützt. Weitere Informationen zur Verknüpfungssyntax finden Sie unter Implementierung von Verknüpfungen.

Unterstützte Verknüpfungen

Joins in einer Abfrage, die Differential Privacy (differentieller Privatsphäre) unterliegt, müssen eine der folgenden sein:

  • INNER

  • { LEFT | RIGHT | FULL } OUTER

  • NATURAL

Beide Seiten der Verknüpfung müssen dasselbe Muster für die Abfrage haben. Zum Beispiel werden die folgenden Verknüpfungen unterstützt:

Beide Seiten sind Bezeichner

SELECT COUNT(*)
FROM t1 INNER JOIN t2 ON t1.a=t2.a;
Copy

Beide Seiten sind Unterabfragen

SELECT COUNT(*)
FROM (SELECT a, SUM(b) FROM t1 GROUP BY a) AS g1
    INNER JOIN (SELECT * FROM t2) AS g2
    ON g1.a=g2.a;
Copy

Die Verknüpfung eines Bezeichners mit einer Unterabfrage wird derzeit nicht unterstützt.

Informationen über die unterstützte Abfragesyntax in Bezug auf Joins finden Sie unter Abfragesyntax.

Entitätsschlüssel in Verknüpfungen verwenden

Wenn Sie mit Tabellen arbeiten, die mit Datenschutz auf Entitätsebene geschützt sind, können Sie die Menge an Rauschen minimieren, indem Sie die Spalte mit dem Entitätsschlüssel als Teil des Verknüpfungsschlüssels einbeziehen, insbesondere wenn dies die Abfrage semantisch nicht verändert.

Betrachten Sie zum Beispiel die folgenden Tabellen, bei denen die Entität Kunden ist:

Tabelle

Beschreibung

customers

Kundenverzeichnis, wobei jede Zeile ein Kunde ist und eine customer_id hat.

transactions

Kundentransaktionen, wobei jeder Kunde mehrere Transaktionen haben kann.

transaction_lines

Eindeutige Element, die in einer Transaktion gekauft wurden. Es kann mehrere Zeilen in einer Transaktion geben.

Wenn der Datenanbieter die bewährten befolgt, hat er die Daten so strukturiert, dass jede dieser Tabellen den Entitätsschlüssel customer_id enthält. Bei diesem Schema kann jede Zeile einer Transaktion nur zu einer Transaktion und jede Transaktion nur zu einem Kunden gehören. Diese Beziehung ist aus den Daten selbst nicht ersichtlich, sodass ohne zusätzliche Informationen die Menge an Rauschen, die für die differentielle Privatsphäre hinzugefügt wird, höher ist als nötig.

Sie können die Menge an Rauschens minimieren, indem Sie den Entitätsschlüssel customer_id als Teil des Verknüpfungsschlüssels einbeziehen, auch wenn dies redundant ist. Wenn Sie beispielsweise die Tabelle transactions mit transaction_lines verknüpfen, benötigen Sie in der Regel nur den Verknüpfungsschlüssel transaction_id. Das Verknüpfen sowohl über die transaction_id als auch die customer_id reduziert jedoch die Menge an Rauschen.

Datentypen und Datenschutzbereiche

Wenn Sie zwei Tabellen verknüpfen, müssen die Datentypen der Spalten des Verknüpfungsschlüssels auf beiden Seiten gleich sein. Für die Differential Privacy (differentielle Privatsphäre) beinhaltet der Datentyp einer Spalte, ob sie einen Datenschutzbereich hat oder nicht.

Wenn Sie z. B. eine datenschutzgeschützte Tabelle transactions und eine ungeschützte Tabelle product_lookup haben und diese über product_id verknüpfen möchten, muss die Spalte product_id in beiden Tabellen vom gleichen Datentyp sein (z. B. eine Zeichenfolge) und beide müssen einen Datenschutzbereich haben.

Um diese Anforderung zu erfüllen, muss der Administrator für den Analysten möglicherweise einen Datenschutzbereich definieren, genau wie der Datenanbieter sie definiert. Wie Sie einen Datenschutzbereiche für eine Tabelle festlegen, erfahren Sie unter Festlegen eines Datenschutzbereichs.

Eindeutigkeitsanforderungen

Verknüpfungen können potenziell Datenzeilen duplizieren, was dazu führen kann, dass einem Abfrageergebnis unendlich viel Rauschen hinzugefügt wird. Um sicherzustellen, dass datenschutzgeschützte Daten bei einer Verknüpfung nicht doppelt vorhanden sind, darf der Verknüpfungsschlüssel (d. h. die Spalten, über die die Tabellen verknüpft werden) für datenschutzgeschützte Tabellen nur einem Datensatz in der anderen Tabelle entsprechen. Das bedeutet, dass bei der Verknüpfung mit einer datenschutzgeschützten Tabelle der Verknüpfungsschlüssel auf der gegenüberliegenden Seite dedupliziert werden muss.

Wichtig

Die Anforderung der Eindeutigkeit von Verknüpfungen gilt nicht immer für Abfragen auf Tabellen, die durch Datenschutz auf Entitätsebene geschützt sind. Um den Datenschutz auf Entitätsebene zu gewährleisten, müssen Abfragen vor der Aggregation den Entitätsschlüssel deduplizieren. Solange dies nach einer Verknüpfung, aber vor der Aggregation geschieht, muss die Verknüpfung nicht auf deduplizierten Daten erfolgen. Weitere Informationen zur Erfüllung dieser Anforderungen finden Sie unter Abfrage von Daten, die durch Datenschutz auf Entitätsebene geschützt sind.

Um die Anforderung der Eindeutigkeit für Verknüpfungen zu erfüllen, kann die Abfrage ein GROUP BY auf einer Teilmenge der Verknüpfungsspalten verwenden, um doppelte Zeilen in einem Ergebnis zu gruppieren.

Nehmen wir zum Beispiel an, dass die Tabelle patients durch Differential Privacy (differentielle Privatsphäre) geschützt ist und die Tabelle geo_lookup nicht. Der Analyst möchte diese beiden Tabellen über zip_code verknüpfen, damit er die Tabelle patients nach State filtern kann. Um sicherzustellen, dass die Datensätze in der datenschutzgeschützten Tabelle patients nicht dupliziert werden, muss die Abfrage die Tabelle zip_code anhand des Verknüpfungsschlüssels deduplizieren. Dies muss explizit gemacht werden, auch wenn die Tabelle geo_lookup bereits eindeutig für zip_code ist. Dadurch wird sichergestellt, dass Snowflake den Datenschutz korrekt berücksichtigen kann.

SELECT COUNT(*)
  FROM patients
  LEFT JOIN (SELECT zip_code, ANY_VALUE(state) AS residence_state
            FROM geo_lookup
            GROUP BY zip_code)
  USING zip_code
  WHERE birth_state = residence_state;
Copy

Abfrage von Daten, die durch Datenschutz auf Entitätsebene geschützt sind

Die meisten Datenanbieter verwenden einen Schlüssel für Entitäten, um bei der Konfiguration des differenzierten Datenschutzes den Datenschutz auf Entitätsebene zu implementieren <label-diff_privacy_admin_entity_privacy>. Wenn eine Tabelle durch Datenschutz auf Entitätsebene geschützt ist, lässt Snowflake keine Aggregate für Felder zu, wenn es eine unbegrenzte Anzahl von Zeilen pro Entität geben könnte. Das bedeutet, dass Abfragen die folgenden Anforderungen erfüllen müssen:

  • An einem bestimmten Punkt der Abfrage muss die datenschutzgeschützte Tabelle auf dem Entitätsschlüssel dedupliziert werden. Operationen, die zur Deduplizierung von Daten verwendet werden können, sind:

    • COUNT( DISTINCT <entity_key_column> )

    • GROUP BY <entity_key_column>

    • UNION (aber nicht UNION ALL), wenn nur der Entitätsschlüssel projiziert wird.

  • Wenn ein Join einen anderen Verknüpfungsschlüssel als die Spalte mit dem Entitätsschlüssel verwendet, kann diese Verknüpfung nicht zwischen der Deduplizierung und der abschließenden SELECT-Klausel mit Aggregation stattfinden.

Bemerkung

Wenn der Datenanbieter den Datenschutz auf Zeilenebene implementiert hat, ist die Anforderung an die Deduplizierung für Verknüpfungen anders. Weitere Informationen zu diesen Anforderungen finden Sie unter Eindeutigkeitsanforderungen.

Um die Anforderungen an den Datenschutz auf Entitätsebene zu veranschaulichen, nehmen wir an, Sie haben eine datenschutzgeschützte Tabelle patients mit der Spalte patient_id für den Entitätsschlüssel. Sie haben auch die nicht-sensible, ungeschützte Tabelle geo_lookup. Die folgenden Beispiele zeigen eine Abfrage, die fehlschlägt, gefolgt von einer neu geschriebenen Version, die erfolgreich ist.

Beispiel: Deduplizierung

Die folgende Abfrage schlägt fehl, weil sie die Anforderungen an die Deduplizierung nicht erfüllt. Auch wenn die Tabelle patients auf patient_id bereits eindeutig ist, schlägt die Abfrage fehl, da sie nicht explizit dedupliziert.

SELECT COUNT(*)
  FROM patients
  WHERE insurance_type = 'Commercial';
Copy

Um die Abfrage so umzuschreiben, dass sie erfolgreich ist, fügen Sie eine eindeutige Zählung für die Spalte mit dem Entitätsschlüsse ein, um eine explizite Deduplizierung des Entitätsschlüssels zu erreichen. Beispiel:

SELECT COUNT(DISTINCT patient_id)
  FROM patients
  WHERE insurance_type = 'Commercial';
Copy
Beispiel: Speicherort der Verknüpfung

Die folgende Abfrage schlägt fehl, obwohl sie eine GROUP BY-Klausel verwendet, um die Anforderung der Deduplizierung zu erfüllen.- Sie schlägt fehl, weil die Tabelle mit einer anderen Tabelle verknüpft wird, die eine Spalte verwendet, die nicht die Entitätsschlüsselspalte ist.

SELECT AVG(bmi)
  FROM (SELECT patient_id, ANY_VALUE(zip_code) AS zip_code
    FROM patients
    GROUP BY patient_id) AS p
  JOIN geo_lookup AS g
    ON p.zip_code = g.zip_code
  WHERE state='CA';
Copy

Um die Abfrage so umzuschreiben, dass sie erfolgreich ist, verwenden Sie die GROUP BY-Klausel nach der Verknüpfung. Die Verknüpfung kann nicht zwischen der Deduplizierung und der SELECT-Klausel mit Aggregation stattfinden.

SELECT AVG(bmi)
  FROM (SELECT patient_id, ANY_VALUE(bmi) as bmi, ANY_VALUE(state) as state
      FROM patients AS p
      JOIN geo_lookup AS g
        ON p.zip_code = g.zip_code
      GROUP BY patient_id)
  WHERE state='CA';
Copy

Ausführen von Abfragen auf Transaktionsebene

Die Anforderung der Deduplizierung für die differentielle Privatsphäre auf Entitätsebene hindert Sie nicht daran, Abfragen auf Transaktionsebene auszuführen. Sie müssen die Daten jedoch zunächst auf Entitätseben gruppieren und dann über diese Gruppen aggregieren.

Nehmen wir zum Beispiel an, Sie haben eine Tabelle doctor_visits und der Datenanbieter hat einen Entitätsschlüssel patient_id definiert, um den Datenschutz auf Entitätsebene zu implementieren. Eine Abfrage auf Transaktionsebene könnte lauten: „Wie viele Arztbesuche waren keine regulären Kontrolluntersuchungen?“ Im Folgenden finden Sie ein Beispiel für eine solche Abfrage:

SELECT SUM(num_visits)
  FROM (SELECT SUM((visit_reason<>'Regular checkup')::INT) AS num_visits
        WHERE visit_reason IS NOT NULL
        GROUP BY patient_id)
  WHERE num_visits > 0 AND num_visits < 20;
Copy

Die Unterabfrage wird nach patient_id gruppiert, um die Daten zu deduplizieren. Die Aggregatspalte num_visits erfasst die Anzahl der Besuche pro Patient, die nicht im Rahmen einer regulären Untersuchung erfolgten. Die Abfrage aggregiert dann wieder auf dieser Spalte pro Patient, um die Gesamtzahl der Besuche zu erhalten. Beachten Sie, dass die WHERE-Klausel in der äußeren Abfrage erforderlich ist, um einen Datenschutzbereich für die Daten anzugeben.

Bemerkung

Es ist zwar keine Anforderung, aber eine bewährte Methode, wenn Sie Tabellen verknüpfen, die durch differentielle Privatsphäre auf Entitätsebene geschützt sind, die Spalte mit dem Entitätsschlüssel als Teil des Verknüpfungsschlüssels einzubeziehen (wenn es die Abfrage semantisch nicht verändert). Weitere Informationen dazu finden Sie unter Entitätsschlüssel in Verknüpfungen verwenden.

Abfrageergebnisse verstehen

Abfragen auf eine datengeschützte Tabelle geben nicht den genauen Wert einer Aggregation zurück. Differential Privacy (differentielle Privatsphäre) fügt Rauschen in das Ergebnis ein, sodass es eine Annäherung an den tatsächlichen Wert wird. Der zurückgegebene Wert weicht so weit vom tatsächlichen Wert ab, dass nicht ersichtlich ist, ob die Daten einer Person in der Aggregation enthalten sind. Dies gilt für alle Abfragen mit Ausnahme einer Abfrage, die die Gesamtzahl der Zeilen in der datenschutzrechtlich geschützten Tabelle zurückgibt, zum Beispiel SELECT COUNT(*) FROM t.

Ein Analyst muss in der Lage sein, festzustellen, ob das in das Ergebnis eingebrachte Rauschen die Nützlichkeit der Abfrage verringert hat. Snowflake verwendet ein Rauschintervall, um Analysten bei der Interpretation der Ergebnisse zu helfen. Ein Rauschintervall ist ein geschlossenes mathematisches Intervall, das in den meisten Fällen den tatsächlichen Wert der Aggregation umfasst. Die Wahrscheinlichkeit, dass das tatsächliche Ergebnis einer Abfrage innerhalb des Rauschintervalls liegt, beträgt 95 %.

Durch Hinzufügen der folgenden Funktionen zu einer Abfrage kann der Analyst das Rauschintervall nutzen, um Entscheidungen über den Nutzen einer Abfrage zu treffen:

  • DP_INTERVAL_LOW — Gibt die untere Grenze des Rauschintervalls zurück. Der tatsächliche Wert wird höchstwahrscheinlich gleich oder größer als diese Zahl sein.

  • DP_INTERVAL_HIGH — Gibt die obere Grenze des Rauschintervalls zurück. Der tatsächliche Wert wird höchstwahrscheinlich gleich oder kleiner als diese Zahl sein.

Um diese Funktionen zu verwenden, geben Sie den Alias einer aggregierten Spalte in der Hauptabfrage an. Die folgende Abfrage gibt zum Beispiel die Summe der Spalte num_claims zusammen mit dem Rauschintervall für diese Aggregation zurück:

SELECT SUM(num_claims) AS sum_claims,
      DP_INTERVAL_LOW(sum_claims),
      DP_INTERVAL_HIGH(sum_claims)
  FROM t1;
Copy

Die Ausgabe könnte so aussehen:

+--------------+--------------------------------+----------------------------------+
|  sum_claims  |  dp_interval_low("sum_claims") |  dp_interval_high("sum_claims")  |
|--------------+--------------------------------+----------------------------------+
|  50          |  35                            |    75                            |
+--------------+--------------------------------+----------------------------------+

In diesem Fall ist der Rückgabewert eine Summe von 50. Aber der Analyst hat auch mit 95%iger Sicherheit festgestellt, dass der tatsächliche Wert der Aggregation zwischen 35 und 75 liegt.

Tipp

Für Informationen über Techniken, die das Rauschen in den Ergebnissen reduzieren können, lesen Sie

Änderungsverfolgung der Ausgaben aus dem Datenschutzbudget

Sie können die Funktion ESTIMATE_REMAINING_DP_AGGREGATES verwenden, um abzuschätzen, wie viele Abfragen Sie innerhalb des aktuellen Budgetfensters noch durchführen können (d. h. bis der kumulative Datenschutzverlust auf 0 zurückgesetzt wird). Die Schätzung basiert auf der Anzahl der Aggregate, nicht der Abfragen. Die Abfrage SELECT SUM(age), COUNT(age) FROM T enthält beispielsweise zwei Aggregatunktionen: SUM(age) und COUNT(age).

Achten Sie bei der Ausführung der Funktion ESTIMATE_REMAINING_DP_AGGREGATES darauf, dass Sie genau die Bedingungen verwenden, die Sie zur Ausführung von Abfragen verwenden, z. B. denselben Benutzer, dieselbe Rolle und dasselbe Konto.

Wenn Sie eine Abfrage durchführen, die mehrere Tabellen verwendet, sollten Sie ESTIMATE_REMAINING_DP_AGGREGATES einmal pro Tabelle ausführen und dann den niedrigsten NUMBER_OF_REMAINING_DP_AGGREGATES Wert als geschätzte Nutzungsobergrenze verwenden.

Das folgende Beispiel zeigt, wie sich eine Serie von Abfragen darauf auswirkt, wie viel der Beschränkung des Datenschutzbudgets verbraucht wurde (d. h. der kumulative Datenschutzverlust der Abfragen) und die geschätzte Anzahl der verbleibenden Aggregate.

1. Erste Überprüfung

Schauen wir uns die Zahlen zum Datenschutzbudget in der Tabelle my_table an. Sie haben noch nie eine Abfrage auf diese Tabelle durchgeführt.

SELECT * FROM TABLE(SNOWFLAKE.DATA_PRIVACY.ESTIMATE_REMAINING_DP_AGGREGATES('my_table'));
Copy

Bislang kein Budget verwendet:

+-----------------------------------+--------------+---------------+--------------+
| NUMBER_OF_REMAINING_DP_AGGREGATES | BUDGET_LIMIT | BUDGET_WINDOW | BUDGET_SPENT |
|-----------------------------------+--------------+---------------+--------------|
|                 996               |     233      |     WEEKLY    |     0.0      |
+-----------------------------------+--------------+---------------+--------------+

2. Eine Abfrage starten

Führen wir nun eine Abfrage mit einer aggregierten Funktion und überprüfen unsere Zahlen erneut:

SELECT SUM(salary) FROM my_table;

-- results omitted ...

SELECT * FROM TABLE(SNOWFLAKE.DATA_PRIVACY.ESTIMATE_REMAINING_DP_AGGREGATES('my_table'));
Copy

Die Schätzung der verbleibenden aggregierten Aufrufe hat sich um eins verringert, und der kumulative Datenschutzverlust (verbrauchtes Budget) ist gestiegen.

+-----------------------------------+--------------+---------------+--------------+
| NUMBER_OF_REMAINING_DP_AGGREGATES | BUDGET_LIMIT | BUDGET_WINDOW | BUDGET_SPENT |
|-----------------------------------+--------------+---------------+--------------|
|                 995               |     233      |     WEEKLY    |     0.6      |
+-----------------------------------+--------------+---------------+--------------+

3. Führen Sie eine weitere Abfrage mit zwei Aggregatfunktionen aus.

SELECT SUM(age), COUNT(age) FROM my_table GROUP BY STATE;

-- results omitted ...

SELECT * FROM TABLE(SNOWFLAKE.DATA_PRIVACY.ESTIMATE_REMAINING_DP_AGGREGATES('my_table'));
Copy

Die geschätzten verbleibenden Abfragen sind um zwei gesunken. Denken Sie daran, dass dies eine Schätzung ist.

+-----------------------------------+--------------+---------------+--------------+
| NUMBER_OF_REMAINING_DP_AGGREGATES | BUDGET_LIMIT | BUDGET_WINDOW | BUDGET_SPENT |
|-----------------------------------+--------------+---------------+--------------|
|                 993               |     233      |     WEEKLY    |     1.8      |
+-----------------------------------+--------------+---------------+--------------+

4. Eine Abfrage erneut ausführen

Lassen Sie uns eine frühere Abfrage wiederholen, um zu zeigen, dass das Datenschutzbudget immer belastet wird, selbst bei identischen Abfragen. Eine doppelte Abfrage verursacht bei jeder Ausführung den gleichen Datenschutzverlust (d. h. sie verbraucht den gleichen Betrag an Datenschutzbudget).

SELECT SUM(age), COUNT(age) FROM T GROUP BY STATE;

-- results omitted ...

SELECT * FROM TABLE(SNOWFLAKE.DATA_PRIVACY.ESTIMATE_REMAINING_DP_AGGREGATES('my_table'));
Copy

Gleiche Gebühr für die Abfrage wie zuvor: 1,2 Einheiten Datenschutzverlust.

+-----------------------------------+--------------+---------------+--------------+
| NUMBER_OF_REMAINING_DP_AGGREGATES | BUDGET_LIMIT | BUDGET_WINDOW | BUDGET_SPENT |
|-----------------------------------+--------------+---------------+--------------|
|                 991               |     233      |     WEEKLY    |     3.0      |
+-----------------------------------+--------------+---------------+--------------+