Vectorized Query Execution

Vectorized query execution is a query engine design where operators process data in column-wise batches (vectors) instead of one row at a time. By operating on contiguous arrays of values, it maximizes CPU cache efficiency and enables SIMD instructions, which is crucial for high-throughput analytics on time-series, tick, and telemetry data.

What Is Vectorized Query Execution?

In a traditional row-at-a-time engine, each operator pulls a single row, processes it, then passes it on. Vectorized engines instead pull a batch of values per column (for example 1,024 timestamps, then 1,024 prices) and apply the operator to the whole batch.

This approach pairs naturally with columnar databases and vector scans, because both store and read columns as contiguous memory blocks that map cleanly to CPU vector registers.

Next generation time-series database

QuestDB is an open-source time-series database optimized for market and heavy industry data. Built from scratch in Java and C++, it offers high-throughput ingestion and fast SQL queries with time-series extensions.

Try live demo Read documentation

Why It Matters for Analytical and Time-Series Workloads

Analytical queries in time-series databases are often dominated by sequential scans, filters, joins, and aggregations over millions of rows. These workloads are typically CPU-bound.

Vectorized execution improves performance by:

Reducing per-row function call and branching overhead

Making memory access cache-friendly through columnar batches

Using SIMD instructions to evaluate predicates and arithmetic on many values at once

For capital markets (tick data, order books) or heavy industry (high-frequency sensor streams), this translates into lower query latency and higher throughput on the same hardware.

How It Works Internally

An analytical query engine organizes execution as a pipeline of operators:

A scan operator reads column chunks into vectors.

Filter operators evaluate predicates on entire vectors, producing a selection mask.

Projection and aggregation operators apply arithmetic or grouping to only the selected positions.

Pseudocode sketch:

while batch := scan.next():
    mask = eval_predicate(batch["price"])
    agg_state.update(batch["volume"][mask])

Each operator is implemented in tight loops over arrays, which the compiler and CPU can aggressively optimize.

Tradeoffs and When It Helps Most

Vectorized query execution shines for large scans and aggregations where per-row work is uniform. It is less beneficial for heavy branching or highly selective point lookups, where overhead of batching and masks may dominate.

Modern query planners typically choose vectorized pipelines by default for analytical workloads, making vectorized execution a core building block of high-performance, real-time analytics databases.