Interrogez les données météorologiques avec vos outils habituels

Commencer

Il vous suffit d’un token API GribStream et d’un client ou d’une bibliothèque compatible avec MySQL.

1. Créez un token API gratuit ou utilisez un token existant.
2. Utilisez gribstream comme nom d’utilisateur et le token API comme mot de passe.
3. Choisissez un dataset, par exemple gfs, comme base de données, puis connectez-vous.

mysql --host=mysql.gribstream.com \
  --port=3307 \
  --user=gribstream \
  --password \
  --database=gfs \
  --quick

Le client MySQL en ligne de commande demande le token sans l’inscrire dans l’historique du shell. Dans cette commande, --quick affiche les lignes à mesure qu’elles arrivent au lieu d’attendre le résultat complet. Les autres clients proposent des réglages différents pour lire les résultats progressivement.

Les requêtes MySQL utilisent le même token API et le même quota que les requêtes de l’API HTTP. L’utilisation dépend des données météorologiques lues pour répondre à la requête. Si vous hésitez sur le dataset, parcourez le catalogue des modèles ; gfs constitue un bon point de départ mondial.

Pourquoi MySQL ?

Les langages et outils équipés d’un pilote MySQL peuvent utiliser cette connexion familière pour interroger GribStream. Vous n’avez pas à exploiter un serveur MySQL, importer des fichiers météorologiques ni apprendre une nouvelle bibliothèque.

La connexion est en lecture seule et conçue pour les données météorologiques. Les datasets apparaissent comme des bases de données, les champs météorologiques peuvent être explorés et le SQL non pris en charge produit une erreur claire.

Trouver une colonne météo, puis l’interroger

Chaque paramètre météorologique de GribStream apparaît sous la forme d’une colonne MySQL propre au dataset. Après avoir choisi un dataset, consultez ses colonnes avant d’écrire la requête :

SHOW FULL COLUMNS FROM gfs.timeseries;

Dans le résultat, copiez la valeur Field dont vous avez besoin. Comment indique son nom lisible, ses unités natives et son équivalent exact avec GS_VALUE(...). Pour la température GFS à 2 m, la colonne est tmp_2_m_above_ground.

Ces trois formes désignent le même paramètre météorologique. La colonne météo est la forme SQL la plus simple ; GS_VALUE permet de reprendre un sélecteur exact lors de la traduction d’une requête existante de l’API HTTP ou du choix dynamique d’un sélecteur. La forme JSON est celle affichée sur les pages des modèles.

tmp_2_m_above_ground

GS_VALUE(
  'TMP',
  '2 m above ground',
  ''
)

{
  "name": "TMP",
  "level": "2 m above ground",
  "info": ""
}

Copiez les noms des colonnes météo depuis SHOW FULL COLUMNS ou gribstream.selector_columns au lieu de les construire. La plupart sont lisibles ; les noms longs ou en collision reçoivent un suffixe déterministe. Les sélecteurs exacts sont sensibles à la casse.

Cette requête renvoie les six prochaines heures de température GFS à 2 m pour un point :

SELECT forecasted_time,
       tmp_2_m_above_ground AS temp_k
FROM gfs.timeseries
WHERE forecasted_time BETWEEN NOW() AND NOW() + INTERVAL 6 HOUR
  AND lat = 40.758
  AND lon = -73.985
  AND lead_time BETWEEN '0h' AND '48h'
ORDER BY forecasted_time
LIMIT 100;

Cette colonne météo publie ses valeurs en kelvins. Consultez son Comment ou le catalogue pour connaître les unités, sans les déduire du nom de la colonne ou de l’alias.

Le résultat est constitué de lignes ordinaires. Les valeurs suivantes sont données à titre d’exemple :

forecasted_time       temp_k
2026-08-07 12:00:00   298.4
2026-08-07 13:00:00   299.1
2026-08-07 14:00:00   299.7

