Entwickler-Datenschutz
SQL-Debugging mit einer synthetischen Datenbank
Erstellen Sie den kleinsten erfundenen Datensatz, der die Beziehungen und Einschränkungen hinter dem SQL-Problem bewahrt. Beginnen Sie nicht damit, einen Produktions-Dump hochzuladen und einige Spalten zu maskieren. Das herunterladbare SQLite-Dataset reproduziert eine Join-Überzählung mit fiktiven Zeilen und verifizierten erwarteten Ergebnissen, sodass die Abfrage ohne Kundendaten diskutiert werden kann.
Für Entwickler, DBAs und Sicherheitstechnik
Bewahren Sie die Beziehung, die den Fehler verursacht, nicht die Originaldatensätze.
Vollständig synthetischer Datensatz. SQL-Ausgaben und zwei Einschränkungen offline verifiziert; kein KI- oder Endpunkt-Richtlinientest durchgeführt.01
Definieren Sie die relationale Fragestellung
Das Beispiel fragt, warum ein Kundengesamtergebnis zu hoch wird, wenn Versandkosten nach dem Verbinden von Bestellungen mit Positionen hinzugefügt werden. Wichtig ist eine Bestellung mit mehreren Positionen. Kundennamen, echte Preise und eine vollständige Produktionsdatenbank sind nicht notwendig, um diese Beziehung zu reproduzieren.
Schreiben Sie das erwartete Ergebnis, bevor Sie einen Assistenten bitten, die Abfrage zu erklären. Ein nützliches Dataset enthält einen Fall, der den Fehler zeigt, und einen, der ihn nicht zeigt. Das hilft, eine korrekte Korrektur von einer Abfrage zu unterscheiden, die nur zufällig plausible Zahlen für eine Zeile liefert.
02
Bewahren Sie Einschränkungen und erfinden Sie die Zeilen
Das Paket erstellt Kunden, Bestellungen und Bestellpositionen mit Primärschlüsseln, Fremdschlüsseln und Prüfungen auf nicht-negative Beträge und positive Mengen. Alle Bezeichnungen und Werte sind erfunden. Das Schema ist ein generisches Lehrbeispiel, nicht aus einer Firmendatenbank kopiert.
Beim Erstellen eines Datasets für Ihr eigenes Problem bewahren Sie nur die Beziehungen und Randfälle, die für die Fragestellung nötig sind. Prüfen Sie, ob Schemanamen, Kommentare oder Einschränkungen selbst proprietäre Informationen offenbaren. Das Ersetzen von Namen in kopierten Produktionszeilen ist nicht dasselbe wie das Erstellen eines synthetischen Datasets.
Quellkontext: SQLite: Unterstützung von Fremdschlüsseln · OAIC: Verwendung kommerziell verfügbarer KI-Produkte
03
Vergleichen Sie die korrekten und überzählenden Abfragen
Die absichtlich falsche Abfrage addiert die Versandkosten einer Bestellung einmal für jede verbundene Position. Der synthetische erste Kunde summiert daher 4.200 Cent statt 3.900. Der zweite Kunde hat eine Position, daher liefern beide Abfragen 2.700 Cent. Dieser Unterschied macht die Ursache ohne echte Kundendaten sichtbar.
Die korrekte Abfrage aggregiert Positionsbeträge pro Bestellung, addiert Versandkosten einmal und summiert dann nach Kunde. Die erwarteten CSV-Dateien enthalten Zählungen sowie Beträge, sodass die geänderte Aggregationsebene sichtbar ist. Dies sind lokal verifizierte SQL-Ergebnisse für das Dataset, keine Beobachtungen eines KI-Modells oder einer Aona-Steuerung.
| Synthetischer Kunde | Überzählende Abfrage | Korrekte Abfrage |
|---|---|---|
| 1: SYNTHETIC_ALPHA | 4.200 Cent; 3 verbundene Zeilen | 3,900 cents; 2 orders |
| 2: SYNTHETIC_BETA | 2.700 Cent; 1 verbundene Zeile | 2,700 cents; 1 order |
Quellkontext: SQLite: SELECT
04
Verifizieren Sie das Dataset offline
Der enthaltene Python-Verifizierer verwendet die Standardbibliothek sqlite3 und eine In-Memory-Datenbank. Er prüft die unveränderten SQL-Dateien per Hash, führt beide Abfragen aus und verifiziert, dass ungültige Fremdschlüssel- und Null-Mengen-Zeilen abgelehnt werden. Es wird keine Produktionsdatenbank geöffnet und keine Netzwerk- oder Provideraufrufe gemacht.
Das Dataset aktiviert die Fremdschlüsselprüfung explizit, da die SQLite-Dokumentation verlangt, diese Einstellung für eine Verbindung zu prüfen. Wenn Sie die SQL ändern, um einen anderen Fall zu untersuchen, halten Sie diese Arbeit getrennt und erstellen Sie neue erwartete Ergebnisse. Der bereitgestellte Verifizierer lehnt absichtlich modifizierte SQL ab, anstatt stillschweigend eine andere Übung zu validieren.
Quellkontext: SQLite: Unterstützung von Fremdschlüsseln
Setzen Sie es in die Praxis um
Synthetisches SQLite-Join-Debugging-Paket
Führen Sie ein echtes relationales Dataset aus und vergleichen Sie eine überzählende Abfrage mit verifizierten erwarteten Ergebnissen.
Vollständig synthetischer Datensatz. SQL-Ausgaben und zwei Einschränkungen offline verifiziert; kein KI- oder Endpunkt-Richtlinientest durchgeführt.
Bestellung 101
Zwei Artikel teilen sich eine Versandkostenpauschale
Der naive Join addiert die Versandkosten zweimal
Korrekte Ebene
Artikel pro Bestellung aggregieren, dann Gesamtbetrag pro Kunde
Erwarteter erster Gesamtbetrag: 3.900 Cent
Kontrollfall
Ein Artikel in Bestellung 201
Beide Abfragen liefern 2.700 Cent
| Check | Erwartetes Dataset-Ergebnis | Verifizierung |
|---|---|---|
| Korrekte Gesamtsummen | 3,900 und 2,700 cents | Lokal verifiziert |
| Überzählungsbeispiel | 4,200 und 2,700 cents | Lokal verifiziert |
| Verwaiste Bestellung | Fremdschlüssel-Ablehnung | Lokal verifiziert |
| Null Positionsmenge | Prüfbedingungs-Ablehnung | Lokal verifiziert |
Arbeiten Sie Ihre Bewertung durch
Nutze die Prüfungen, um die benötigten Beweise zu organisieren. Speichere deine Auswahl in Wordund füge dann deine Notizen und Beweise hinzu. Deine Auswahl bleibt in diesem Tab, bis du sie herunterlädst.
0 von 3 Rezension
Beispiele und Rezensionsmaterial
Lesen Sie die Details hier oder halten Sie die PDF, bearbeitbar Word Dokument und Tabellenkalkulationen zusammen.
Synthetic SQLite debugging fixtureLesen
All rows, labels und amounts are invented. No customer records, credentials, external connection strings or API calls are included.
Question: why does adding order shipping after a join overcount the first customer?
The optional verifier uses only Python’s standard sqlite3 module and an in-memory database. Run verify_fixture.py from this extracted pack to check the unchanged SQL, both expected query outputs and two constraints. It does not open an existing database or use a network. Changed SQL is rejected by hash.
Review fixture.sql, overcounting-query.sql and correct-query.sql with the expected CSV files. If you choose to share the example with an approved AI client, share only these synthetic files and the question. Treat a suggested query as something to validate locally, not a verified production fix.
Guide und sources
Canonical guide: https://aona.ai/resources/guides/database-fixtures-ai-debugging/ Source review: 2026-09-21
- SQLite: Foreign Key Support: https://www.sqlite.org/foreignkeys.html
- SQLite: SELECT: https://www.sqlite.org/lang_select.html
- OAIC: Use of commercially available AI products: https://www.oaic.gov.au/privacy/privacy-guidance-for-organisations-and-government-agencies/guidance-on-privacy-and-the-use-of-commercially-available-ai-products
Expected correctLesen
| Customer ID | Total cents | Order count |
|---|---|---|
| 1 | 3900 | 2 |
| 2 | 2700 | 1 |
Expected overcountingLesen
| Customer ID | Total cents | Joined row count |
|---|---|---|
| 1 | 4200 | 3 |
| 2 | 2700 | 1 |
Arbeitscode und Testdateien
Verwenden Sie die Originaldateien für die Code- und Datenübungen. Die Quell-ZIP enthält deren Anweisungen und Eingabedaten.
Quellbeispiele herunterladen (ZIP)FixtureSQL
-- Fully synthetic SQLite fixture. No real customer data or credentials.
PRAGMA foreign_keys = ON;
CREATE TABLE customers (
customer_id INTEGER PRIMARY KEY,
label TEXT NOT NULL CHECK (label LIKE 'SYNTHETIC_%')
);
CREATE TABLE orders (
order_id INTEGER PRIMARY KEY,
customer_id INTEGER NOT NULL REFERENCES customers(customer_id),
shipping_cents INTEGER NOT NULL CHECK (shipping_cents >= 0)
);
CREATE TABLE order_items (
item_id INTEGER PRIMARY KEY,
order_id INTEGER NOT NULL REFERENCES orders(order_id),
quantity INTEGER NOT NULL CHECK (quantity > 0),
unit_price_cents INTEGER NOT NULL CHECK (unit_price_cents >= 0)
);
INSERT INTO customers VALUES (1, 'SYNTHETIC_ALPHA'), (2, 'SYNTHETIC_BETA');
INSERT INTO orders VALUES (101, 1, 300), (102, 1, 500), (201, 2, 200);
INSERT INTO order_items VALUES (1001, 101, 2, 1000), (1002, 101, 1, 500), (1003, 102, 3, 200), (1004, 201, 1, 2500);
Korrekte AbfrageSQL
-- Aggregate items per order before adding each order's shipping once.
WITH per_order AS (
SELECT o.order_id, o.customer_id,
o.shipping_cents + COALESCE(SUM(i.quantity * i.unit_price_cents), 0) AS total_cents
FROM orders AS o
LEFT JOIN order_items AS i ON i.order_id = o.order_id
GROUP BY o.order_id, o.customer_id, o.shipping_cents
)
SELECT customer_id, SUM(total_cents) AS total_cents, COUNT(*) AS order_count
FROM per_order
GROUP BY customer_id
ORDER BY customer_id;
Überzählende AbfrageSQL
-- Intentionally wrong for this task: shipping is added once per joined item.
SELECT o.customer_id,
SUM(i.quantity * i.unit_price_cents + o.shipping_cents) AS total_cents,
COUNT(*) AS joined_row_count
FROM orders AS o
JOIN order_items AS i ON i.order_id = o.order_id
GROUP BY o.customer_id
ORDER BY o.customer_id;
Verify fixturePY
# Offline, in-memory SQLite verification of the unchanged synthetic pack.
import hashlib
import json
from pathlib import Path
import sqlite3
root = Path(__file__).parent
expected_hashes = {'fixture.sql': 'ea22bd66ff6182552a4c726dbba7a2634c5e49e0726ab2b471165a1bc1736250', 'correct-query.sql': 'bce555fad1354c7b3dde4a286bfdee0fe2ea9b98b93b229c06b23112f8cbf197', 'overcounting-query.sql': 'b5b71cb2aff59ee818442585c14410c3a538181064f92a6b14fb7bf90871d97f'}
texts = {}
for name, expected in expected_hashes.items():
text = (root / name).read_text()
if hashlib.sha256(text.encode()).hexdigest() != expected:
raise SystemExit("Refusing modified SQL: use the unchanged synthetic fixture.")
texts[name] = text
connection = sqlite3.connect(":memory:")
try:
connection.executescript(texts["fixture.sql"])
assert connection.execute("PRAGMA foreign_keys").fetchone()[0] == 1
correct_rows = connection.execute(texts["correct-query.sql"]).fetchall()
overcounting_rows = connection.execute(texts["overcounting-query.sql"]).fetchall()
assert correct_rows == [(1, 3900, 2), (2, 2700, 1)]
assert overcounting_rows == [(1, 4200, 3), (2, 2700, 1)]
rejected = []
for label, statement in [
("foreign_key", "INSERT INTO orders VALUES (999, 999, 0)"),
("positive_quantity", "INSERT INTO order_items VALUES (9999, 101, 0, 100)")
]:
try:
connection.execute(statement)
except sqlite3.IntegrityError:
rejected.append(label)
else:
raise AssertionError("Expected constraint rejection: " + label)
print(json.dumps({"fixture": "D18 synthetic only", "sqlite_version": sqlite3.sqlite_version,
"correct_rows": correct_rows, "overcounting_rows": overcounting_rows,
"constraints_rejected": rejected, "database": "in-memory", "network_calls": 0}))
finally:
connection.close()
Bevor du weitermachst
Halte diese Unterscheidungen klar
- Maskierung eines Produktions-Dumps und Bezeichnung als synthetisch
- Erfinden Sie die Zeilen und bewahren Sie nur die Beziehung auf, die zur Reproduktion des Problems nötig ist.
- Nur eine plausible Summe prüfen
- Beziehen Sie einen Fall ein, der den Fehler aufdeckt, einen Kontrollfall und die Aggregationszählungen oder Einschränkungen, die ihn erklären.
Wenden Sie sie auf die KI-Nutzung durch Mitarbeiter an
Bring deinen tatsächlichen Datenpfad mit.
Aona kann bei der Bewertung unterstützter Mitarbeiter-Prompt- oder Dateieinreichungen für Programmieraufgaben helfen.
Aona bietet keine Datenbank-Zeilenberechtigungen und garantiert keine Inspektion jeder Abfrage, jedes Dumps oder MCP-Ergebnisses. Dieses Fixture testet SQL lokal, nicht eine Aona-Richtlinie.
Verwenden Sie das synthetische Schema und die Abfrage in einer begrenzten Demonstration des unterstützten Einreichungswegs, wobei jede reale Datenbank außerhalb der Übung bleibt.
Überprüfe deinen AnwendungsfallFAQ
Fragen zu dieser Entscheidung
Ist das Fixture mit echtem SQLite kompatibel?
Verbindet sich der Verifizierer mit einer bestehenden Datenbank?
Kann ich ein Produktionsschema mit gefälschten Zeilen verwenden?
Beweisen die verifizierten SQL-Ausgaben, dass eine KI-generierte Korrektur sicher ist?
Beweise hinter dem Leitfaden
Quellen und Umfang
Erstellt von Aona. Quellen überprüft 2026-09-21. Das zitierte Material unterstützt die unten genannten Punkte; es zertifiziert kein Produkt oder Ihren Anwendungsfall.
- SQLite: Unterstützung von Fremdschlüsseln
Dokumentiert Fremdschlüsselbeziehungen und die Aktivierung der Durchsetzung für eine Verbindung.
vendor · geprüft 2026-09-21 - SQLite: SELECT
Dokumentiert Joins, Gruppierungen und Abfrageauswertung, die im Fixture verwendet werden.
vendor · geprüft 2026-09-21 - OAIC: Verwendung kommerziell verfügbarer KI-Produkte
Erklärt Datenschutzüberlegungen für persönliche Informationen, die an KI übermittelt werden.
regulator · geprüft 2026-09-21