Notación para condiciones SQL en cadenas JSON

Notación compacta de cadenas para generar condiciones SQL desde JSON

Al construir consultas SQL a partir de archivos JSON, a menudo terminas con expresiones condicionales largas. El enfoque original usaba arrays como "vendor_id": [17,-23], que se convertían en vendor_id = 17 OR NOT vendor_id = 23. Es conciso, pero limitado: no soporta rangos, agregaciones MIN/MAX y tiene sintaxis ambigua.

La nueva notación resuelve esto con un formato de cadena validado por expresiones regulares. Cubre comparaciones, conjuntos, rangos y negaciones para cualquier tipo de datos usando los operadores =, <, >, !. El signo menos denota negación lógica, independientemente del tipo de datos.

Constructos principales de la notación

La notación convierte cadenas como X=operand en SQL estándar. Soporta funciones binarias como MIN, MAX y 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

Para conjuntos de dos elementos:

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))

Para conjuntos de cualquier tamaño, la lógica es similar: OR para igualdades, AND para negaciones, MIN/MAX para límites.

Ventajas sobre los arrays

Cambiar de arrays JSON a cadenas simplifica el análisis y la validación:

• Validación: Expresiones regulares en lugar de verificaciones de esquema por elemento.
• Completitud: Soporte integrado para rangos y agregaciones, sin extensiones necesarias.
• Legibilidad: Aprovecha la intuición matemática: X>[y1,y2] significa que X es mayor que todos los elementos.

Ejemplo de acortamiento:

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

Notación: age>=[18,65] OR age>70

Evaluación con modelos de IA

El análisis de DeepSeek destaca las fortalezas:

• Compacidad: Alta densidad de información sin perder significado.
• Intuitividad: X!=[y1,y2] significa claramente no igual a ninguno.
• Extensibilidad: Fácil agregar rangos con >> (inclusivo) y >< (exclusivo).

Posibles problemas:

• Ambigüedad para principiantes: X>[5,10] requiere entender MAX.
• Conjuntos vacíos: Hay que definir el comportamiento para X=[].
• Conflictos: >> podría chocar con desplazamientos bitwise.

Sugerencias de mejora:

• Alternativas para rangos: X..[y1,y2], X:[y1,y2].
• Paréntesis para rangos estrictos: X>>(10,20).

Análogos y singularidad

Análogos más cercanos:

| Lenguaje/DSL | Ejemplo | Similitud |

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

| Quist | 300 <= number < 500 | Comparaciones dobles, conjuntos |

| SQL++ | lang IN ["en", "de"]| IN para arrays |

| PRQL | derive full_name = ... | Enfoque funcional |

Singularidad de la notación:

• Flechas >>, >< para BETWEEN/NOT BETWEEN.
• Combinaciones como >=[y1,y2] para límites de conjuntos.
• Minimalismo con expresividad completa.

Comparación:

• Notación: 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')

Conclusiones clave

• Diseñada para preprocesadores SQL o DSL JSON en backends.
• Análisis basado en regex: rápido, sin parsers complejos.
• Soporta cualquier tipo de datos comparable.
• Menos lógico para negaciones simplifica la unificación.
• Primera versión para discusión, sin optimizaciones aún.

— Editorial Team