Consultar dados 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;

O Oracle (12c+) consulta dados JSON com expressões de caminho SQL/JSON. JSON_VALUE retorna um único valor escalar, JSON_QUERY um fragmento de objeto/array, e JSON_TABLE converte JSON em uma estrutura relacional de linhas e colunas. O 21c+ suporta um tipo de dado 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"}';

O tipo jsonb do PostgreSQL oferece operadores ricos: -> (objeto/elemento json), ->> (valor texto), #> (caminho), @> (contenção), ? (existência de chave). Um índice GIN acelera as consultas com @> e ?. Consultas de caminho SQL/JSON também são possíveis com 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';

O MySQL (5.7+) consulta o tipo JSON nativo com JSON_EXTRACT(); o operador -> é uma abreviação de JSON_EXTRACT, e ->> de JSON_UNQUOTE(JSON_EXTRACT()). Buscas em campos JSON podem ser aceleradas com uma 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;

O SQL Server (2016+) armazena JSON em uma coluna NVARCHAR. JSON_VALUE retorna um valor escalar, JSON_QUERY um objeto/array, e OPENJSON converte JSON em formato tabular. ISJSON() faz a validação. Buscas em caminhos JSON podem ser aceleradas com uma 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 }
)

O MongoDB armazena todos os dados como documentos (BSON, semelhante a JSON); consultá-los é nativo. A notação de ponto alcança campos aninhados e elementos de arrays. Transformações complexas são feitas com o Aggregation Pipeline, e os índices permitem buscas rápidas em campos aninhados.

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

O Redis core não tem tipo JSON; o módulo RedisJSON (Redis Stack) fornece leituras e escritas baseadas em JSONPath com JSON.SET/JSON.GET. Junto com o RediSearch, documentos JSON podem ser indexados e consultados. Sem o módulo, o JSON é armazenado como string e interpretado na aplicação.

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

O Elasticsearch armazena e indexa documentos nativamente como JSON. Para preservar os limites dos elementos em arrays de objetos aninhados, use o tipo de campo 'nested' e uma consulta nested; caso contrário, arrays do tipo object são achatados (risco de correspondência cruzada). A distinção object vs. nested é crítica para a correção.