Suivez la procédure de recherche dans le catalogue pour rechercher les colonnes par nom de paramètre, vérifier leurs unités et retrouver le sélecteur JSON exact ou l’expression GS_VALUE lorsque vous en avez besoin.

Si la connexion a déjà sélectionné gfs, utilisez FROM timeseries. Sinon, qualifiez la table avec gfs.timeseries.

Partez d’une requête qui fonctionne

Choisissez l’exemple le plus proche de votre objectif, ouvrez-le et ne modifiez que le dataset, la colonne météo découverte, les heures ou les lieux nécessaires. Copiez les noms depuis SHOW FULL COLUMNS au lieu d’essayer de deviner la normalisation d’un sélecteur.

SELECT forecasted_time, name, lat, lon,
       tmp_2_m_above_ground AS temp_k
FROM gfs.timeseries
WHERE forecasted_time BETWEEN '2026-07-13T00:00:00Z'
                          AND '2026-07-13T06:00:00Z'
  AND (lat, lon, name) IN (
        (40.758, -73.985, 'Times Square'),
        (29.7604, -95.3698, 'Houston'),
        (51.5072, -0.1276, 'London')
      );

SELECT forecasted_time, lat, lon,
       tmp_2_m_above_ground AS temp_k
FROM gfs.timeseries
WHERE forecasted_time BETWEEN '2026-07-13T00:00:00Z'
                          AND '2026-07-13T06:00:00Z'
  AND lat BETWEEN 25 AND 50
  AND lon BETWEEN -125 AND -66
  AND grid_step = 1;

SELECT forecasted_time,
       tmp_2_m_above_ground AS temp_k
FROM gfs.timeseries
WHERE forecasted_time IN (
        '2026-07-13T00:00:00Z',
        '2026-07-13T06:00:00Z',
        '2026-07-14T18:00:00Z'
      )
  AND lat = 40.758
  AND lon = -73.985;

SELECT forecasted_at, forecasted_time,
       tmp_2_m_above_ground AS temp_k
FROM gfs.runs
WHERE forecasted_at BETWEEN '2026-07-13T00:00:00Z'
                        AND '2026-07-13T12:00:00Z'
  AND lead_time BETWEEN '0h' AND '48h'
  AND lat = 40.758
  AND lon = -73.985
ORDER BY forecasted_at, forecasted_time;

SELECT forecasted_at, forecasted_time,
       tmp_2_m_above_ground AS temp_k
FROM gfs.timeseries
WHERE forecasted_time BETWEEN '2026-07-13T00:00:00Z'
                          AND '2026-07-14T00:00:00Z'
  AND forecasted_at <= '2026-07-12T18:00:00Z'
  AND lat = 40.758
  AND lon = -73.985
ORDER BY forecasted_time;

SELECT forecasted_time, member,
       tmp_2_m_above_ground AS temp_k
FROM gefsatmos.timeseries
WHERE forecasted_time BETWEEN '2026-07-13T00:00:00Z'
                          AND '2026-07-13T12:00:00Z'
  AND member IN (0, 1, 2)
  AND lead_time BETWEEN '0h' AND '48h'
  AND lat = 40.758
  AND lon = -73.985;

SELECT forecasted_time,
       tmp_2_m_above_ground AS temp_k,
       temp_k - 273.15 AS temp_c
FROM gfs.timeseries
WHERE forecasted_time BETWEEN '2026-07-13T00:00:00Z'
                          AND '2026-07-14T00:00:00Z'
  AND lat = 40.758
  AND lon = -73.985
  AND temp_c BETWEEN 18 AND 24;

SELECT forecasted_time, lat, lon,
       tmp_2_m_above_ground AS temp_k
FROM gfs.timeseries
WHERE forecasted_time = '2026-07-13T18:00:00Z'
  AND lat BETWEEN 25 AND 50
  AND lon BETWEEN -125 AND -66
  AND grid_step = 0.5
ORDER BY temp_k DESC
LIMIT 20;

Se connecter depuis votre langage de programmation

