Interroger des données 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+) interroge les données JSON avec des expressions de chemin SQL/JSON. JSON_VALUE renvoie une valeur scalaire unique, JSON_QUERY un fragment objet/tableau, et JSON_TABLE convertit le JSON en structure relationnelle lignes-colonnes. 21c+ prend en charge un type de données JSON natif.

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"}';

Le type jsonb de PostgreSQL offre de riches opérateurs : -> (objet/élément json), ->> (valeur texte), #> (chemin), @> (inclusion), ? (existence de clé). Un index GIN accélère les requêtes @> et ?. Les requêtes de chemin SQL/JSON sont aussi possibles avec 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+) interroge le type JSON natif avec JSON_EXTRACT() ; l'opérateur -> est un raccourci de JSON_EXTRACT, et ->> de JSON_UNQUOTE(JSON_EXTRACT()). Les recherches sur les champs JSON peuvent être accélérées avec une generated column + un index.

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+) stocke le JSON dans une colonne NVARCHAR. JSON_VALUE renvoie une valeur scalaire, JSON_QUERY un objet/tableau, et OPENJSON convertit le JSON en forme tabulaire. ISJSON() le valide. Les recherches sur des chemins JSON peuvent être accélérées avec une computed column + un index.

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 stocke toutes les données sous forme de documents (BSON, proche du JSON) ; leur interrogation est native. La notation pointée atteint les champs imbriqués et les éléments de tableaux. Les transformations complexes se font avec l'Aggregation Pipeline, et les index donnent des recherches rapides sur les champs imbriqués.

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 de base n'a pas de type JSON ; le module RedisJSON (Redis Stack) fournit des lectures et écritures basées sur JSONPath avec JSON.SET/JSON.GET. Avec RediSearch, les documents JSON peuvent être indexés et interrogés. Sans le module, le JSON est stocké comme une chaîne et analysé dans l'application.

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 stocke et indexe nativement les documents en JSON. Pour préserver les limites des éléments dans les tableaux d'objets imbriqués, utilisez le type de champ 'nested' et une requête nested ; sinon les tableaux de type object sont aplatis (risque de correspondances croisées). La distinction object vs nested est cruciale pour l'exactitude.