Présentation

DDSQL est un langage SQL pour les données Datadog. Il implémente plusieurs opérations SQL standard, telles que SELECT, et permet d’interroger des données non structurées. Vous pouvez effectuer des actions comme obtenir exactement les données souhaitées en rédigeant votre propre instruction SELECT, ou interroger des tags comme s’ils étaient des colonnes de table standard.

Cette documentation couvre la prise en charge SQL disponible et inclut :

• Syntaxe compatible avec PostgreSQL
• Types de données
• Littéraux de type
• Tableaux
• Fonctions SQL
• Expressions régulières
• Fonctions de fenêtrage
• Fonctions JSON
• Fonctions de table
• Tags

Syntaxe

La syntaxe SQL suivante est prise en charge :

SELECT (DISTINCT) (DISTINCT : facultatif)

Récupérer des lignes depuis une base de données, DISTINCT filtrant les enregistrements en double.

Copy

SELECT DISTINCT customer_id
FROM orders 

JOIN

Combiner des lignes provenant de deux tables ou plus en fonction d’une colonne liée entre elles. Prend en charge FULL JOIN, INNER JOIN, LEFT JOIN, RIGHT JOIN.

Copy

SELECT orders.order_id, customers.customer_name
FROM orders
JOIN customers
ON orders.customer_id = customers.customer_id 

GROUP BY

Regrouper les lignes ayant les mêmes valeurs dans les colonnes spécifiées en lignes récapitulatives.

Copy

SELECT product_id, SUM(quantity)
FROM sales
GROUP BY product_id 

|| (concaténation)

Concaténer deux chaînes ou plus.

Copy

SELECT first_name || ' ' || last_name AS full_name
FROM employees 

WHERE (prend en charge les filtres LIKE, IN, ON, OR)

Filtrer les enregistrements répondant à une condition spécifiée.

Copy

SELECT *
FROM employees
WHERE department = 'Sales' AND name LIKE 'J%' 

CASE

Appliquer une logique conditionnelle pour renvoyer différentes valeurs selon des conditions spécifiées.

Copy

SELECT order_id,
  CASE
    WHEN quantity > 10 THEN 'Bulk Order'
    ELSE 'Standard Order'
  END AS order_type
FROM orders 

WINDOW

Effectuer un calcul sur un ensemble de lignes de table liées à la ligne courante.

Copy

SELECT
  timestamp,
  service_name,
  cpu_usage_percent,
  AVG(cpu_usage_percent) OVER (PARTITION BY service_name ORDER BY timestamp ROWS BETWEEN 2 PRECEDING AND CURRENT ROW) AS moving_avg_cpu
FROM
  cpu_usage_data 

IS NULL / IS NOT NULL

Vérifier si une valeur est nulle ou non nulle.

Copy

SELECT *
FROM orders
WHERE delivery_date IS NULL 

LIMIT

Spécifier le nombre maximum d’enregistrements à renvoyer.

Copy

SELECT *
FROM customers
LIMIT 10 

OFFSET

Ignorer un nombre spécifié d’enregistrements avant de commencer à renvoyer les résultats de la requête.

Copy

SELECT *
FROM employees
OFFSET 20 

ORDER BY

Trier le jeu de résultats d’une requête selon une ou plusieurs colonnes. Prend en charge ASC et DESC pour l’ordre de tri.

Copy

SELECT *
FROM sales
ORDER BY sale_date DESC 

HAVING

Filtrer les enregistrements répondant à une condition spécifiée après le regroupement.

Copy

SELECT product_id, SUM(quantity)
FROM ventes
GROUP BY product_id
HAVING SUM(quantity) > 10 

IN, ON, OR

Utilisés pour les conditions spécifiées dans les requêtes. Disponibles dans les clauses WHERE et JOIN.

Copy

SELECT *
FROM orders
WHERE order_status IN ('Shipped', 'Pending') 

USING

Cette clause est un raccourci pour les jointures dont les colonnes de jointure portent le même nom dans les deux tables. Elle prend une liste de ces colonnes séparées par des virgules et crée une condition d’égalité distincte pour chaque paire correspondante. Par exemple, joindre T1 et T2 avec USING (a, b) est équivalent à ON T1.a = T2.a AND T1.b = T2.b.

Copy

SELECT orders.order_id, customers.customer_name
FROM orders
JOIN customers
USING (customer_id) 

AS

Renommer une colonne ou une table avec un alias.

Copy

SELECT first_name AS name
FROM employees 

Opérations arithmétiques

Effectuer des calculs de base à l’aide d’opérateurs tels que +, -, *, /.

Copy