Choisissez un langage de programmation ci-dessous. Chaque exemple établit une connexion sécurisée, exécute la même petite requête météorologique et lit ses lignes. Conservez le token dans une variable d’environnement ou un gestionnaire de secrets ; ne l’enregistrez jamais dans une chaîne de connexion versionnée.

mysql \
  -h mysql.gribstream.com -P 3307 \
  -u gribstream -p -D gfs \
  --quick

import os
import certifi
import pandas as pd
from sqlalchemy import URL, create_engine

url = URL.create(
    "mysql+mysqlconnector",
    username="gribstream",
    password=os.environ["GRIBSTREAM_API_TOKEN"],
    host="mysql.gribstream.com",
    port=3307,
    database="gfs",
)

engine = create_engine(url, connect_args={
    "ssl_verify_cert": True,
    "ssl_verify_identity": True,
    "ssl_ca": certifi.where(),
})

sql = """
SELECT forecasted_time,
       tmp_2_m_above_ground AS temp_k
FROM timeseries
WHERE forecasted_time BETWEEN NOW() AND NOW() + INTERVAL 6 HOUR
  AND lat = 40.758 AND lon = -73.985
ORDER BY forecasted_time
"""

for frame in pd.read_sql_query(sql, engine, chunksize=10_000):
    print(frame.head())

String SQL = """
    SELECT forecasted_time,
           tmp_2_m_above_ground AS temp_k
    FROM timeseries
    WHERE forecasted_time BETWEEN NOW() AND NOW() + INTERVAL 6 HOUR
      AND lat = 40.758 AND lon = -73.985
    ORDER BY forecasted_time
    """;

String url = "jdbc:mysql://mysql.gribstream.com:3307/gfs?sslMode=VERIFY_IDENTITY";
Properties props = new Properties();
props.setProperty("user", "gribstream");
props.setProperty("password", System.getenv("GRIBSTREAM_API_TOKEN"));

try (Connection db = DriverManager.getConnection(url, props);
     Statement statement = db.createStatement(
         ResultSet.TYPE_FORWARD_ONLY,
         ResultSet.CONCUR_READ_ONLY)) {
    statement.setFetchSize(Integer.MIN_VALUE);
    try (ResultSet rows = statement.executeQuery(SQL)) {
        while (rows.next()) {
            System.out.println(rows.getTimestamp("forecasted_time"));
        }
    }
}

const string SQL = @"
SELECT forecasted_time,
       tmp_2_m_above_ground AS temp_k
FROM timeseries
WHERE forecasted_time BETWEEN NOW() AND NOW() + INTERVAL 6 HOUR
  AND lat = 40.758 AND lon = -73.985
ORDER BY forecasted_time";

var builder = new MySqlConnectionStringBuilder {
    Server = "mysql.gribstream.com",
    Port = 3307,
    Database = "gfs",
    UserID = "gribstream",
    Password = Environment.GetEnvironmentVariable("GRIBSTREAM_API_TOKEN"),
    SslMode = MySqlSslMode.VerifyFull,
};

await using var db = new MySqlConnection(builder.ConnectionString);
await db.OpenAsync();
await using var command = new MySqlCommand(SQL, db);
await using var rows = await command.ExecuteReaderAsync(
    CommandBehavior.SequentialAccess);
while (await rows.ReadAsync()) {
    Console.WriteLine(rows.GetDateTime("forecasted_time"));
}

const query = `
SELECT forecasted_time,
       tmp_2_m_above_ground AS temp_k
FROM timeseries
WHERE forecasted_time BETWEEN NOW() AND NOW() + INTERVAL 6 HOUR
  AND lat = 40.758 AND lon = -73.985
ORDER BY forecasted_time`

cfg := mysql.NewConfig()
cfg.User = "gribstream"
cfg.Passwd = os.Getenv("GRIBSTREAM_API_TOKEN")
cfg.Net = "tcp"
cfg.Addr = "mysql.gribstream.com:3307"
cfg.DBName = "gfs"
cfg.TLSConfig = "true"
cfg.ParseTime = true
db, err := sql.Open("mysql", cfg.FormatDSN())
if err != nil { log.Fatal(err) }
defer db.Close()

