See Rockset
in action

Get a product tour with a Rockset engineer

Rockset vs Apache Pinot

Compare and contrast Rockset and Apache Pinot by architecture, ingestion, queries, performance, and scalability.

Rockset vs Apache Pinot Architecture

Apache Pinot
Deployment model
SaaS - infrastructure, software and cluster ops managed by service provider
PaaS or self managed
Use of storage hierarchy
• SSDs store shared hot data, accessible from any Virtual Instance cluster • Cloud storage for durability
Hot storage plus Deep Store for backup and restore operations
Isolation of ingest and query
Yes - separate compute clusters (Virtual Instances) for ingest and query
Separation of compute and storage
No, although StarTree separates compute and cloud storage, which is an important consideration for those considering StarTree vs. open-source Pinot
Isolation for multiple applications
Yes - separate compute cluster (Virtual Instance) for each application
Full isolation with replication

Rockset is built to be a cloud-only database and does not have a self-managed option. It disaggregates compute from both hot storage and cloud storage, allowing multiple isolated compute clusters to run on the same shared data.

Pinot is a real-time distributed OLAP datastore that ingests both batch and streaming data. It has a distributed systems architecture that scales both horizontally and vertically, but unlike alternative OLAP databases, it does not decouple storage and compute. It supports both self-managed and PaaS options.

Rockset vs Apache Pinot Ingestion

Apache Pinot
Data sources
Managed data connectors to: • Events streams (e.g. Kafka, Kinesis) • Database CDC (e.g. MongoDB, DynamoDB, MySQL, PostgreSQL) • Data lakes (e.g. S3, Google Cloud Storage)
Streaming • AWS Kinesis • Apache Kafka Batch • Cloud Storage • PostgreSQL • MySQL • Snowflake • Google BigQuery File upload Write API
Semi structured data
• Ingests JSON and XML without a predefined schema • Ingests nested data
Support for JSON column types, but JSON must first be converted to a string
Transformations and rollups
Yes - using SQL ingest transformations

Rockset has built-in connectors that manage streaming ingestion from common data sources. It has native support for semi-structured data, so that nested JSON and XML can be ingested and queried as is.

Pinot supports high-performance ingest from streaming data sources. Each table is either offline or real time. Real-time tables have a smaller retention period and scale based on ingestion rate while offline tables have a larger retention period and scale based on the amount of data. In order to persistently store the generated segments that make up a table, you will need to change controller and server configs to add deep storage.

See Rockset in action
Get a product tour with a Rockset engineer.

Rockset vs Apache Pinot Performance

Apache Pinot
Documents are mutable and can be updated at the field level
• By default, all data in Pinot is immutable • Upserts only supported for streaming ingest • No support for upserts on data using the star tree index • No support for upserts on out-of-order events
• Converged Index (row, columnar and inverted index) built on all data by default • All queries are resolved through the index
• Manually configured • Forward index, inverted Index, Star-Tree index (columnar), bloom filter, range index, search index, JSON index, geospatial index, timestamp index
Query latency
50-1000ms queries on 100s of TB
50-1000ms queries on 100s of TB
Storage format
Converged Index, comprising a rowstore, columnstore and inverted index
Pinot stores data in a columnar format and adds additional indexes to perform fast filtering, aggregation and group by
Streaming ingest
• Ingests on a per-record basis • Data latency is typically 1-2 seconds
1-2 second ingest for streaming data

Rockset is designed to make streaming data queryable as quickly as possible by avoiding the need to batch data. It also updates documents efficiently by only reindexing fields that are part of an update request. Rockset indexes all data by default, which results in storage amplification but also enables low-latency queries that require less compute.

Like its competitors, Pinot can achieve sub-second query latency at high concurrency. However, this level of performance requires tuning, management, and deep expertise. Compared with the open-source version, the PaaS versions of Pinot address some of these issues, but similarly require expertise while making tradeoffs affecting query performance.

Rockset vs Apache Pinot Queries

Apache Pinot
SQL joins limited to inner join, left-outer, and semi-join
Query language
SQL - with extensions for nested data
Developer tooling
• Data APIs - saved SQL queries executed via REST endpoint • Python, Java, Node.js and Go SDKs • UDFs
• API for querying SQL via POST command • Clients for JDBC, Java, Python, and Golang • Integrations with Trino and Presto
Visualization tools
Integrations with Tableau, Looker, Grafana, Superset, Power BI, Retoolwhic
Integrations with Tableau and Superset

Rockset supports SQL as its native query language and can perform SQL joins. Users can create data APIs by storing SQL queries in Rockset that are executed from dedicated REST endpoints. Rockset integrates with some common visualization tools, but BI is not Rockset’s primary use case.

In Pinot, SQL-like queries are received by brokers and scatter the request between real-time and offline servers. The two tables then process requests, send results back to the broker, and responds with the result. Joins are limited, as is support for UDFs and subqueries, making Pinot more or less useful depending on the use case.

Rockset vs Apache Pinot Scalability

Apache Pinot
Vertical scaling
Resize compute clusters (Virtual Instances) via API or in the console
All 4 pinot node types can be resized manually
Horizontal scaling
• Add or remove compute clusters (Virtual Instances) via API or in the console • Scale out compute clusters for higher concurrency • Use separate compute clusters to isolate ingest from query or for multiple isolated applications • No rebalancing required
• Users can add additional Pinot nodes to scale horizontally • Rebalancing is manual

Rockset Virtual Instances are distributed compute clusters that can be scaled up for faster queries or scaled out for practically unlimited concurrency or if compute isolation is needed. Rockset has shared storage that scales automatically and independently, so no rebalancing is required.

Pinot allows for vertical scaling by increasing CPU and memory for each node as well as horizontal scaling by adding additional nodes. Capacity planning is a time-consuming, iterative, and manual task. It involves load testing and tuning across multiple vectors including read QPS, write QPS, number of streaming partitions, daily data size, retention period, types of workloads, number and type of segments, and much more.

See Rockset in action
Sub-second SQL on streaming data with surprising efficiency.