Créez une clause WHERE SQL paramétrée depuis des filtres
Transformez des filtres de recherche en clause WHERE sûre : statut active, âge d’au moins 21 et rôle admin ou editor deviennent des noms de colonne entre guillemets avec des marqueurs numérotés, et les valeurs active, 21, admin et editor restent dans une liste à part. Gratuit dans votre navigateur.
- Gratuit
- Fonctionne dans votre navigateur
- Sans inscription
- Vos données restent sur votre appareil
Lancer gratuitement
Tout se passe dans votre navigateur : gratuit, sans envoi de vos données.
Transformez une liste structurée de filtres applicatifs en deux éléments attendus par un client de base de données : une clause WHERE SQL dotée de paramètres positionnels et un tableau séparé de valeurs ordonnées. Chaque nom de champ est délimité comme identifiant SQL, segment par segment pour les noms qualifiés, tandis que les valeurs restent hors du texte SQL. Les filtres conservent leur ordre initial et sont reliés par AND.
Construisez la structure SQL sans concaténer les valeurs
Les écrans de recherche dynamique partent souvent d’enregistrements d’apparence anodine : un champ, un opérateur et une valeur. Le danger apparaît lorsque ces données deviennent du SQL par insertion directe de la valeur dans une chaîne. Ce générateur sépare la structure et les données.
Intégrez la clause à une instruction SELECT, UPDATE ou DELETE plus large, puis transmettez params à un pilote compatible. Le générateur n’exécute aucune requête, ne se connecte à aucune base, n’inspecte aucun schéma et ne décide pas quelles colonnes l’appelant peut utiliser. Votre application doit conserver une liste d’autorisation si les utilisateurs influencent les champs.
La délimitation empêche la ponctuation et les mots réservés de casser la syntaxe, mais l’autorisation reste du ressort de l’application. Les filtres étant reliés par AND dans l’ordre reçu, la sortie reste stable et facile à journaliser, comparer ou combiner à un préfixe de requête fixe.
Maîtrisez les opérateurs, paramètres et tests de nullité
Les opérateurs pris en charge couvrent l’égalité, l’inégalité, les comparaisons d’ordre, LIKE, NOT LIKE, IN, NOT IN, IS NULL et IS NOT NULL. Le texte de l’opérateur passe en majuscules et les espaces répétés sont réduits : une saisie comme « not like » produit donc un SQL canonique. Chaque comparaison ordinaire consomme un paramètre.
IN et NOT IN exigent un tableau non vide et le développent en un paramètre par élément tout en préservant l’ordre. Les tests de nullité ne consomment aucun paramètre et ne nécessitent aucune valeur, car leur grammaire SQL ne contient pas de marqueur. Toute valeur manquante pour un autre opérateur est refusée plutôt que de produire un SQL incomplet.
La sortie emploie volontairement des paramètres numérotés précédés d’un dollar, adaptés à PostgreSQL et aux bibliothèques compatibles. Si votre pilote utilise des points d’interrogation ou des noms, adaptez la syntaxe sans modifier l’ordre des valeurs renvoyées.
Délimitez les identifiants et validez la politique applicative
Chaque champ est considéré comme un identifiant éventuellement qualifié. Les noms vides et les segments vides entre deux points sont refusés. Ce traitement empêche de confondre un champ avec de la syntaxe SQL non délimitée, sans prétendre que tous les moteurs suivent exactement les mêmes conventions.
Vérifiez la compatibilité avec votre base cible, surtout si elle n’emploie pas les guillemets doubles pour les identifiants. Par ailleurs, l’échappement n’accorde aucun droit. Si un appelant externe choisit les champs, associez les clés publiques à un ensemble explicite de colonnes avant d’appeler le générateur.
Tout opérateur SQL inconnu déclenche une erreur de saisie claire. Cette capacité est déterministe, n’effectue aucune requête réseau et renvoie uniquement la clause et ses paramètres.
Cas d’usage
Construire une requête de rapport interne
Transformez les lignes d’un générateur de rapports en prédicats AND sans insérer les valeurs dans le SQL.
Produire des requêtes de dépôt testables
Capturez séparément la clause déterministe et le tableau des paramètres lors des tests de la couche de données.
Questions fréquentes
Quel est le tarif ?
L’exécuteur du navigateur est disponible pour un usage interactif.
Cet outil exécute-t-il le SQL ?
Non. Il renvoie seulement une clause WHERE et un tableau params ordonné ; votre application les transmet au pilote.
Puis-je utiliser IN et NOT IN ?
Oui. Fournissez un tableau non vide comme valeur ; le générateur crée un paramètre pour chaque élément.
Comment les tests de nullité sont-ils représentés ?
Utilisez IS NULL ou IS NOT NULL. Ces opérateurs ne demandent aucune valeur et n’ajoutent rien à params.
L’échappement remplace-t-il une liste de colonnes autorisées ?
Non. L’échappement protège la syntaxe ; la liste détermine les colonnes et noms qualifiés accessibles à l’appelant.
Comment les contrôles de valeur vide comme IS NULL sont-ils gérés ?
IS NULL et IS NOT NULL n’ont besoin d’aucune valeur ni d’aucun marqueur, car leur formulation SQL n’a rien à remplir. Toute autre comparaison prend exactement une valeur, et une valeur manquante est refusée au lieu de produire du SQL incomplet.
Outils associés
Pour les développeurs — accès API
Tout sur cette page est disponible par programmation. Cette section s'adresse aux équipes qui veulent l'intégrer à leurs systèmes ; les autres peuvent simplement utiliser l'outil ci-dessus.
Endpoint
Authentification par jeton Bearer : un seul POST met la tâche en file d’attente, et le résultat vous parvient par webhook ou lien signé.
Appeler depuis votre stack
curl -X POST https://api.kit.forhosting.com/dev2/sql-where-builder \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"filters":[{"field":"users.status","operator":"=","value":"active"},{"field":"users.age","operator":">=","value":21}]}'const res = await fetch("https://api.kit.forhosting.com/dev2/sql-where-builder", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"filters": [
{
"field": "users.status",
"operator": "=",
"value": "active"
},
{
"field": "users.age",
"operator": ">=",
"value": 21
}
]
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/dev2/sql-where-builder",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"filters": [
{
"field": "users.status",
"operator": "=",
"value": "active"
},
{
"field": "users.age",
"operator": ">=",
"value": 21
}
]
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/dev2/sql-where-builder", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"filters":[{"field":"users.status","operator":"=","value":"active"},{"field":"users.age","operator":">=","value":21}]}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"filters":[{"field":"users.status","operator":"=","value":"active"},{"field":"users.age","operator":">=","value":21}]}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/dev2/sql-where-builder", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)Exemple de requête
{
"filters": [
{
"field": "users.status",
"operator": "=",
"value": "active"
},
{
"field": "users.age",
"operator": ">=",
"value": 21
}
]
}Exemple de réponse
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "dev2.sql_where_builder",
"status": "queued",
"_links": {
"result": "/tasks/tsk_…/result"
}
}L’API est asynchrone : chaque appel renvoie un task_id immédiatement, puis vous interrogez l’état à raison d’une requête par seconde.
Tarifs
Le prix est publié, sans tokens ni crédits. Une tâche qui échoue n’est pas facturée.
Limites
max_items | 100 |
Erreurs
| HTTP | Code | Signification |
|---|---|---|
401 | unauthorized | Clé API absente ou invalide : vérifiez l’en-tête Authorization. |
402 | insufficient_balance | Solde insuffisant : rechargez votre compte pour lancer cette tâche. |
404 | unknown_type | Type de tâche inconnu : vérifiez le champ type de votre requête. |
429 | rate_limited | Trop de requêtes : ralentissez la cadence, puis réessayez. |
Notes techniques
Le résultat est donc prévisible pour les générateurs de requêtes, outils d’administration, écrans de rapport et endpoints qui reçoivent déjà les filtres sous forme de données.
Construisez la structure SQL sans concaténer les valeurs
Il renvoie une clause WHERE SQL paramétrée avec des paramètres positionnels de style PostgreSQL, tels que $1 et $2, ainsi qu’un tableau params dans l’ordre correspondant exact.
Maîtrisez les opérateurs, paramètres et tests de nullité
Les valeurs scalaires JSON sont acceptées, notamment les chaînes, nombres, booléens et null ; les tableaux sont réservés aux deux opérateurs de liste.
Délimitez les identifiants et validez la politique applicative
Un nom tel que users.created_at devient deux segments délimités séparément, tandis qu’un guillemet double interne est échappé par doublement, conformément aux règles SQL usuelles. Appliquez aussi vos règles métier aux opérateurs : un endpoint de rapport peut autoriser égalité et intervalles tout en refusant les motifs, même si LIKE est disponible.
Cas d'intégration
Alimenter les filtres d’un endpoint API
Convertissez les filtres validés de la chaîne de requête en clause et paramètres ordonnés pour la base.
Questions techniques
Quelle syntaxe de paramètres est générée ?
Il génère des paramètres numérotés de style PostgreSQL : $1, $2, puis les suivants.