Consultar datos JSON

Oracle

-- Extract a scalar value with JSON_VALUE:
SELECT JSON_VALUE(data, '$.customer.city') AS city FROM orders;
-- Expand into rows with JSON_TABLE:
SELECT t.product, t.quantity
FROM orders s,
     JSON_TABLE(s.data, '$.items[*]'
       COLUMNS (product VARCHAR2(50) PATH '$.product',
                quantity NUMBER PATH '$.quantity')) t;

Oracle (12c+) consulta datos JSON con expresiones de ruta SQL/JSON. JSON_VALUE devuelve un único valor escalar, JSON_QUERY un fragmento de objeto/array y JSON_TABLE convierte JSON en una estructura relacional de filas y columnas. 21c+ admite un tipo de datos JSON nativo.

PostgreSQL

-- jsonb operators:
SELECT data->'customer'->>'city' AS city FROM orders;
-- Containment (@>) and a GIN index:
CREATE INDEX ix ON orders USING GIN (data);
SELECT * FROM orders
WHERE data @> '{"status": "approved"}';

El tipo jsonb de PostgreSQL ofrece operadores muy completos: -> (objeto/elemento json), ->> (valor de texto), #> (ruta), @> (contención), ? (existe la clave). Un índice GIN acelera las consultas con @> y ?. También son posibles las consultas de ruta SQL/JSON con jsonb_path_query.

MySQL

-- JSON_EXTRACT or shorthand operators:
SELECT JSON_EXTRACT(data, '$.customer.city') AS city FROM orders;
-- ->> returns unquoted text:
SELECT data->>'$.customer.city' AS city FROM orders
WHERE data->>'$.status' = 'approved';

MySQL (5.7+) consulta el tipo JSON nativo con JSON_EXTRACT(); el operador -> es la abreviatura de JSON_EXTRACT y ->> de JSON_UNQUOTE(JSON_EXTRACT()). Las búsquedas en campos JSON se pueden acelerar con una generated column + índice.

SQL Server

-- Extract a scalar value with JSON_VALUE:
SELECT JSON_VALUE(data, '$.customer.city') AS city FROM orders;
-- Expand into rows with OPENJSON:
SELECT k.product, k.quantity
FROM orders s
CROSS APPLY OPENJSON(s.data, '$.items')
  WITH (product NVARCHAR(50) '$.product', quantity INT '$.quantity') k;

SQL Server (2016+) almacena JSON en una columna NVARCHAR. JSON_VALUE devuelve un valor escalar, JSON_QUERY un objeto/array y OPENJSON convierte JSON a formato tabular. ISJSON() lo valida. Las búsquedas por rutas JSON se pueden acelerar con una computed column + índice.

MongoDB

// MongoDB is natively a document (BSON/JSON) database.
// Access nested fields with dot notation:
db.orders.find({ "customer.city": "Ankara" })
// Array element and projection:
db.orders.find(
  { "items.product": "pen" },
  { "items.$": 1 }
)

MongoDB almacena todos los datos como documentos (BSON, similar a JSON); consultarlos es nativo. La notación de punto llega a los campos anidados y a los elementos de los arrays. Las transformaciones complejas se hacen con Aggregation Pipeline, y los índices permiten búsquedas rápidas en campos anidados.

Redis

# Requires the RedisJSON module (Redis Stack).
# Write a JSON document:
JSON.SET order:1 $ '{"customer":{"city":"Ankara"},"status":"approved"}'
# Read a value with JSONPath:
JSON.GET order:1 $.customer.city

Redis básico no tiene tipo JSON; el módulo RedisJSON (Redis Stack) proporciona lecturas y escrituras basadas en JSONPath con JSON.SET/JSON.GET. Junto con RediSearch, los documentos JSON se pueden indexar y consultar. Sin el módulo, JSON se almacena como cadena y se analiza en la aplicación.

Elasticsearch

# Documents are already JSON; query fields directly:
GET orders/_search
{ "query": { "term": { "customer.city": "Ankara" } } }
# For nested arrays, use the nested type and a nested query:
GET orders/_search
{ "query": { "nested": { "path": "items",
  "query": { "match": { "items.product": "pen" } } } } }

Elasticsearch almacena e indexa los documentos de forma nativa como JSON. Para conservar los límites de los elementos en arrays de objetos anidados, use el tipo de campo 'nested' y una consulta nested; de lo contrario, los arrays de tipo object se aplanan (riesgo de coincidencias cruzadas). La distinción object vs. nested es crítica para la exactitud.