Protection des données pour développeurs
Déboguer SQL avec une base de données synthétique
Construisez le plus petit jeu de données inventé qui préserve les relations et contraintes derrière le problème SQL. Ne commencez pas par télécharger un dump de production et masquer quelques colonnes. Le fixture SQLite téléchargeable reproduit un surcompte de jointure avec des lignes fictives et une sortie attendue vérifiée, permettant de discuter la requête sans données client.
Pour Développeurs, DBA et ingénierie sécurité
Préservez la relation qui cause le bug, pas les enregistrements originaux.
Jeu de données entièrement synthétique. Sorties SQL et deux contraintes vérifiées hors ligne ; aucun test IA ou politique de point de terminaison effectué.01
Définissez la question relationnelle
L’exemple demande pourquoi un total client devient trop élevé quand les frais de port sont ajoutés après la jointure des commandes aux lignes d’articles. La caractéristique importante est une commande avec plusieurs articles. Les noms clients, prix réels et base de données complète de production ne sont pas nécessaires pour reproduire cette relation.
Rédigez le résultat attendu avant de demander à un assistant d’expliquer la requête. Un fixture utile inclut un cas exposant l’erreur et un autre qui ne l’expose pas. Cela aide à distinguer une correction correcte d’une requête qui retourne simplement des chiffres plausibles pour une ligne.
02
Préservez les contraintes et inventez les lignes
Le pack crée clients, commandes et order_items avec clés primaires, clés étrangères et vérifications pour montants non négatifs et quantités positives. Toutes les étiquettes et valeurs sont inventées. Le schéma est un exemple pédagogique générique, non copié d’une base de données d’entreprise.
Lors de la création d’un fixture pour votre propre problème, conservez uniquement les relations et cas limites nécessaires à la question. Vérifiez si les noms de schéma, commentaires ou contraintes divulguent des informations propriétaires. Remplacer les noms dans des lignes de production copiées n’est pas équivalent à construire un fixture synthétique.
Contexte source : SQLite : Support des clés étrangères · OAIC : Utilisation de produits IA commerciaux
03
Comparer les requêtes correcte et surcomptée
La requête intentionnellement incorrecte ajoute les frais de livraison d’une commande une fois par article joint. Le premier client synthétique totalise donc 4 200 centimes au lieu de 3 900. Le second client a un article, donc les deux requêtes retournent 2 700 centimes. Cette différence rend la cause observable sans données réelles de client.
La requête correcte agrège les montants des articles par commande, ajoute les frais de livraison une fois, puis totalise par client. Les fichiers CSV attendus incluent les comptes ainsi que les montants pour rendre visible le changement de niveau d’agrégation. Ce sont des résultats SQL vérifiés localement pour le fixture, pas des observations d’un modèle IA ou d’un contrôle Aona.
| Client synthétique | Requête surcomptée | Requête correcte |
|---|---|---|
| 1: SYNTHETIC_ALPHA | 4 200 centimes ; 3 lignes jointes | 3,900 cents; 2 orders |
| 2: SYNTHETIC_BETA | 2 700 centimes ; 1 ligne jointe | 2,700 cents; 1 order |
Contexte source : SQLite: SELECT
04
Vérifier le fixture hors ligne
Le vérificateur Python inclus utilise la bibliothèque standard sqlite3 et une base de données en mémoire. Il vérifie les fichiers SQL inchangés par hash, exécute les deux requêtes et confirme que les lignes avec clés étrangères invalides et quantités nulles sont rejetées. Il n’ouvre aucune base de données de production ni n’effectue d’appels réseau ou fournisseur.
Le fixture active explicitement l’application des clés étrangères, comme l’exige la documentation SQLite pour une connexion. Si vous modifiez le SQL pour explorer un autre cas, gardez ce travail séparé et créez de nouveaux résultats attendus. Le vérificateur fourni refuse délibérément le SQL modifié plutôt que de valider silencieusement un exercice différent.
Contexte source : SQLite : Support des clés étrangères
Mettez-le en pratique
Pack de débogage de jointure SQLite synthétique
Exécutez un fixture relationnel réel et comparez une requête surcomptée avec les résultats attendus vérifiés.
Jeu de données entièrement synthétique. Sorties SQL et deux contraintes vérifiées hors ligne ; aucun test IA ou politique de point de terminaison effectué.
Commande 101
Deux articles partagent un seul frais de livraison
La jointure naïve ajoute les frais deux fois
Niveau correct
Agréger les articles par commande, puis totaliser par client
Premier total attendu : 3 900 centimes
Cas témoin
Un article sur la commande 201
Les deux requêtes retournent 2 700 centimes
| Vérifier | Résultat attendu du fixture | Vérification |
|---|---|---|
| Totaux corrects | 3,900 et 2,700 cents | Vérifié localement |
| Exemple de surcomptage | 4,200 et 2,700 cents | Vérifié localement |
| Commande orpheline | Rejet de clé étrangère | Vérifié localement |
| Quantité d’article nulle | Rejet de contrainte de vérification | Vérifié localement |
Travaillez votre révision
Utilisez les vérifications pour organiser les preuves dont vous avez besoin. Enregistrez vos sélections dans Word, puis ajoutez vos notes et preuves. Vos sélections restent dans cet onglet jusqu'à leur téléchargement.
0 sur 3 révisé
Exemples et matériel de révision
Lisez les détails ici, ou conservez ensemble le PDF, le document Word modifiable et les feuilles de calcul.
Synthetic SQLite debugging fixtureLire
All rows, labels et 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 et 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 correctLire
| Customer ID | Total cents | Order count |
|---|---|---|
| 1 | 3900 | 2 |
| 2 | 2700 | 1 |
Expected overcountingLire
| Customer ID | Total cents | Joined row count |
|---|---|---|
| 1 | 4200 | 3 |
| 2 | 2700 | 1 |
Code fonctionnel et fichiers de test
Utilisez les fichiers originaux pour les exercices de code et de données. Le ZIP source inclut leurs instructions et données d'entrée.
Télécharger les exemples source (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);
Requête correcteSQL
-- 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;
Requête surcomptéeSQL
-- 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()
Avant de continuer
Gardez ces distinctions claires
- Masquer un dump de production et l’appeler synthétique
- Inventez les lignes et conservez uniquement la relation nécessaire pour reproduire le problème.
- Vérifier uniquement un total plausible
- Inclure un cas qui expose l’erreur, un cas témoin et les comptes d’agrégation ou contraintes qui l’expliquent.
Appliquez-le à l'utilisation de l'IA par les employés
Apportez votre chemin de données réel.
Aona peut aider à évaluer les soumissions de prompts ou fichiers employés supportés pour une question de codage.
Aona ne fournit pas de permissions sur les lignes de base de données ni ne garantit l’inspection de chaque requête, dump ou résultat MCP. Ce fixture teste le SQL localement, pas une politique Aona.
Utilisez le schéma et la requête synthétiques dans une démonstration ciblée du chemin de soumission supporté, en gardant toute base réelle hors de l’exercice.
Révisez votre cas d'utilisationFAQ
Questions pour cette décision
Le fixture est-il compatible avec SQLite réel ?
Le vérificateur se connecte-t-il à une base existante ?
Puis-je utiliser un schéma de production avec des lignes factices ?
Les sorties SQL vérifiées prouvent-elles qu’une correction générée par IA est sûre ?
Preuves à l'appui du guide
Sources et portée
Préparé par Aona. Sources vérifiées 2026-09-21. Le matériel cité soutient les points spécifiques ci-dessous ; il ne certifie pas un produit ni votre cas d'usage.
- SQLite : Support des clés étrangères
Documente les relations de clés étrangères et l’activation de leur application pour une connexion.
vendor · vérifié 2026-09-21 - SQLite: SELECT
Documente les jointures, regroupements et évaluation des requêtes utilisés dans le fixture.
vendor · vérifié 2026-09-21 - OAIC : Utilisation de produits IA commerciaux
Explique les considérations de confidentialité pour les informations personnelles fournies à l’IA.
regulator · vérifié 2026-09-21