Consulta datos meteorológicos con las herramientas que ya utilizas

Comenzar

Solo necesitas un token de API de GribStream y un cliente o una biblioteca compatible con MySQL.

1. Crea un token de API gratuito o usa uno que ya tengas.
2. Usa gribstream como nombre de usuario y el token de API como contraseña.
3. Selecciona un dataset, por ejemplo gfs, como base de datos y conéctate.

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

El cliente de línea de comandos de MySQL solicita el token sin guardarlo en el historial del shell. En este comando, --quick hace que el cliente muestre las filas a medida que llegan, en lugar de esperar a tener el resultado completo. Otros clientes tienen opciones distintas para leer resultados de forma incremental.

Las consultas MySQL usan el mismo token y la misma cuota que las consultas de la API HTTP. El uso se calcula según los datos meteorológicos leídos para responder. Si no sabes qué dataset elegir, explora el catálogo de modelos; gfs es un buen punto de partida global.

¿Por qué MySQL?

Los lenguajes y las herramientas con un driver MySQL pueden usar una conexión conocida para consultar GribStream. No necesitas administrar un servidor MySQL, importar archivos meteorológicos ni aprender una biblioteca nueva.

La conexión es de solo lectura y está diseñada para datos meteorológicos. Los datasets aparecen como bases de datos, los campos meteorológicos se pueden explorar y el SQL no compatible devuelve un error claro.

Busca una columna meteorológica y consúltala

Cada parámetro meteorológico de GribStream aparece como una columna MySQL propia del dataset. Después de elegir un dataset, consulta sus columnas antes de escribir la consulta:

SHOW FULL COLUMNS FROM gfs.timeseries;

En el resultado, copia el valor de Field que necesites. Comment indica su nombre legible, las unidades nativas y el equivalente exacto con GS_VALUE(...). Para la temperatura GFS a 2 m, la columna es tmp_2_m_above_ground.

Estas tres formas identifican el mismo parámetro meteorológico. La columna es la forma SQL más sencilla; GS_VALUE es la alternativa de selector exacto para traducir una consulta existente de la API HTTP o elegir el selector dinámicamente. La forma JSON es la que aparece en las páginas de modelos.

tmp_2_m_above_ground

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

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

Copia los nombres de las columnas meteorológicas desde SHOW FULL COLUMNS o gribstream.selector_columns en lugar de construirlos. La mayoría son legibles; los nombres largos o que colisionan reciben un sufijo determinista. Los selectores exactos distinguen mayúsculas y minúsculas.

Esta consulta devuelve las próximas seis horas de temperatura GFS a 2 m para un punto:

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;

Esta columna meteorológica publica valores en kelvin. Consulta su Comment o el catálogo para conocer las unidades, en lugar de deducirlas del nombre de la columna o del alias.

El resultado contiene filas normales. Los siguientes valores son ilustrativos:

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

Usa el flujo de búsqueda en el catálogo para buscar columnas por nombre de parámetro, consultar sus unidades y recuperar el selector JSON exacto o la expresión GS_VALUE cuando los necesites.

Si la conexión ya ha seleccionado gfs, usa FROM timeseries. De lo contrario, indica la tabla como gfs.timeseries.

Parte de una consulta que funciona

Elige el ejemplo más parecido a tu objetivo, ábrelo y cambia solo el dataset, la columna meteorológica encontrada, los tiempos o los lugares que necesites. Copia los nombres desde SHOW FULL COLUMNS en lugar de intentar deducir cómo se normaliza un selector.

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;

Conéctate desde tu lenguaje de programación

Elige un lenguaje de programación. Cada ejemplo establece una conexión segura, ejecuta la misma consulta meteorológica pequeña y lee sus filas. Guarda el token en una variable de entorno o en un gestor de secretos; no lo incluyas en una cadena de conexión guardada en el código.

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$);

Para resultados grandes, usa el iterador de filas, el modo streaming o el equivalente de tu driver para evitar que reúna todo el resultado en memoria.

Elige timeseries o runs

