Wetterdaten mit Ihren vertrauten Werkzeugen abfragen

Jetzt starten

Sie benötigen lediglich ein GribStream-API-Token und einen MySQL-kompatiblen Client oder eine entsprechende Bibliothek.

1. Erstellen Sie ein kostenloses API-Token oder verwenden Sie ein vorhandenes Token.
2. Verwenden Sie gribstream als Benutzernamen und das API-Token als Passwort.
3. Wählen Sie ein Dataset wie gfs als Datenbank aus und stellen Sie die Verbindung her.

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

Der MySQL-Client für die Kommandozeile fragt das Token ab, ohne es im Shell-Verlauf zu speichern. --quick sorgt in diesem Befehl dafür, dass Zeilen bei ihrer Ankunft ausgegeben werden, statt auf das vollständige Ergebnis zu warten. Andere Clients verwenden andere Einstellungen für die schrittweise Ausgabe.

MySQL-Abfragen verwenden dasselbe API-Token und dasselbe Kontingent wie Abfragen über die HTTP-API. Die Nutzung richtet sich nach den Wetterdaten, die zur Beantwortung gelesen werden. Wenn Sie bei der Dataset-Auswahl unsicher sind, durchsuchen Sie den Modellkatalog; gfs ist ein sinnvoller globaler Ausgangspunkt.

Warum MySQL?

Sprachen und Werkzeuge mit einem MySQL-Treiber können über diese vertraute Verbindung GribStream abfragen. Sie müssen weder einen MySQL-Server betreiben noch Wetterdateien importieren oder eine neue Client-Bibliothek lernen.

Die Verbindung ist nur lesend und auf Wetterdaten zugeschnitten. Datasets erscheinen als Datenbanken, Wetterparameter lassen sich erkunden und nicht unterstütztes SQL führt zu einer klaren Fehlermeldung.

Wetterspalte finden und abfragen

Jeder GribStream-Wetterparameter erscheint als datasetspezifische MySQL-Spalte. Wählen Sie zunächst ein Dataset und sehen Sie sich dessen Spalten an, bevor Sie die Abfrage schreiben:

SHOW FULL COLUMNS FROM gfs.timeseries;

Kopieren Sie aus dem Ergebnis den benötigten Wert unter Field. Comment enthält den lesbaren Namen, die native Einheit und die genaue Entsprechung mit GS_VALUE(...). Für die GFS-Temperatur in 2 m Höhe heißt die Spalte tmp_2_m_above_ground.

Diese drei Formen bezeichnen denselben Wetterparameter. Die Wetterspalte ist die einfachste SQL-Form; GS_VALUE übernimmt den exakten Selektor, wenn Sie eine vorhandene Abfrage der HTTP-API übersetzen oder den Selektor dynamisch wählen. Die JSON-Form ist der auf den Modellseiten angezeigte Selektor.

tmp_2_m_above_ground

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

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

Kopieren Sie Wetterspaltennamen aus SHOW FULL COLUMNS oder gribstream.selector_columns, statt sie selbst zu bilden. Die meisten sind gut lesbar; lange oder kollidierende Namen erhalten ein deterministisches Suffix. Exakte Selektoren unterscheiden Groß- und Kleinschreibung.

Diese Abfrage liefert die nächsten sechs Stunden der GFS-Temperatur in 2 m Höhe für einen Punkt:

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;

Diese Wetterspalte veröffentlicht Werte in Kelvin. Prüfen Sie die Einheit in Comment oder im Katalog, statt sie aus Spaltenname oder Alias abzuleiten.

Das Ergebnis besteht aus gewöhnlichen Zeilen. Die folgenden Werte dienen nur als Beispiel:

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

Nutzen Sie die Katalogsuche, um Spalten nach Parameternamen zu finden, Einheiten zu prüfen und bei Bedarf den exakten JSON-Selektor oder die GS_VALUE-Expression zu erhalten.

Wenn die Verbindung bereits gfs ausgewählt hat, verwenden Sie FROM timeseries. Andernfalls geben Sie die Tabelle als gfs.timeseries an.

Mit einer funktionierenden Abfrage beginnen

Wählen Sie das Beispiel, das Ihrem Ziel am nächsten kommt, öffnen Sie es und ändern Sie nur Dataset, gefundene Wetterspalte, Zeiten oder Orte. Kopieren Sie Spaltennamen aus SHOW FULL COLUMNS, statt die Normalisierung eines Selektors zu erraten.

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;

Aus Ihrer Programmiersprache verbinden

Wählen Sie unten eine Sprache aus. Jedes Beispiel stellt eine sichere Verbindung her, führt dieselbe kleine Wetterabfrage aus und liest deren Zeilen. Speichern Sie das Token in einer Umgebungsvariable oder Geheimnisverwaltung und niemals in einer versionierten Verbindungszeichenfolge.

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

Verwenden Sie für große Ergebnisse den Zeilen-Iterator, Streaming-Modus oder die entsprechende Funktion Ihres Treibers, damit nicht das gesamte Ergebnis im Speicher landet.

