---
title: Hypercore | Tiger Data Docs
description: Reference information about the TimescaleDB hybrid row-columnar storage engine
---

Hypercore is a hybrid row-columnar storage engine in TimescaleDB. It is designed specifically for real-time analytics and powered by time-series data. The advantage of hypercore is its ability to seamlessly switch between row-oriented and column-oriented storage, delivering the best of both worlds:

![Hypertable with hypercore enabled: incoming rows are stored in the rowstore and automatically columnized into the columnstore in batches of up to 1000 values per column](/_astro/hypertable-with-hypercore-enabled-light.C2P2rNDf_Z10vkFN.webp) ![Hypertable with hypercore enabled: incoming rows are stored in the rowstore and automatically columnized into the columnstore in batches of up to 1000 values per column](/_astro/hypertable-with-hypercore-enabled-dark.CSPYbMj5_Z4MOOe.webp)

Hypercore solves the key challenges in real-time analytics:

- High ingest throughput
- Low-latency ingestion
- Fast query performance
- Efficient handling of data updates and late-arriving data
- Streamlined data management

Hypercore‘s hybrid approach combines the benefits of row-oriented and column-oriented formats:

- **Fast ingest with rowstore**: new data is initially written to the rowstore, which is optimized for high-speed inserts and updates. Real-time applications can handle rapid streams of incoming data, including upserts and late-arriving rows.

- **Efficient analytics with columnstore**: as the data cools, TimescaleDB automatically converts it to the columnstore. The columnar format enables fast scanning and aggregation. Multiple mechanisms keep queries fast:

  - [Chunk skipping](/build/performance-optimization/improve-hypertable-performance/index.md) skips entire chunks that cannot match the query.
  - Vectorized execution evaluates aggregate functions directly on columnstore batches. Since 2.27.0, this path also covers queries whose `WHERE` clause uses non-vectorizable functions like `time_bucket()`, including continuous aggregate refreshes — yielding 30%–2× faster execution in many cases.
  - [Sparse indexes](/build/performance-optimization/indexing/index.md) — `bloom` for equality and `minmax` for ranges — let the engine skip individual batches without decompressing them. Bloom indexes accelerate `SELECT`, `UPDATE`, `DELETE`, and `UPSERT` operations on compressed data.
  - Summary queries like `COUNT`, `MIN`, `MAX`, `FIRST`, and `LAST` read results straight from batch metadata.

- **Lower storage costs**: 90–98% compression in the columnstore reduces storage cost dramatically, without sacrificing query performance.

- **Fast modification of compressed data in columnstore**: just use SQL. TimescaleDB supports `INSERT`, `UPDATE`, `DELETE`, and `UPSERT` directly on the columnstore, with high-performance paths for each.

- **Full mutability with transactional semantics**: regardless of where data is stored, hypercore provides full ACID support. Like in a vanilla PostgreSQL database, inserts and updates to the rowstore and columnstore are always consistent and visible to queries as soon as they complete.