rows, err := db.QueryContext(ctx, query)
if err != nil { log.Fatal(err) }
defer rows.Close()
for rows.Next() {
    var validTime time.Time
    var tempK float64
    if err := rows.Scan(&validTime, &tempK); err != nil { log.Fatal(err) }
}

import mysql from 'mysql2';

const SQL = `
SELECT forecasted_time,
       tmp_2_m_above_ground AS temp_k
FROM timeseries
WHERE forecasted_time BETWEEN NOW() AND NOW() + INTERVAL 6 HOUR
  AND lat = 40.758 AND lon = -73.985
ORDER BY forecasted_time`;

const db = mysql.createConnection({
  host: 'mysql.gribstream.com',
  port: 3307,
  user: 'gribstream',
  password: process.env.GRIBSTREAM_API_TOKEN,
  database: 'gfs',
  ssl: {},
});

db.query(SQL)
  .stream({ highWaterMark: 64 })
  .on('data', row => console.log(row.forecasted_time))
  .on('error', err => { throw err; })
  .on('end', () => db.end());

use mysql::{OptsBuilder, Pool, SslOpts};
use mysql::prelude::Queryable;

let sql = r#"
SELECT forecasted_time,
       tmp_2_m_above_ground AS temp_k
FROM timeseries
WHERE forecasted_time BETWEEN NOW() AND NOW() + INTERVAL 6 HOUR
  AND lat = 40.758 AND lon = -73.985
ORDER BY forecasted_time"#;

let opts = OptsBuilder::new()
    .ip_or_hostname(Some("mysql.gribstream.com"))
    .tcp_port(3307)
    .user(Some("gribstream"))
    .pass(std::env::var("GRIBSTREAM_API_TOKEN").ok())
    .db_name(Some("gfs"))
    .ssl_opts(Some(SslOpts::default()));

let pool = Pool::new(opts)?;
let mut db = pool.get_conn()?;
let rows = db.query_iter(sql)?;
for row in rows {
    println!("{:?}", row?);
}

const char *sql =
    "SELECT forecasted_time, "
    "tmp_2_m_above_ground AS temp_k "
    "FROM timeseries "
    "WHERE forecasted_time BETWEEN NOW() AND NOW() + INTERVAL 6 HOUR "
    "AND lat = 40.758 AND lon = -73.985 "
    "ORDER BY forecasted_time";

MYSQL *db = mysql_init(NULL);
unsigned int ssl_mode = SSL_MODE_VERIFY_IDENTITY;
mysql_options(db, MYSQL_OPT_SSL_MODE, &ssl_mode);

mysql_real_connect(db, "mysql.gribstream.com", "gribstream",
    getenv("GRIBSTREAM_API_TOKEN"), "gfs", 3307, NULL, 0);
mysql_query(db, sql);
MYSQL_RES *result = mysql_use_result(db);
MYSQL_ROW row;
while ((row = mysql_fetch_row(result)) != NULL) {
    printf("%s\n", row[0]);
}
mysql_free_result(result);
mysql_close(db);

export MYSQL_HOST=mysql.gribstream.com
export MYSQL_TCP_PORT=3307
export MYSQL_USER=gribstream
export MYSQL_PWD="$GRIBSTREAM_API_TOKEN"
export MYSQL_DATABASE=gfs

ATTACH 'ssl_mode=verify_identity' AS gribstream_db
  (TYPE mysql, READ_ONLY);

SELECT forecasted_time, lead_time, lat, lon,
       tmp_2_m_above_ground AS temp_k
FROM gribstream_db.gfs.timeseries
WHERE forecasted_time BETWEEN CURRENT_TIMESTAMP
                          AND CURRENT_TIMESTAMP + INTERVAL 6 HOUR
  AND lat = 40.758
  AND lon = -73.985
  AND lead_time BETWEEN 0 AND 48