Cada dataset expone las mismas dos formas de tabla meteorológica. Elige la tabla según la pregunta que quieras responder, no según las columnas que quieras devolver.

forecasted_at es el tiempo de inicialización del modelo. forecasted_time es el tiempo válido que se pronostica. lead_time es la diferencia entre ambos en horas; se puede seleccionar o filtrar.

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;

Descubre datasets, columnas meteorológicas y selectores exactos

No adivines nombres de columnas, niveles de parámetros ni unidades. Busca un dataset, consulta sus columnas meteorológicas y recurre al mapeo del selector exacto solo cuando necesites la forma de la API o la alternativa GS_VALUE.

1. Busca 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. Explora sus columnas meteorológicas

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

3. Busca el mapeo o usa un selector exacto

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 relaciona cada columna meteorológica con su nombre legible, unidades, selector JSON y expresión GS_VALUE equivalente. Requiere un filtro exacto por dataset.

Usa el column_name generado en las consultas SQL habituales. Usa GS_VALUE(name, level, info) cuando necesites una traducción directa de un selector de la API. Este selector de gefsatmosmean tiene un valor info no vacío, por lo que necesita los tres argumentos:

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

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

Las páginas de modelos siguen mostrando el selector JSON canónico y su alternativa exacta con GS_VALUE. Copia los nombres de columnas SQL desde el esquema en vivo, donde ya se han resuelto las colisiones y los identificadores largos.

4. Busca señales comparables entre datasets

Los parámetros compartidos enumeran conceptos meteorológicos comunes, unidades de salida y los datasets compatibles. Consulta este catálogo antes de comparar modelos y después resuelve la tupla exacta de cada dataset, sin suponer que los nombres de los selectores coinciden.

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;

Valores, cálculos y filtros

Las columnas calculadas usan expresiones SQL conocidas y pueden hacer referencia a alias definidos antes en la lista de selección. Primero asigna un alias a una columna meteorológica y luego reutilízalo. Escribe las conversiones de unidades de forma explícita:

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);

Las condiciones sobre valores meteorológicos admiten BETWEEN, IN numérico, comprobaciones de NULL, paréntesis, NOT y combinaciones booleanas. Une con AND las condiciones de tiempo, ubicación, lead time, miembro y ejecución del modelo; usa OR solo dentro de condiciones sobre valores meteorológicos.

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;

Rangos, tiempos relativos y zonas horarias

timeseries.forecasted_time es el tiempo válido. runs.forecasted_at es el tiempo de inicialización del modelo. Los rangos necesitan ambos límites e incluyen los dos extremos cuando se escriben con BETWEEN.

Para ventanas contiguas, utiliza un rango semiabierto como forecasted_time >= start AND forecasted_time < end. Así evitas devolver dos veces el instante del límite al combinar consultas consecutivas.

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;

Puntos, grillas, lead times y ensembles

Usa un par de coordenadas para un punto, una lista de tuplas para varios puntos con nombre o límites de latitud y longitud con grid_step para una grilla regular. Los ejemplos de consultas incluyen cada una de estas formas.

• Un punto: usa lat = value AND lon = value.
• Varios puntos: usa (lat, lon) o (lat, lon, name) con IN.
• Una grilla: limita ambas coordenadas y define grid_step en grados. Los pasos más pequeños seleccionan más puntos y consumen más cuota.

Mantén las consultas eficientes

El uso de cuota depende de los datos meteorológicos leídos para evaluar una consulta, no del número de filas devueltas. Una condición sobre un valor meteorológico o un alias calculado —por ejemplo, temp_c > 30— solo puede eliminar filas después de leer esos valores. Por tanto, una consulta grande puede consumir mucha cuota aunque sus filtros devuelvan muy pocas filas.

Las condiciones sobre el tiempo de pronóstico, la ubicación, el lead time y el miembro del ensemble reducen los datos seleccionados. Estas decisiones tienen el mayor efecto:

