Notation pour les conditions SQL dans les chaînes JSON

Notation compacte en chaîne pour générer des conditions SQL à partir de JSON

Lors de la construction de requêtes SQL à partir de fichiers JSON, on aboutit souvent à des expressions conditionnelles longues. L'approche initiale utilisait des tableaux comme "vendor_id": [17,-23], qui se convertissaient en vendor_id = 17 OR NOT vendor_id = 23. C'est concis mais limité : pas de support pour les intervalles, les agrégations MIN/MAX, et une syntaxe ambiguë.

La nouvelle notation résout cela avec un format de chaîne validé par des expressions régulières. Elle couvre les comparaisons, ensembles, intervalles et négations pour n'importe quel type de données en utilisant les opérateurs =, <, >, !. Le signe moins désigne la négation logique, indépendamment du type de données.

Éléments de base de la notation

La notation convertit des chaînes comme X=operand en SQL standard. Elle supporte les fonctions binaires comme MIN, MAX et BETWEEN.

X=y        -> X = y
X<y        -> X < y
X>y        -> X > y

X!=y       -> X < y OR X > y
X<=y       -> X < y OR X = y
X>=y       -> X > y OR X = y

Pour les ensembles à deux éléments :

X=[y1, y2]     -> (X = y1 OR X = y2)
X>[y1, y2]     -> (X > MAX(y1, y2))
X<[y1, y2]     -> (X < MIN(y1, y2))

X!=[y1, y2]    -> (X != y1 AND X != y2)
X<=[y1, y2]    -> (X <= MIN(y1, y2))
X>=[y1, y2]    -> (X >= MAX(y1, y2))

X>>[y1, y2]    -> BETWEEN(y1, y2)
X><[y1, y2]    -> (NOT BETWEEN(y1, y2))

Pour les ensembles de taille quelconque, la logique est similaire : OR pour les égalités, AND pour les négations, MIN/MAX pour les bornes.

Avantages par rapport aux tableaux

Passer des tableaux JSON aux chaînes simplifie l'analyse et la validation :

• Validation : Expressions régulières au lieu de vérifications de schéma par élément.
• Exhaustivité : Support intégré des intervalles et agrégations — pas d'extensions nécessaires.
• Lisibilité : Exploite l'intuition mathématique — X>[y1,y2] signifie X supérieur à tous les éléments.

Exemple de raccourcissement :

SQL traditionnel : WHERE (age >= 18 AND age <= 65) OR age > 70

Notation : age>=[18,65] OR age>70

Évaluation par modèle IA

L'analyse de DeepSeek met en lumière les forces :

• Compacité : Densité d'information élevée sans perte de sens.
• Intuitivité : X!=[y1,y2] signifie clairement différent de tous.
• Extensibilité : Facile d'ajouter des intervalles avec >> (inclus) et >< (exclus).

Problèmes potentiels :

• Ambiguïté pour les débutants : X>[5,10] nécessite de comprendre MAX.
• Ensembles vides : Besoin de définir le comportement pour X=[].
• Conflits : >> pourrait interférer avec les décalages binaires.

Suggestions d'amélioration :

• Alternatives pour intervalles : X..[y1,y2], X:[y1,y2].
• Parentèses pour intervalles stricts : X>>(10,20).

Analogues et unicité

Analogues les plus proches :

| Langage/DSL | Exemple | Similitude |

|-------------|--------------------------|-----------------------------|

| Quist | 300 <= number < 500 | Comparaisons doubles, ensembles |

| SQL++ | lang IN ["en", "de"]| IN pour tableaux |

| PRQL | derive full_name = ...| Approche fonctionnelle |

Unicité de la notation :

• Flèches >>, >< pour BETWEEN/NOT BETWEEN.
• Combinaisons comme >=[y1,y2] pour les bornes d'ensemble.
• Minimalisme avec une expressivité complète.

Comparaison :

• Notation : age>=[18,65] OR status=[active,pending]
• Quist : (18 <= age <= 65 OR status:in active, pending)
• SQL : (age >= 18 AND age <= 65) OR status IN ('active', 'pending')

Points clés

• Conçue pour les préprocesseurs SQL ou DSL JSON en backend.
• Analyse basée sur regex : rapide, pas d'analyseurs complexes nécessaires.
• Supporte tous les types de données comparables.
• Moins logique pour les négations simplifie l'unification.
• Première version pour discussion — pas d'optimisations encore.

— Editorial Team