LIMIT 100;

SELECT *
FROM mysql_query('gribstream_db', $sql$
  SELECT forecasted_time, name, lat, lon,
         tmp_2_m_above_ground AS temp_k
  FROM gfs.timeseries
  WHERE forecasted_time BETWEEN NOW() AND NOW() + INTERVAL 6 HOUR
    AND (lat, lon, name) IN (
          (40.758, -73.985, 'Times Square'),
          (29.7604, -95.3698, 'Houston')
        )
    AND lead_time BETWEEN '0h' AND '48h'
  LIMIT 100
$sql$);

Pour les résultats volumineux, utilisez l’itérateur de lignes, le mode streaming ou l’équivalent de votre pilote afin de ne pas conserver l’ensemble du résultat en mémoire.

Choisir timeseries ou runs

Chaque dataset présente les mêmes deux formes de table météorologique. Choisissez la table en fonction de la question à laquelle vous répondez, et non des colonnes que vous voulez renvoyer.

forecasted_at est l’heure d’initialisation du modèle. forecasted_time est l’heure de validité prévue. lead_time est leur différence en heures ; cette colonne peut être sélectionnée ou filtrée.

SELECT forecasted_at, forecasted_time, lat, lon,
       tmp_2_m_above_ground AS temp_k
FROM gfs.runs
WHERE forecasted_at BETWEEN '2026-07-13T00:00:00Z'
                        AND '2026-07-13T12:00:00Z'
  AND lead_time BETWEEN '0h' AND '48h'
  AND lat = 40.758
  AND lon = -73.985
ORDER BY forecasted_at DESC, forecasted_time ASC;

SELECT forecasted_at, forecasted_time, index_updated_at,
       tmp_2_m_above_ground AS temp_k
FROM gfs.timeseries
WHERE forecasted_time BETWEEN '2026-07-13T00:00:00Z'
                          AND '2026-07-13T06:00:00Z'
  AND lat = 40.758
  AND lon = -73.985
ORDER BY forecasted_time;

Découvrir les datasets, les colonnes météo et les sélecteurs exacts

Ne devinez pas les noms de colonnes, les niveaux de paramètres ni les unités. Trouvez un dataset, consultez ses colonnes météo et n’utilisez la correspondance du sélecteur exact que si vous avez besoin de la forme de l’API ou de la solution de repli GS_VALUE.

1. Trouver un dataset

SELECT code, full_name, provider, min_lead_time, max_lead_time,
       is_ensemble, member_count, members, parameter_count
FROM gribstream.datasets
WHERE code LIKE '%gfs%'
ORDER BY code;

SELECT code, archive_start, archive_window, rolling_window,
       time_resolution, run_cadence, min_lead_time, max_lead_time,
       catalog_updated_at
FROM gribstream.datasets
WHERE code = 'gfs';

2. Parcourir ses colonnes météo

SHOW FULL COLUMNS FROM gfs.timeseries LIKE '%tmp%';

3. Rechercher les correspondances ou utiliser un sélecteur exact

SELECT short_name, full_name, units, has_code_table, variation_count
FROM gribstream.parameters
WHERE dataset = 'gfs'
  AND (short_name = 'TMP' OR full_name LIKE '%temperature%')
ORDER BY short_name
LIMIT 20;

SELECT column_name, full_name, units, name, level, info,
       selector_json, gs_value_sql
FROM gribstream.selector_columns
WHERE dataset = 'gfs'
  AND column_name = 'tmp_2_m_above_ground';

gribstream.selector_columns relie chaque colonne météo à son nom lisible, ses unités, son sélecteur JSON et son expression GS_VALUE équivalente. La requête doit contenir une condition exacte sur dataset.