timeseries oder runs wählen

Jedes Dataset stellt dieselben zwei Formen von Wettertabellen bereit. Wählen Sie die Tabelle nach der zu beantwortenden Frage, nicht nach den gewünschten Ausgabespalten.

forecasted_at ist der Initialisierungszeitpunkt des Modells. forecasted_time ist der vorhergesagte Gültigkeitszeitpunkt. lead_time ist die Differenz in Stunden und kann ausgewählt oder gefiltert werden.

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;

Datasets, Wetterspalten und exakte Selektoren finden

Raten Sie Spaltennamen, Parameterlevel oder Einheiten nicht. Finden Sie ein Dataset, prüfen Sie seine Wetterspalten und verwenden Sie die exakte Selektorzuordnung nur, wenn Sie die API-Form oder die GS_VALUE-Ausweichform benötigen.

1. Dataset finden

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. Wetterspalten durchsuchen

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

3. Zuordnungen suchen oder exakten Selektor verwenden

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 ordnet jede Wetterspalte ihrem lesbaren Namen, den Einheiten, dem JSON-Selektor und der entsprechenden GS_VALUE-Expression zu. Die Abfrage benötigt eine exakte Bedingung für dataset.

Verwenden Sie den erzeugten column_name in gewöhnlichem SQL. Nutzen Sie GS_VALUE(name, level, info) für die direkte Übersetzung eines API-Selektors. Dieser gefsatmosmean-Selektor besitzt einen nicht leeren Wert für info und benötigt daher alle drei Argumente:

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

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

Die Modellseiten zeigen weiterhin den kanonischen JSON-Selektor und seine exakte GS_VALUE-Form. Kopieren Sie SQL-Spaltennamen aus dem aktuellen Schema, in dem Kollisionen und lange Bezeichner bereits aufgelöst sind.

4. Vergleichbare Signale über Datasets finden

Gemeinsame Parameter listen übereinstimmende Wetterkonzepte, Ausgabeeinheiten und unterstützende Datasets auf. Verwenden Sie diesen Katalog vor Modellvergleichen und bestimmen Sie anschließend das exakte Selektor-Tupel jedes Datasets, statt identische Namen anzunehmen.

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;

Werte, Berechnungen und Filter

Berechnete Spalten verwenden vertraute SQL-Expressionen und können auf zuvor definierte Aliase verweisen. Geben Sie zuerst einer Wetterspalte einen Alias und verwenden Sie diesen anschließend weiter. Schreiben Sie Einheitenumrechnungen ausdrücklich aus:

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

Bedingungen für Wetterwerte unterstützen BETWEEN, numerisches IN, NULL-Prüfungen, Klammern, NOT und boolesche Kombinationen. Verbinden Sie Zeit-, Orts-, Lead-Time-, Mitglieder- und Modelllaufbedingungen mit AND; verwenden Sie OR nur innerhalb von Wetterwertbedingungen.

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;

Zeiträume, relative Zeiten und Zeitzonen

timeseries.forecasted_time ist die gültige Zeit. runs.forecasted_at ist der Initialisierungszeitpunkt des Modells. Zeiträume benötigen beide Grenzen und schließen bei BETWEEN beide Endpunkte ein.

Verwenden Sie für angrenzende Fenster einen halboffenen Zeitraum wie forecasted_time >= start AND forecasted_time < end. So wird der Grenzzeitpunkt beim Zusammenführen aufeinanderfolgender Abfragen nicht doppelt zurückgegeben.

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;

Punkte, Grids, Lead Times und Ensembles

Verwenden Sie ein Koordinatenpaar für einen Punkt, eine Tupelliste für mehrere benannte Punkte oder Grenzen für Breiten- und Längengrad mit grid_step für ein regelmäßiges Grid. Die Abfragebeispiele zeigen jede Form.

• Ein Punkt: lat = value AND lon = value verwenden.
• Mehrere Punkte: (lat, lon) oder (lat, lon, name) mit IN verwenden.
• Ein Grid: beide Koordinaten begrenzen und grid_step in Grad festlegen. Kleinere Schritte wählen mehr Punkte aus und verbrauchen mehr Kontingent.

Abfragen effizient halten

Das API-Kontingent richtet sich nach den zur Auswertung gelesenen Wetterdaten, nicht nach der Zahl der zurückgegebenen Zeilen. Eine Bedingung für einen Wetterwert oder berechneten Alias — etwa temp_c > 30 — kann Zeilen erst entfernen, nachdem diese Werte gelesen wurden. Eine große Abfrage kann daher viel Kontingent verbrauchen, obwohl ihre Filter nur wenige Zeilen liefern.

Bedingungen für Vorhersagezeit, Ort, Lead Time und Ensemble-Mitglied reduzieren die ausgewählten Daten. Den größten Einfluss haben folgende Entscheidungen:

