Aperçu

DDSQL est SQL pour les données Datadog. Il implémente plusieurs opérations SQL standard, telles que SELECT, et permet des requêtes sur des données non structurées. Vous pouvez effectuer des actions comme obtenir exactement les données que vous souhaitez en écrivant votre propre instruction SELECT, ou interroger des tags comme s’ils étaient des colonnes de table standard.

Vous pouvez exécuter des requêtes DDSQL à partir d’agents AI en utilisant l’ensemble d’outils Datadog MCP Server ddsql (Aperçu).

Cette documentation couvre le support 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être
• Fonctions JSON
• Fonctions d’adresse réseau
• Fonctions de table
• Tags

Syntaxe

La syntaxe SQL suivante est prise en charge :

SELECT (DISTINCT) (DISTINCT: Optionnel)

Récupère des lignes d’une base de données, en DISTINCT filtrant les enregistrements en double.

Copy

SELECT DISTINCT customer_id
FROM orders 

JOIN

Combine des lignes 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

Regroupe les lignes ayant les mêmes valeurs dans des colonnes spécifiées en lignes de résumé.

Copy

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

|| (concat)

Concatène deux chaînes ou plus ensemble.

Copy

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

WHERE (Inclut le support pour LIKE, IN, ON, OR filtres)

Filtre les enregistrements qui répondent à une condition spécifiée.

Copy

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

CASE

Fournit une logique conditionnelle pour renvoyer différentes valeurs en fonction 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

Effectue un calcul sur un ensemble de lignes de table qui sont liées à la ligne actuelle.

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érifie si une valeur est nulle ou non nulle.

Copy

SELECT *
FROM orders
WHERE delivery_date IS NULL 

LIMIT

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

Copy

SELECT *
FROM customers
LIMIT 10 

OFFSET

Ignore un nombre spécifié d’enregistrements avant de commencer à renvoyer des enregistrements de la requête.

Copy

SELECT *
FROM employees
OFFSET 20 

ORDER BY

Trie l’ensemble des résultats d’une requête par une ou plusieurs colonnes. Inclut ASC, DESC pour l’ordre de tri.

Copy

SELECT *
FROM sales
ORDER BY sale_date DESC 

HAVING

Filtre les enregistrements qui répondent à une condition spécifiée après regroupement.

Copy

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

IN, ON, OR

Utilisé pour des conditions spécifiées dans les requêtes. Disponible dans les clauses WHERE, JOIN.

Copy

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

USING

Cette clause est un raccourci pour les jointures où les colonnes de jointure ont 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

Renomme une colonne ou une table avec un alias.

Copy

SELECT first_name AS name
FROM employees 

Opérations arithmétiques

Effectue des calculs de base en utilisant des opérateurs comme +, -, *, /.

Copy

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

INTERVAL value unit

Intervalle représentant une durée de temps 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 de tableau

Tous les types de données prennent en charge les types de tableau. Voir 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 en utilisant la syntaxe [TYPE] [value].

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 pourraient ê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 qui partagent toutes le même type de données. Chaque type de base DDSQL a un type de tableau correspondant.

Littéraux de tableau

Utilisez la syntaxe ARRAY[value1, value2, ...] 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édez aux éléments individuels d’un tableau avec un indice basé sur 1. Accéder à un indice qui est 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, utilisez 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 la fonction de fenêtre, voir la section Fonction de fenêtre séparée 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

-- Get the Unix epoch of a timestamp
SELECT EXTRACT(epoch FROM TIMESTAMP '2021-01-01 00:00:00+00')
-- Returns: 1609459200

-- Get the total seconds in an interval
SELECT EXTRACT(epoch FROM INTERVAL '1 day 2 hours')
-- Returns: 93600

-- Calculate how many seconds ago each event occurred
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')
-- Returns 2025-09-15 12:30:00

SELECT DATE_BIN('1 day', TIMESTAMP '2025-09-15 12:34:56', TIMESTAMP '2025-01-01')
-- Returns 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'

-- Calculate the median (50th percentile) response time
SELECT
  APPROX_PERCENTILE(0.5) WITHIN GROUP (ORDER BY response_time) AS median_response_time
FROM
  logs

-- Calculate 95th and 99th response time percentiles by 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

Variantes

Toutes les fonctions d’expressions régulières (regex) utilisent la variante des Composants Internationaux pour Unicode (ICU) :

• Métacaractères
• Opérateurs
• Expressions d’ensemble (Classes de caractères)
• Options de drapeau pour les drapeaux dans le motif. Reportez-vous à la section drapeaux ci-dessous pour les drapeaux au niveau de la fonction.
• Trouver et Remplacer (en utilisant 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

Drapeaux au niveau de la fonction

Vous pouvez utiliser les drapeaux suivants avec les fonctions d’expressions régulières :

i

Correspondance insensible à la casse

n ou m

Correspondance sensible aux nouvelles lignes

g

Global; remplace toutes les sous-chaînes correspondantes plutôt que seulement la première.

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']