Utilisez le column_name généré dans les requêtes SQL ordinaires. Employez GS_VALUE(name, level, info) pour traduire directement un sélecteur de l’API. Ce sélecteur de gefsatmosmean possède une valeur info non vide ; les trois arguments sont donc nécessaires :

{
  "name": "CAPE",
  "level": "surface",
  "info": "ens mean"
}

GS_VALUE(
  'CAPE',
  'surface',
  'ens mean'
)

Les pages des modèles continuent d’afficher le sélecteur JSON canonique et sa forme exacte avec GS_VALUE. Copiez les noms des colonnes SQL depuis le schéma en ligne, où les collisions et les identifiants longs sont déjà résolus.

4. Trouver des signaux comparables entre datasets

Les paramètres partagés répertorient des concepts météorologiques communs, leurs unités de sortie et les datasets compatibles. Consultez ce catalogue avant de comparer des modèles, puis résolvez le tuple exact de chaque dataset sans supposer que les noms des sélecteurs correspondent.

SELECT code, label, units, supported_datasets
FROM gribstream.shared_parameters
WHERE code = 'temperature_2m';

SELECT forecasted_time,
       v_10u_sfc AS u_component,
       v_10v_sfc AS v_component,
       func.Hypot(u_component, v_component) AS wind_speed
FROM ifsoper.timeseries
WHERE forecasted_time BETWEEN '2026-07-13T00:00:00Z'
                          AND '2026-07-13T06:00:00Z'
  AND lat = 48.8566
  AND lon = 2.3522
ORDER BY forecasted_time;

SELECT topic, supported_syntax, example, notes
FROM gribstream.sql_dialect
ORDER BY topic;

SELECT name, description, `sql`
FROM gribstream.query_examples
ORDER BY name;

SHOW FULL COLUMNS FROM gfs.timeseries;

Valeurs, calculs et filtres

Les colonnes calculées utilisent des expressions SQL familières et peuvent référencer des alias définis plus tôt dans la liste de sélection. Donnez d’abord un alias à une colonne météo, puis réutilisez-le. Écrivez explicitement les conversions d’unités :

SELECT forecasted_time,
       tmp_2_m_above_ground AS temp_k,
       temp_k - 273.15 AS temp_c
FROM gfs.timeseries
WHERE forecasted_time BETWEEN '2026-07-13T00:00:00Z'
                          AND '2026-07-13T12:00:00Z'
  AND lat = 40.758
  AND lon = -73.985
  AND (temp_c BETWEEN 18 AND 30 OR temp_c IS NULL);

Les conditions sur les valeurs météorologiques acceptent BETWEEN, IN numérique, les tests NULL, les parenthèses, NOT et les combinaisons booléennes. Reliez avec AND les conditions de temps, de lieu, de lead time, de membre et de run du modèle ; utilisez OR uniquement entre conditions portant sur des valeurs météorologiques.

SELECT forecasted_time,
       ugrd_10_m_above_ground AS u,
       vgrd_10_m_above_ground AS v,
       func.Hypot(u, v) AS wind_speed
FROM gfs.timeseries
WHERE forecasted_time BETWEEN '2026-07-13T00:00:00Z'
                          AND '2026-07-13T12:00:00Z'
  AND lat = 40.758
  AND lon = -73.985
  AND wind_speed > 5;

SELECT forecasted_time AS valid_time,
       GS_VALUE(?, ?) AS temp_k,
       temp_k - ? AS temp_c
FROM gfs.timeseries
WHERE forecasted_time BETWEEN ? AND ?
  AND lat = ?
  AND lon = ?
  AND temp_c BETWEEN ? AND ?
LIMIT 100;

SELECT DISTINCT name,
       tmp_2_m_above_ground AS temp_k
FROM gfs.timeseries
WHERE forecasted_time BETWEEN '2026-07-13T00:00:00Z'
                          AND '2026-07-13T06:00:00Z'
  AND (lat, lon, name) IN (
        (40.758, -73.985, 'Times Square'),
        (29.7604, -95.3698, 'Houston')
      )
LIMIT 100;