• Verwenden Sie timeseries, sofern Sie nicht ausdrücklich den Verlauf mehrerer Modellläufe benötigen.
• Halten Sie Zeiträume kurz oder verwenden Sie eine Liste exakter Zeiten.
• Wählen Sie nur die benötigten Wetterparameterspalten aus.
• Bevorzugen Sie exakte Punkte gegenüber einem großen Grid und wählen Sie einen passenden grid_step.
• Begrenzen Sie lead_time und wählen Sie nur benötigte Ensemble-Mitglieder.

Sortierung zur Erkundung verwenden

ORDER BY ist hauptsächlich für interaktive Sitzungen und Datenexploration gedacht, wenn ein sofort lesbares Ergebnis zusätzlichen Aufwand rechtfertigt. Bei einer begrenzten Abfrage können Zeilen in der Regel schrittweise zurückgegeben werden, wenn zuerst nach der primären Zeitspalte sortiert wird. Verwenden Sie forecasted_time für timeseries oder forecasted_at für runs, wählen Sie die Richtung und ergänzen Sie bei Bedarf ausgewählte Spalten oder Aliase als weitere Schlüssel.

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;

Beginnen Sie bei runs mit forecasted_at und begrenzen Sie beide Seiten von lead_time. Ist ein sortiertes Ergebnis zu groß für eine sichere Verarbeitung, verkleinern Sie die Auswahl oder entfernen Sie ORDER BY und sortieren in Ihrer Anwendung.

Lassen Sie ORDER BY bei historischen Nachladungen und anderen großen Datenabrufen weg. Sortieren Sie nach dem Empfang, falls die Reihenfolge wichtig ist. So begrenzt die Sortierung nicht den Durchsatz, insbesondere bei breiten Auswahlen mit Wetterwertfiltern.

LIMIT für die Ergebnisgröße verwenden, nicht für das Kontingent

LIMIT hält interaktive Ausgaben klein, bestimmt aber nicht die Menge der gelesenen Wetterdaten. Filter und Sortierung können wesentlich mehr Daten lesen, als das Ergebnis enthält. Reduzieren Sie den Kontingentverbrauch mit den Auswahlbedingungen oben.

Erweitert: Abfrage mit EXPLAIN prüfen

Die meisten Abfragen benötigen kein EXPLAIN. Stellen Sie es einer Wetterabfrage voran, um die Anweisung zu prüfen und Diagnoseinformationen anzuzeigen, ohne Wetterzeilen abzurufen oder Kontingent zu verbrauchen. Es dient vor allem der Fehlerbehebung und dem Support.

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;

Schrittweise Ausgabe, Abbruch und Fehler

Zeilen werden schrittweise verfügbar. Ob sie sofort erscheinen, hängt vom MySQL-Client oder der Bibliothek ab. Verwenden Sie für große Abfragen eine ungepufferte, streamende, iterative oder blockweise Ergebnisschnittstelle. Die genaue Einstellung ist clientspezifisch; der Client-Anhang verlinkt die Dokumentation.

• Client trennt die Verbindung: Das Schließen der Verbindung bricht ihre aktive Abfrage ab.
• MySQL-Client: Mit Ctrl+C stoppen Sie die aktive Abfrage.

Fehlerbehebung

SHOW SESSION STATUS LIKE 'Compression%';

Verbindung als selbstbeschreibendes Werkzeug für KI-Agenten nutzen

Jeder allgemeine MySQL-Datenbankconnector — auch als MCP-Werkzeug bereitgestellt — kann sich mit mysql.gribstream.com:3307 verbinden. Hinterlegen Sie das API-Token in der Geheimniskonfiguration des Connectors.

Geben Sie dem Agenten die folgende Anweisungsdatei. Über Schema und Katalogtabellen kann er Datasets, Wetterspalten, Einheiten, exakte Selektorzuordnungen, Dialektregeln und ausführbare Beispiele ermitteln, bevor er eine Abfrage erstellt.

1. gribstream.sql_dialect und gribstream.query_examples lesen.
2. gribstream.datasets durchsuchen und danach SHOW FULL COLUMNS für die gewählte Wettertabelle ausführen.
3. gribstream.selector_columns verwenden, wenn eine exakte JSON-Selektor- oder GS_VALUE-Zuordnung benötigt wird.
4. Die kleinste begrenzte Abfrage erstellen und ausführen, die die Frage beantwortet.
5. EXPLAIN nur zum Prüfen oder Untersuchen einer Abfrage verwenden.

GribStream-MySQL-Skill für Agenten herunterladen — mit vollständigem Ablauf, Syntaxgrenzen und Regeln für den Datenabruf.

Unterstütztes SQL und bewusste Grenzen

Diese Grenzen halten Abfragen vorhersehbar, Ergebnisse schrittweise lesbar und Fehlermeldungen klar, statt SQL mit überraschendem Verhalten zu akzeptieren.

Anhang: Konfigurationsreferenzen der Clients

TLS, Kompression, Ergebnispufferung, Abbruch, Zeitüberschreitungen und Verbindungspools werden im Client oder Treiber statt per SQL konfiguriert. Verwenden Sie die Dokumentation der tatsächlich eingesetzten Bibliothek.