SELECT price, tax, (price * tax) AS total_cost
FROM products 

INTERVAL value unit

Intervalle représentant une durée spécifiée dans une unité donnée. Unités prises en charge :
- milliseconds / millisecond
- seconds / second
- minutes / minute
- hours / hour
- days / day

Types de données

DDSQL prend en charge les types de données suivants :

Types tableau

Tous les types de données prennent en charge les types tableau. Consultez la section Tableaux pour les littéraux de tableau, l’accès aux éléments et les fonctions de tableau.

Littéraux de type

DDSQL prend en charge les littéraux de type explicites avec la syntaxe [TYPE] [valeur].

Le préfixe de type peut être omis et le type est automatiquement déduit de la valeur. Par exemple, 'hello world' est déduit comme VARCHAR, 123 comme BIGINT et true comme BOOLEAN. Utilisez des préfixes de type explicites lorsque les valeurs peuvent être ambiguës ; par exemple, TIMESTAMP '2025-01-01' serait déduit comme VARCHAR sans le préfixe.

Exemple

-- Using type literals in queries
SELECT
    VARCHAR 'Product Name: ' || name AS labeled_name,
    price * DECIMAL '1.08' AS price_with_tax,
    created_at + INTERVAL '7 days' AS expiry_date
FROM products
WHERE created_at > TIMESTAMP '2025-01-01';

Tableaux

Les tableaux sont des collections ordonnées de valeurs partageant toutes le même type de données. Chaque type de base DDSQL possède un type tableau correspondant.

Littéraux de tableau

Utiliser la syntaxe ARRAY[valeur1, valeur2, ...] pour construire un littéral de tableau. Le type du tableau est automatiquement déduit des valeurs.

SELECT ARRAY['apple', 'banana', 'cherry'] AS fruits;  -- VARCHAR array
SELECT ARRAY[1, 2, 3] AS numbers;                     -- BIGINT array
SELECT ARRAY[true, false, true] AS flags;             -- BOOLEAN array
SELECT ARRAY[1.1, 2.2, 3.3] AS decimals;              -- DECIMAL array

Accès aux éléments

Accéder aux éléments individuels d’un tableau avec un indice basé sur 1. Accéder à un index hors limites renvoie NULL.

SELECT ARRAY['a', 'b', 'c'][1];   -- Returns 'a'
SELECT ARRAY['a', 'b', 'c'][2];   -- Returns 'b'
SELECT ARRAY['a', 'b', 'c'][10];  -- Returns NULL (out of bounds)

Pour accéder aux éléments d’une colonne de tableau, utiliser la même syntaxe d’indice :

SELECT recipients[1] AS first_recipient
FROM emails

Fonctions de tableau

Les fonctions suivantes opèrent sur des tableaux :

SELECT
  CARDINALITY(recipients) AS recipient_count
FROM
  emails

SELECT
  ARRAY_POSITION(recipients, 'hello@example.com') AS position
FROM
  emails

SELECT
  STRING_TO_ARRAY('a,b,c,d,e,f', ',') AS parts

SELECT
  ARRAY_TO_STRING(ARRAY['a', 'b', 'c'], ',') AS joined_string

SELECT
  sender,
  ARRAY_AGG(subject) AS subjects,
  ARRAY_AGG(DISTINCT subject) AS distinct_subjects
FROM
  emails
GROUP BY
  sender

SELECT
  sender,
  recipient
FROM
  emails,
  UNNEST(recipients) AS recipient

Fonctions

Les fonctions SQL suivantes sont prises en charge. Pour les fonctions de fenêtrage, consultez la section Fonctions de fenêtrage dans cette documentation.

SELECT MIN(response_time) AS min_response_time
FROM logs
WHERE status_code = 200

SELECT MAX(response_time) AS max_response_time
FROM logs
WHERE status_code = 200

SELECT COUNT(request_id) AS total_requests
FROM logs
WHERE status_code = 200 

SELECT SUM(bytes_transferred) AS total_bytes
FROM logs
GROUP BY service_name

SELECT AVG(response_time)
AS avg_response_time
FROM logs
WHERE status_code = 200
GROUP BY service_name

SELECT BOOL_AND(status_code = 200) AS all_success
FROM logs

SELECT BOOL_OR(status_code = 200) AS some_success
FROM logs

SELECT CEIL(price) AS rounded_price
FROM products

SELECT FLOOR(price) AS floored_price
FROM products

SELECT ROUND(price) AS rounded_price
FROM products

SELECT POWER(response_time, 2) AS squared_response_time
FROM logs

SELECT LOWER(customer_name) AS lowercase_name
FROM customers