Plages temporelles, temps relatif et fuseaux horaires

timeseries.forecasted_time est l’heure de validité. runs.forecasted_at est l’heure d’initialisation du modèle. Les plages exigent deux limites et incluent les deux extrémités lorsqu’elles utilisent BETWEEN.

Pour des fenêtres adjacentes, préférez une plage semi-ouverte telle que forecasted_time >= start AND forecasted_time < end. Elle évite de renvoyer deux fois l’instant situé à la frontière lorsque des requêtes consécutives sont réunies.

SELECT forecasted_at, forecasted_time,
       tmp_2_m_above_ground AS temp_k
FROM gfs.timeseries
WHERE forecasted_time BETWEEN NOW() - INTERVAL 2 DAY AND NOW()
  AND forecasted_at <= NOW() - INTERVAL 6 HOUR
  AND lat = 40.758
  AND lon = -73.985
LIMIT 100;

SELECT forecasted_time,
       CONVERT_TZ(forecasted_time, 'UTC', 'Europe/Paris') AS paris_time,
       tmp_2_m_above_ground AS temp_k
FROM gfs.timeseries
WHERE forecasted_time >=
        CONVERT_TZ('2026-10-25 00:00:00', 'Europe/Paris', 'UTC')
  AND forecasted_time <
        CONVERT_TZ('2026-10-26 00:00:00', 'Europe/Paris', 'UTC')
  AND lat = 48.8566
  AND lon = 2.3522
LIMIT 100;

Points, grilles, lead times et ensembles

Utilisez une paire de coordonnées pour un point, une liste de tuples pour plusieurs points nommés, ou des limites de latitude et longitude avec grid_step pour une grille régulière. Les exemples de requêtes illustrent chaque forme.

• Un point : utilisez lat = value AND lon = value.
• Plusieurs points : utilisez (lat, lon) ou (lat, lon, name) avec IN.
• Une grille : bornez les deux coordonnées et définissez grid_step en degrés. Un pas plus petit sélectionne davantage de points et consomme plus de quota.

Conserver des requêtes efficaces

L’utilisation du quota dépend des données météorologiques lues pour évaluer une requête, et non du nombre de lignes renvoyées. Une condition sur une valeur météorologique ou un alias calculé — par exemple temp_c > 30 — ne peut retirer des lignes qu’après la lecture de ces valeurs. Une requête volumineuse peut donc consommer beaucoup de quota même si ses filtres renvoient très peu de lignes.

Les conditions sur l’heure de prévision, le lieu, le lead time et le membre d’ensemble réduisent les données sélectionnées. Les choix suivants ont le plus d’effet :

• Utilisez timeseries, sauf si vous avez besoin de l’historique de plusieurs runs du modèle.
• Gardez des plages temporelles courtes ou utilisez une liste d’heures exactes.
• Sélectionnez uniquement les colonnes de paramètres météorologiques nécessaires.
• Préférez des points exacts à une grande grille ; pour une grille, choisissez un grid_step adapté.
• Bornez lead_time et sélectionnez seulement les membres d’ensemble nécessaires.

Utiliser le tri pour l’exploration

ORDER BY vise surtout les sessions interactives et l’exploration de données, lorsqu’un résultat immédiatement lisible justifie un travail supplémentaire. Pour une requête bornée, commencer le tri par la colonne temporelle principale permet généralement de recevoir les lignes progressivement. Utilisez forecasted_time pour timeseries ou forecasted_at pour runs, choisissez le sens voulu et ajoutez des colonnes ou alias sélectionnés comme clés secondaires si nécessaire.

SELECT forecasted_time AS valid_time, name, lat, lon,
       tmp_2_m_above_ground AS temp_k
FROM gfs.timeseries
WHERE forecasted_time BETWEEN '2026-07-13T00:00:00Z'
                          AND '2026-07-13T12:00:00Z'
  AND (lat, lon, name) IN (
        (40.758, -73.985, 'Times Square'),
        (29.7604, -95.3698, 'Houston'),
        (51.5072, -0.1276, 'London')
      )