For an in-depth explanation of how hypertables and hypercore work, see the [Data model](/learn/deep-dive/whitepaper#data-model/index.md).

## Samples

Best practice for using hypercore is to:

1. **Enable columnstore on a hypertable**

   For [efficient queries](/build/performance-optimization/secondary-indexes/index.md), remember to `segmentby` the column you will use most often to filter your data. For example:

   - **Hypertables**:

     Use [`CREATE TABLE`](/reference/timescaledb/hypertables/create_table/index.md):

     ```
     CREATE TABLE crypto_ticks (
       "time" TIMESTAMPTZ,
       symbol TEXT,
       price DOUBLE PRECISION,
       day_volume NUMERIC
     ) WITH (
       timescaledb.hypertable,
       timescaledb.segmentby='symbol',
       timescaledb.orderby='time DESC'
     );
     ```

     For TimescaleDB [v2.23.0](https://github.com/timescale/timescaledb/releases/tag/2.23.0) and higher, the table is automatically partitioned on the first column in the table with a timestamp data type. If multiple columns are suitable candidates as a partitioning column, TimescaleDB throws an error and asks for an explicit definition. For earlier versions, set `partition_column` to a time column.

     If you are self-hosting TimescaleDB [v2.20.0](https://github.com/timescale/timescaledb/releases/tag/2.23.0) to [v2.22.1](https://github.com/timescale/timescaledb/releases/tag/2.23.0), to convert your data to the columnstore after a specific time interval, you have to call [add\_columnstore\_policy](/reference/timescaledb/hypercore/add_columnstore_policy/index.md) after you call [CREATE TABLE](/reference/timescaledb/hypertables/create_table/index.md)

     If you are self-hosting TimescaleDB [v2.19.3](https://github.com/timescale/timescaledb/releases/tag/2.19.3) and below, create a [PostgreSQL relational table](https://www.postgresql.org/docs/current/sql-createtable.html), then convert it using [create\_hypertable](/reference/timescaledb/hypertables/create_hypertable/index.md). You then enable hypercore with a call to [ALTER TABLE](/reference/timescaledb/hypercore/alter_table/index.md).

   - **Continuous aggregates**:

   1. [Use `ALTER MATERIALIZED VIEW` for a continuous aggregate](/reference/timescaledb/continuous-aggregates/alter_materialized_view/index.md):

      ```
      ALTER MATERIALIZED VIEW assets_candlestick_daily set (
         timescaledb.enable_columnstore = true,
         timescaledb.segmentby = 'symbol');
      ```

   2. Create a [columnstore\_policy](/reference/timescaledb/hypercore/add_columnstore_policy/index.md) that automatically converts chunks in a hypertable to the columnstore at a specific time interval. For example:

      ```
      CALL add_columnstore_policy('assets_candlestick_daily', after => INTERVAL '1d');
      ```

   TimescaleDB is optimized for fast updates on compressed data in the columnstore. To modify data in the columnstore, use standard SQL.

2. **View the policies that you set or the policies that already exist**

   ```
   SELECT * FROM timescaledb_information.jobs
   WHERE proc_name='policy_compression';
   ```

   See [timescaledb\_information.jobs](/reference/timescaledb/informational-views/jobs/index.md).

You can also [convert\_to\_columnstore](/reference/timescaledb/hypercore/convert_to_columnstore/index.md) and [convert\_to\_rowstore](/reference/timescaledb/hypercore/convert_to_rowstore/index.md) manually for more fine-grained control over your data.

## Limitations

chunks in the columnstore have the following limitations:

- `ROW LEVEL SECURITY` is not supported on chunks in the columnstore.

## Available functions

### Policies

- [`add_columnstore_policy()`](/reference/timescaledb/hypercore/add_columnstore_policy/index.md): set a policy to automatically move chunks in a hypertable to the columnstore when they reach a given age
- [`remove_columnstore_policy()`](/reference/timescaledb/hypercore/remove_columnstore_policy/index.md): remove a columnstore policy from a hypertable

### Configuration

- [`ALTER TABLE (hypercore)`](/reference/timescaledb/hypercore/alter_table/index.md): enable the columnstore for a hypertable

### Manual conversion

- [`convert_to_columnstore()`](/reference/timescaledb/hypercore/convert_to_columnstore/index.md): manually add a chunk to the columnstore
- [`convert_to_rowstore()`](/reference/timescaledb/hypercore/convert_to_rowstore/index.md): move a chunk from the columnstore to the rowstore

### Statistics and information

- [`chunk_columnstore_stats()`](/reference/timescaledb/hypercore/chunk_columnstore_stats/index.md): get statistics about chunks in the columnstore
- [`hypertable_columnstore_stats()`](/reference/timescaledb/hypercore/hypertable_columnstore_stats/index.md): get columnstore statistics related to the

columnstore

- [`timescaledb_information.chunk_columnstore_settings`](/reference/timescaledb/hypercore/chunk_columnstore_settings/index.md): get information about settings on each chunk in the columnstore
- [`timescaledb_information.hypertable_columnstore_settings`](/reference/timescaledb/hypercore/hypertable_columnstore_settings/index.md): get information about columnstore settings for all hypertables