• Usa timeseries salvo que necesites el historial de varias ejecuciones del modelo.
• Mantén cortos los rangos de tiempo o usa una lista de tiempos exactos.
• Selecciona solo las columnas de parámetros meteorológicos necesarias.
• Prefiere puntos exactos a una grilla extensa; si usas una grilla, elige un grid_step adecuado.
• Limita lead_time y selecciona solo los miembros necesarios del ensemble.

Usa el ordenamiento para explorar

ORDER BY está pensado principalmente para sesiones interactivas y exploración, cuando merece la pena recibir un resultado legible de inmediato. En una consulta acotada, ordenar primero por la columna temporal principal normalmente permite recibir filas de forma incremental. Usa forecasted_time con timeseries o forecasted_at con runs, elige cualquier dirección y añade columnas o alias seleccionados como claves secundarias cuando haga falta.

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;

Para runs, empieza por forecasted_at y limita los dos extremos de lead_time. Si un resultado ordenado es demasiado grande para procesarlo con seguridad, reduce la selección o elimina ORDER BY y ordena en tu aplicación.

En cargas históricas y otras descargas de gran volumen, omite ORDER BY. Si el orden importa, ordena los datos después de recibirlos. Así el ordenamiento no limita el rendimiento, sobre todo al combinar una selección amplia con filtros de valores meteorológicos.

Usa LIMIT para el tamaño del resultado, no para la cuota

LIMIT sirve para mantener pequeño el resultado interactivo, pero no determina cuántos datos meteorológicos se leen. Los filtros y el ordenamiento pueden leer muchos más datos de los que contiene el resultado final. Usa los controles de selección anteriores para reducir el consumo de cuota.

Avanzado: valida una consulta con EXPLAIN

La mayoría de las consultas no necesitan EXPLAIN. Añádelo delante de una consulta meteorológica para validar la sentencia y ver información de diagnóstico sin recuperar filas ni consumir cuota. Resulta útil sobre todo para investigar problemas y solicitar soporte.

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;

Resultados incrementales, cancelación y errores

Las filas se vuelven disponibles de forma incremental. Que las veas de inmediato depende del cliente o la biblioteca MySQL, así que usa su interfaz sin búfer, de transmisión continua, iterativa o por bloques para consultas grandes. La opción exacta depende del cliente; el apéndice de clientes enlaza su documentación.

• Desconexión del cliente: cerrar la conexión cancela su consulta activa.
• Cliente MySQL: pulsa Ctrl+C para detener la consulta activa.

Solución de problemas

SHOW SESSION STATUS LIKE 'Compression%';

Usar la conexión como herramienta autodescriptiva para agentes de IA

Cualquier conector genérico de base de datos MySQL —incluidos los expuestos como herramientas MCP— puede conectarse a mysql.gribstream.com:3307. Proporciona el token de API mediante la configuración secreta del conector.

Proporciona al agente el siguiente archivo de instrucciones (skill). El esquema y las tablas del catálogo le permiten descubrir datasets, columnas meteorológicas, unidades, mapeos de selectores exactos, reglas del dialecto y ejemplos listos para ejecutar antes de construir una consulta.

1. Leer gribstream.sql_dialect y gribstream.query_examples.
2. Buscar en gribstream.datasets y después consultar SHOW FULL COLUMNS para la tabla meteorológica elegida.
3. Usar gribstream.selector_columns cuando se necesite el mapeo a un selector JSON exacto o a GS_VALUE.
4. Construir y ejecutar la consulta acotada más pequeña que responda a la pregunta.
5. Usar EXPLAIN solo para validar o investigar una consulta.

Descarga las instrucciones de GribStream MySQL para agentes, con el flujo completo, los límites de sintaxis y las reglas para recuperar datos.

SQL compatible y límites deliberados

Estos límites mantienen las consultas previsibles, permiten entregar resultados de forma incremental y producen errores claros, en lugar de aceptar SQL con resultados sorprendentes.

Apéndice: referencias de configuración por cliente

TLS, la compresión, la acumulación de resultados, la cancelación, los tiempos de espera y el pool de conexiones se configuran en el cliente o driver, no mediante SQL. Consulta la documentación de la biblioteca que utilices.