ORDER BY valid_time DESC, temp_k DESC, name ASC;

Pour runs, commencez par forecasted_at et bornez les deux côtés de lead_time. Si un résultat trié est trop volumineux pour être traité en toute sécurité, réduisez la sélection ou retirez ORDER BY et triez dans votre application.

Pour les chargements historiques et autres extractions volumineuses, omettez ORDER BY. Si l’ordre compte, triez après réception. Vous évitez ainsi que le tri limite le débit, notamment lorsqu’une sélection large est associée à des filtres de valeurs météorologiques.

Utiliser LIMIT pour la taille du résultat, pas pour le quota

LIMIT permet de réduire un résultat interactif, mais ne détermine pas la quantité de données météorologiques lues. Les filtres et le tri peuvent lire beaucoup plus de données que le résultat final n’en contient. Utilisez les contrôles de sélection ci-dessus pour réduire le quota consommé.

Avancé : valider une requête avec EXPLAIN

La plupart des requêtes n’ont pas besoin de EXPLAIN. Placez-le devant une requête météorologique pour valider l’instruction et obtenir des informations de diagnostic sans récupérer de lignes ni consommer de quota. Il sert principalement au dépannage et à l’assistance.

EXPLAIN
SELECT forecasted_time, lat, lon,
       tmp_2_m_above_ground AS temp_k
FROM gfs.timeseries
WHERE forecasted_time BETWEEN '2026-07-13T00:00:00Z'
                          AND '2026-07-13T12:00:00Z'
  AND (lat, lon) = (40.758, -73.985)
LIMIT 100;

Lecture progressive, annulation et erreurs

Les lignes deviennent disponibles progressivement. Leur affichage immédiat dépend du client ou de la bibliothèque MySQL ; pour les requêtes volumineuses, utilisez son interface non bufferisée, streaming, itérative ou par blocs. Le réglage exact dépend du client ; l’annexe des clients renvoie vers la documentation de chaque bibliothèque.

• Déconnexion du client : fermer la connexion annule sa requête active.
• Client MySQL : appuyez sur Ctrl+C pour arrêter la requête active.

Dépannage

SHOW SESSION STATUS LIKE 'Compression%';

Utiliser la connexion comme outil autodescriptif pour les agents d’IA

Tout connecteur générique de base de données MySQL — y compris s’il est exposé comme outil MCP — peut se connecter à mysql.gribstream.com:3307. Fournissez le token API dans la configuration secrète du connecteur.

Donnez à l’agent le fichier d’instructions ci-dessous. Le schéma et les tables du catalogue lui permettent de découvrir les datasets, les colonnes météo, les unités, les correspondances exactes des sélecteurs, les règles du dialecte et des exemples prêts à l’emploi avant de construire une requête.

1. Lire gribstream.sql_dialect et gribstream.query_examples.
2. Rechercher dans gribstream.datasets, puis consulter SHOW FULL COLUMNS pour la table météo choisie.
3. Utiliser gribstream.selector_columns lorsqu’une correspondance avec un sélecteur JSON exact ou GS_VALUE est nécessaire.
4. Construire et exécuter la plus petite requête bornée qui répond à la question.
5. Utiliser EXPLAIN uniquement pour valider ou dépanner une requête.

Télécharger les instructions GribStream MySQL pour agents, avec la procédure complète, les limites de syntaxe et les règles de récupération des données.

SQL pris en charge et limites délibérées

Ces limites rendent les requêtes prévisibles, permettent une lecture progressive des résultats et produisent des erreurs claires au lieu d’accepter un SQL au comportement surprenant.

Annexe : références de configuration des clients

TLS, la compression, la mise en mémoire des résultats, l’annulation, les délais d’attente et les pools de connexions se configurent dans le client ou le pilote, pas en SQL. Consultez la documentation de la bibliothèque que vous utilisez.