---
title: Basic compression with hypercore | Tiger Data Docs
description: Compress data into the columnstore for up to 98% storage savings and faster analytical queries
---

Hypercore is TimescaleDB‘s hybrid row-columnar storage engine. It automatically compresses chunks from the rowstore into the columnstore, typically reducing storage by 90–98% while making analytical queries significantly faster.

## How it works

When you create a hypertable with `segmentby` and `orderby` options, TimescaleDB automatically creates a [columnstore policy](/docs/reference/timescaledb/hypercore/add_columnstore_policy/index.md) that converts older chunks into columnar format. Recent data stays in the rowstore for fast inserts, while older data is compressed in the columnstore for efficient scans.

## Enable hypercore

## Prerequisites for this tutorial

To follow the procedure on this page, you'll need:

- A [Tiger Cloud service](/docs/get-started/quickstart/create-service/index.md) with Real-time analytics or a running instance of self-hosted TimescaleDB
- Your [connection details](/docs/integrate/find-connection-details/index.md)
- Any client that can run SQL (Tiger Console, `psql`, or your app’s SQL driver)

Create a hypertable with hypercore enabled using `CREATE TABLE`:

```
CREATE TABLE conditions (
  time        TIMESTAMPTZ       NOT NULL,
  location    TEXT              NOT NULL,
  device      TEXT              NOT NULL,
  temperature DOUBLE PRECISION  NULL,
  humidity    DOUBLE PRECISION  NULL
) WITH (
  tsdb.hypertable,
  tsdb.segmentby = 'device',
  tsdb.orderby = 'time DESC'
);
```

This automatically:

- Creates a hypertable partitioned by `time`
- Sets `device` as the segment column for efficient filtering
- Orders data by `time DESC` for optimal compression and scan performance
- Creates a columnstore policy that compresses chunks after one chunk interval

Tips

Choose `segmentby` based on how you filter data (for example, by device, location, or user). Choose `orderby` based on your most common sort order (usually time descending). Lower cardinality `segmentby` columns give better compression.

## Check compression results

After the columnstore policy runs, check how much space you’ve saved:

```
SELECT
  hypertable_size('conditions') AS total_size,
  pg_size_pretty(hypertable_size('conditions')) AS pretty_size;
```

For detailed per-chunk information:

```
SELECT * FROM chunks_detailed_size('conditions');
```

## Benefits

- Storage savings: 90–98% compression ratios are common.
- Query performance: Analytical queries run faster on columnar data thanks to vectorized execution.
- Cost reduction: Less storage means lower cloud costs.
- Transparent: Queries work the same on both rowstore and columnstore data.

## Next steps

- [Understand hypercore](/docs/learn/columnar-storage/understand-hypercore/index.md): How the hybrid storage engine works.
- [Set up hypercore](/docs/build/columnar-storage/setup-hypercore/index.md): Optimize `segmentby`, `orderby`, and policies.
- [Compression methods in hypercore](/docs/learn/columnar-storage/compression-methods/index.md): Algorithms used for each data type.