SELECT UPPER(customer_name) AS uppercase_name
FROM customers

SELECT ABS(balance) AS absolute_balance
FROM accounts

SELECT COALESCE(phone_number, email) AS contact_info
FROM users

SELECT
  CAST(order_id AS VARCHAR) AS order_id_string,
  'Order-' || CAST(order_id AS VARCHAR) AS order_label
FROM
  orders

SELECT
  customer_name,
  LENGTH(customer_name) AS name_length
FROM
  customers

SELECT
  TIMESTAMP '2023-10-01 10:00:00' + INTERVAL '30 days' AS future_date,
  INTERVAL '1 MILLISECOND 2 SECONDS 3 MINUTES 4 HOURS 5 DAYS'

SELECT
  TRIM(name) AS trimmed_name
FROM
  users

SELECT
  REPLACE(description, 'old', 'new') AS updated_description
FROM
  products

SELECT
  SUBSTRING(title, 1, 10) AS short_title
FROM
  books

SELECT
  REVERSE(username) AS reversed_username
FROM
  users
LIMIT 5

SELECT
  STRPOS('foobar', 'bar')

SELECT
  SPLIT_PART('aaa-bbb-ccc', '-', 2)

SELECT
  EXTRACT(year FROM purchase_date) AS purchase_year
FROM
  sales

-- Obtenir l'époque Unix d'un timestamp
SELECT EXTRACT(epoch FROM TIMESTAMP '2021-01-01 00:00:00+00')
-- Renvoie : 1609459200

-- Obtenir le nombre total de secondes d'un intervalle
SELECT EXTRACT(epoch FROM INTERVAL '1 day 2 hours')
-- Renvoie : 93600

-- Calculer le nombre de secondes écoulées depuis chaque événement
SELECT
  event_time,
  EXTRACT(epoch FROM now()) - EXTRACT(epoch FROM event_time) AS seconds_ago
FROM
  events

SELECT
  TO_TIMESTAMP('25/12/2025 04:23 pm', 'DD/MM/YYYY HH:MI am') AS ts

SELECT
  TO_TIMESTAMP(1735142580) AS ts_from_epoch

SELECT
  TO_CHAR(order_date, 'MM-DD-YYYY') AS formatted_date
FROM
  orders

SELECT DATE_BIN('15 minutes', TIMESTAMP '2025-09-15 12:34:56', TIMESTAMP '2025-01-01')
-- Renvoie 2025-09-15 12:30:00

SELECT DATE_BIN('1 jour', TIMESTAMP '2025-09-15 12:34:56', TIMESTAMP '2025-01-01')
-- Renvoie 2025-09-15 00:00:00

SELECT
  DATE_TRUNC('month', event_time) AS month_start
FROM
  events

-- Define the current analysis window
WITH bounds AS (
  SELECT CAST(CURRENT_SETTING('dd.time_frame_start') AS TIMESTAMP) AS time_frame_start,
         CAST(CURRENT_SETTING('dd.time_frame_end')   AS TIMESTAMP) AS time_frame_end
),
-- Define the immediately preceding window of equal length
     previous_bounds AS (
  SELECT time_frame_start - (time_frame_end - time_frame_start) AS prev_time_frame_start,
         time_frame_start                                       AS prev_time_frame_end
  FROM bounds
)
SELECT * FROM bounds, previous_bounds

SELECT
  *
FROM
  sales
WHERE
  purchase_date > NOW() - INTERVAL '1 hour'

-- Calculer le temps de réponse médian (50e percentile)
SELECT
  APPROX_PERCENTILE(0.5) WITHIN GROUP (ORDER BY response_time) AS median_response_time
FROM
  logs

-- Calculer les percentiles de temps de réponse au 95e et 99e par service
SELECT
  service_name,
  APPROX_PERCENTILE(0.95) WITHIN GROUP (ORDER BY response_time) AS p95_response_time,
  APPROX_PERCENTILE(0.99) WITHIN GROUP (ORDER BY response_time) AS p99_response_time
FROM
  logs
GROUP BY
  service_name

Expressions régulières

Version

Toutes les fonctions d’expression régulière (regex) utilisent la version International Components for Unicode (ICU) :

• Métacaractères
• Opérateurs
• Expressions d’ensemble (classes de caractères)
• Options d’indicateurs pour les indicateurs dans les modèles. Consultez la section indicateurs ci-dessous pour les indicateurs au niveau de la fonction.
• Recherche et remplacement (avec des groupes de capture)

Fonctions

SELECT
  *
FROM
  emails
WHERE
  REGEXP_LIKE(email_address, '@example\.com$')

