dennis zhuang 87bd2c6e62 feat(promql): run cross-table selector pairs natively (#9990)
I hereby agree to the terms of the [GreptimeDB
CLA](https://github.com/GreptimeTeam/.github/blob/main/CLA.md).

## Refer to a related PR or issue link (optional)

Native tree operator wiring (#25): cross-table inputs ("wiring B").
Builds on the two-scan route of #9870 / #9871 / #9896.

## What's changed and what's your intention?

A two-selector native statement can now read two different tables: `a /
b`, `rate(a[5m]) / rate(b[5m])`, and set operators across tables. A
scalar or point-wise wrapper around such a pair is admitted too, e.g.
`100 * (1 - a / b)`, `(a / b) * 100`, `abs(a - on(x) b)`, on one table
or across two. Before, the planner required every input to share one
metric, time index and tag list, and only admitted the pair as the root.
Both kinds of query fell back to the legacy plan.

- **Placement.** A cross-table `FusedSeries` runs on the frontend.
Region-side placement would read the wrong data:
`NameAwareDataSourceInjector` rebinds every `TableScan` in a region
request to that request's one region, so a two-table node sent to one
region would read it for both inputs.
- **`RawSeriesSource`.** New logical node and exec, one per table. It
wraps that table's scan and carries the table's metric name, tags and
fields. It is commutative, so the dist analyzer pushes each one into its
own `MergeScan`.
- In the region, it builds the `SeriesScanExec`, materializes labels,
and emits one explicit-label raw frame stream declared `Contiguous`,
reading the scan partitions in order. A series never spans scan
partitions, so each series stays contiguous.
- Its declared frame schema is built the same way as what the region
emits, which `MergeScan`'s exact `validate_remote_schema` requires.
- `plan_fused_series` accepts these frame children, and `ScanHintRule`
gives their scans the per-series distribution.
- **Planner.**
- Each input gets its own scan time filter on its own time index; the
output time index is the first input's.
- Output labels are worked out over the whole tree from each input's own
tags:
    - one-to-one `on` / `ignoring` narrows the left side's labels;
    - `and` / `unless` keep the left side's labels;
- `or` takes both sides' tags, and a series' missing tag is NULL, not
invented.

`FusedSeriesExec` takes its label columns from the output schema;
before, it narrowed them from the root binary alone, which was wrong for
wrapped trees.
- A tree whose labels cannot be named declines: an aggregate or vector
operation, or an `or` union whose columns would collide.
- **Comparisons.** Vector–vector comparisons (`a > on(host) b`, `a ==
bool b`, and wrappers around them) are admitted on one table and across
two, with Prometheus semantics: a filter keeps the left sample and
labels, `bool` returns 0/1 and drops the name.
- **Route precedence with #9973.** The whole statement is tried natively
first, so a pair over two unpartitioned Mito tables now takes this
cross-table route instead of #9973's hybrid route; the hybrid route
still covers what this route declines (e.g. partitioned or metric-engine
tables). #9973's hybrid fixtures use a partitioned right table to keep
exercising it. A right side with a duplicate match group now returns
Prometheus' "found duplicate series for the match group" error on this
route, where legacy returns a result.
- **Unchanged.**
  - Same-table pairs still run inside the region.
  - Partitioned tables with two selectors still fall back.
- `group_left` / `group_right`, aggregates on both sides, more than two
selectors and `info()` are not covered and keep the legacy plan.

In an o11ybench plan probe (standalone, Mito, single-region tables),
vmbench-lite-05, lite-06, lite-08 and long-range-03 now plan natively.
That makes 22 of the 30 queries native, all with results equal to
legacy.

Legacy itself fails `a / on(host) b` when the two tables' time indexes
have different names ("Error parsing timestamp from 'h0'"); native
answers it. That case is checked against explicit rows only.

- **Concurrent inputs.** The multi-input gather of `FusedSeriesExec` and
`RawSeriesSourceExec` used to drain scan partitions (and inputs) one
after another. That stalled mito2's legacy series distributor, which
sends into one `channel(1)` per partition. On regions with overlapping
SSTs, every scan took ~480ms, and a same-table pair took up to 12.8s. A
new `SeriesGather` polls every partition and input concurrently, each
partition on its own query task.
- It hands the executor series-contiguous input: a chunk is held while
another partition of the same input has a series open.
- What it holds is at most one series per partition, charged to the
memory pool.
  - Inputs do not constrain each other.
- An error frees everything; dropping the stream aborts the partition
tasks; a panicking task reports an error.

The distributor itself is fixed separately on main in #9991; this PR no
longer needs it.

Measured on standalone single-region Mito tables with overlapping SSTs
(o11ybench data, median of 10, ON vs legacy OFF):

| query | sequential gather (before) | this PR | legacy |
| --- | --- | --- | --- |
| vmbench-lite-05 | 479 ms | 3.03 ms | 7.4 ms |
| vmbench-lite-06 | 970 ms | 4.19 ms | 10.4 ms |
| vmbench-lite-08 | 971 ms | 3.30 ms | 8.0 ms |
| vmbench-long-range-03 | 98.6 ms | 39.6 ms | 36 ms |
| same-table cpu pair | 12.8 s | 15.3 ms | 7.6 ms |

Same-table pairs are still slower than legacy (0.5–0.7x), because native
scans the region twice while legacy plans `x / x` with one scan. Results
are equal to legacy in every compared query. One exception: legacy
returns no series for `x{region="r"} / x{region=~"r"}`, where both sides
select the same series; native returns them, as Prometheus does.

## PR Checklist
Please convert it to a draft if some of the following conditions are not
met.

- [x] I have written the necessary rustdoc comments.
- [x] I have added the necessary unit tests and integration tests.
- [ ] This PR requires documentation updates.
- [x] API changes are backward compatible.
- [x] Schema or data changes are backward compatible.
- [ ] This PR needs to be backported to release branches, and I have
added the `backport-<target>` labels (e.g. `backport-v1.3` targets
`release/v1.3`).
2026-10-27 18:28:58 +08:00
2023-08-10 08:08:37 +00:00
2023-06-25 11:05:46 +08:00
2023-11-09 10:38:12 +00:00

GreptimeDB Logo

Metrics, logs, and traces.
One engine, on your infrastructure.

A columnar database for metrics, logs, and traces on object storage. Apache-2.0 licensed core.

User Guide  ·  API Docs  ·  Roadmap 2026  ·  Slack

Stable Canary Nightly Docker Pulls License

stable for production  ·  canary includes pre-releases  ·  nightly is a weekly snapshot of main

Introduction

GreptimeDB is an open-source observability database. Metrics, logs, and traces run on one columnar engine over object storage and share one table model: tags, timestamp, and fields. When signals carry common identifiers such as service, host, or trace ID, you can correlate them in SQL without moving data between databases.

Ingest through OpenTelemetry, Prometheus Remote Write, Loki Push, or Elasticsearch Bulk. Use SQL across observability data and PromQL for metrics. Migrate ingestion one signal at a time without rebuilding your collectors.

One Query Across Signals

OpenTelemetry ingestion writes spans to opentelemetry_traces and log records to opentelemetry_logs. Both tables carry trace_id, so correlating them is a join:

-- The slowest failed spans in the last hour,
-- with the log lines emitted inside those same traces.
SELECT
    t.service_name,
    t.span_name,
    t.duration_nano / 1000000 AS duration_ms,
    l.timestamp AS log_time,
    l.severity_text,
    l.body
FROM opentelemetry_traces t
JOIN opentelemetry_logs l ON l.trace_id = t.trace_id
WHERE t.timestamp > now() - INTERVAL '1' HOUR
  AND t.span_status_code = 'STATUS_CODE_ERROR'
ORDER BY t.duration_nano DESC
LIMIT 20;

Metrics join the same way, on any tag the tables share, such as service, host, or pod.

Why You Might Use It

  • You run Prometheus plus Loki or Elasticsearch and want one backend instead of three
  • You have outgrown Prometheus on cardinality or retention and don't want the Thanos/Mimir operational surface
  • You are hitting Loki's query performance limits as log volume grows
  • You need long retention on object storage without a separate analytics stack
  • You want to query telemetry with SQL, not only a domain query language
  • You are storing GenAI or agent telemetry (OTel GenAI conventions) alongside infrastructure signals

Learn more in Why GreptimeDB.

What's Supported

Ingest OpenTelemetry (OTLP), Prometheus Remote Write, Loki Push, Elasticsearch Bulk, InfluxDB line protocol, gRPC
Query SQL, PromQL, Jaeger-compatible trace queries, MySQL and PostgreSQL wire protocols
Storage S3, GCS, Azure Blob and S3-compatible endpoints as primary storage, with memory and local-disk caches
Built in Retention policies, downsampling, continuous aggregation, explicit table partitioning, and inverted / skipping / fulltext indexes

Compute and storage are disaggregated: object storage holds the data, while memory and local-disk caches keep recent and frequently queried data close to compute.

GreptimeDB Overview

Benchmarks

Compatibility and Migration

Compatibility is per protocol, and query-side coverage is narrower than ingestion.

Compatible Not compatible
Prometheus Remote Write ingestion; PromQL queries Gaps are listed in PromQL compatibility
Loki Push ingestion; dual-write through Grafana Alloy makes the cutover gradual LogQL and the rest of the Loki query API
Elasticsearch _bulk ingestion in the open-source core; QueryDSL partially, in Enterprise Most other Elasticsearch APIs

Limitations and Edition Boundary

Cluster deployment, object storage, the Flow engine, and every ingestion protocol listed above are in the Apache-2.0 build. Repartitioning, region migration, and index creation are manual operations there.

Read replicas, workload isolation, and automated repartitioning are GreptimeDB Enterprise features, along with enterprise security and governance. The Enterprise overview has the current list, and pricing has the edition comparison.

Architecture

GreptimeDB can run in two modes:

  • Standalone — single binary for development and small deployments.
  • Distributed — four components, each independently scalable:
    • Frontend — protocol entry (OTel, Prometheus, MySQL/PostgreSQL, gRPC, ingestion APIs for Elasticsearch/InfluxDB/Loki) and the distributed query engine. Stateless, scales horizontally.
    • Datanode — region engine with WAL, memtable, SST, cache, compaction, and indexes. Persists data to object storage. Elastic.
    • Metasrv — metadata, routing, repartitioning, and security. Backed by a pluggable KV layer (etcd or RDS).
    • Flownode (optional) — continuous flow computation (streaming and materialized views).

For deeper coverage, see the architecture doc or DeepWiki.

GreptimeDB System Overview

Try GreptimeDB

For AI agents — paste this prompt into your agent:

Read https://docs.greptime.com/SKILL.md and follow the instructions
to deploy, configure, ingest, and query GreptimeDB.
docker run -p 127.0.0.1:4000-4003:4000-4003 \
  -v "$(pwd)/greptimedb_data:/greptimedb_data" \
  --name greptime --rm \
  greptime/greptimedb:latest standalone start \
  --http-addr 0.0.0.0:4000 \
  --grpc-bind-addr 0.0.0.0:4001 \
  --mysql-addr 0.0.0.0:4002 \
  --postgres-addr 0.0.0.0:4003

Dashboard: http://localhost:4000/dashboard

Read more in the full Install Guide.

Troubleshooting:

  • Cannot connect to the database? Ensure that ports 4000, 4001, 4002, and 4003 are not blocked by a firewall or used by other services.
  • Failed to start? Check the container logs with docker logs greptime for further details.

Getting Started

Build From Source

Prerequisites:

  • Rust toolchain — stable, pinned by rust-toolchain.toml
  • Protobuf compiler (>= 3.15)
  • C/C++ building essentials: gcc / g++ / autoconf and the glibc dev package (libc6-dev on Ubuntu, glibc-devel on Fedora)
  • Python toolchain (optional, only for some test scripts)

Build and run:

make                          # build greptime binary
cargo run -- standalone start # start in standalone mode

Common dev commands:

make fmt            # format Rust code
make clippy         # lint (fails on warnings)
make test           # unit + integration tests (uses cargo-nextest)
make sqlness-test   # SQL regression tests

See the Contribution Guidelines for the full developer workflow.

Tools & Extensions

Project Status

GreptimeDB is generally available, with stable APIs and regular releases. It runs in production at scale — OceanBase Cloud operates 80+ GreptimeDB clusters managing 300 TB of logs, cutting log storage cost by 60%+ after migrating from Grafana Loki. See more in case studies.

Release lines and support windows are in the version reference. For where the project is going, read the v1.0 highlights and the 2026 roadmap.

Community

We invite you to engage and contribute!

If GreptimeDB is useful to you, please star the repo.

Known Users

License

GreptimeDB is an open-core project. Its core is licensed under the Apache License 2.0.

A small set of peripheral, enterprise-only features are gated behind the enterprise Cargo feature (not built by default) and are governed by the separate GreptimeDB Enterprise License. Source files under that license carry an explicit Enterprise License header.

Commercial Support

Scaling observability on your infrastructure? GreptimeDB Enterprise adds the operational, security, and support layer for production deployments. Contact us for details.

Contributing

Integration CI Codecov

Acknowledgement

Special thanks to all contributors! See AUTHOR.md.


All trademarks, logos, and brand names referenced in this README and in the Overview diagram are the property of their respective owners. Their use is for identification purposes only and does not imply endorsement or affiliation.

S
Description
Open-source, cloud-native, unified observability database for metrics, logs and traces, supporting SQL/PromQL/Streaming.
Readme Apache-2.0
2 GiB
Languages
Rust 97.9%
Python 1.5%
Shell 0.3%
JavaScript 0.2%