SELECT regexp_match('foobarbequebaz', '(bar)(beque)');
-- {bar,beque}

SELECT regexp_match('foobarbequebaz', 'barbeque');
-- {barbeque}

SELECT regexp_match('abc123xyz', '([a-z]+)(\d+)(x(.)z)');
-- {abc,123,xyz,y}

SELECT regexp_replace('Auth success token=abc123XYZ789', 'token=\w+', 'token=***');
-- Auth success token=***

SELECT regexp_replace('status=200 method=GET', 'status=(\d+) method=(\w+)', '$2: $1');
-- GET: 200

SELECT regexp_replace('INFO INFO INFO', 'INFO', 'DEBUG', 1, 2);
-- INFO DEBUG INFO

Indicateurs au niveau de la fonction

Les indicateurs suivants peuvent être utilisés avec les fonctions d’expression régulière :

i

Correspondance insensible à la casse

n or m

Correspondance sensible aux sauts de ligne

g

Global ; remplacer toutes les sous-chaînes correspondantes plutôt que la première uniquement

SELECT regexp_match('INFO', 'info')
-- NULL

SELECT regexp_match('INFO', 'info', 'i')
-- ['INFO']

SELECT regexp_match('a
b', '^b') ;
-- NULL

SELECT regexp_match('a
b', '^b', 'n') ;
-- ['b']

SELECT icu_regexp_replace('Request id=12345 completed, id=67890 pending', 'id=\d+', 'id=XXX');
-- Request id=XXX completed, id=67890 pending

SELECT regexp_replace('Request id=12345 completed, id=67890 pending', 'id=\d+', 'id=XXX', 'g');
-- Request id=XXX completed, id=XXX pending

Fonctions de fenêtrage

Ce tableau présente un aperçu des fonctions de fenêtrage prises en charge. Pour des informations détaillées et des exemples, consultez la documentation PostgreSQL.

Fonctions et opérateurs JSON

Fonctions de table

Les fonctions de table permettent d’interroger les logs, les métriques et d’autres sources de données non structurées.

dd.logs(
    columns => array < varchar >,
    filter ? => varchar,
    indexes ? => array < varchar >,
    storage ? => varchar,
    from_timestamp ? => timestamp,
    to_timestamp ? => timestamp
) AS (column_name type [, ...])

SELECT timestamp, host, service, message, asset_id
FROM dd.logs(
    filter  => 'source:java',
    columns => ARRAY['timestamp','host','service','message','@asset.id']
) AS (
    timestamp TIMESTAMP,
    host      VARCHAR,
    service   VARCHAR,
    message   VARCHAR,
    asset_id  VARCHAR
)

dd.metrics_scalar(
    query varchar,
    reducer varchar [, from_timestamp timestamp, to_timestamp timestamp]
)

SELECT *
FROM dd.metrics_scalar(
    'avg:system.cpu.user{*} by {service}',
    'avg',
    TIMESTAMP '2025-07-10 00:00:00.000-04:00',
    TIMESTAMP '2025-07-17 00:00:00.000-04:00'
)
ORDER BY value DESC;

dd.metrics_timeseries(
    query varchar [, from_timestamp timestamp, to_timestamp timestamp]
)

SELECT *
FROM dd.metrics_timeseries(
    'avg:system.cpu.user{*} by {service}',
    TIMESTAMP '2025-07-10 00:00:00.000-04:00',
    TIMESTAMP '2025-07-17 00:00:00.000-04:00'
)
ORDER BY timestamp, service;

SELECT *
FROM dd.logs(
    columns => ARRAY['timestamp','host','service','message'],
    from_timestamp => TIMESTAMP '2025-07-10 00:00:00.000-04:00',
    to_timestamp => TIMESTAMP '2025-07-17 00:00:00.000-04:00'
) AS (
    timestamp TIMESTAMP,
    host      VARCHAR,
    service   VARCHAR,
    message   VARCHAR
)

SELECT *
FROM dd.logs(
    columns => ARRAY['timestamp','host','service','message'],
    from_timestamp => now() - INTERVAL '7 days',
    to_timestamp => now()
) AS (
    timestamp TIMESTAMP,
    host      VARCHAR,
    service   VARCHAR,
    message   VARCHAR
)

SELECT *
FROM dd.logs(
    columns => ARRAY['timestamp','host','service','message'],
    filter  => 'source:java',
    indexes => ARRAY['trino'],
    storage => 'hot'
) AS (
    timestamp TIMESTAMP,
    host      VARCHAR,
    service   VARCHAR,
    message   VARCHAR
)