Skip to main content
This tutorial demonstrates how to compact existing segments into fewer but larger segments in Apache Druid. There is some per-segment memory and processing overhead during query processing. Therefore, it can be beneficial to reduce the total number of segments. See Segment size optimization for details.

​
Prerequisites

This tutorial assumes you have already downloaded Apache Druid as described in the single-machine quickstart and have it running on your local machine. If you haven’t already, you should finish the following tutorials first:

​
Load the initial data

This tutorial uses the Wikipedia edits sample data included with the Druid distribution. To load the initial data, you use an ingestion spec that loads batch data with segment granularity of HOUR and creates between one and three segments per hour.
1

Submit the ingestion spec

You can review the ingestion spec at quickstart/tutorial/compaction-init-index.json. Submit the spec as follows to create a datasource called compaction-tutorial:
bin/post-index-task --file quickstart/tutorial/compaction-init-index.json --url http://localhost:8081
maxRowsPerSegment in the tutorial ingestion spec is set to 1000 to generate multiple segments per hour for demonstration purposes. Do not use this spec in production.
2

View the datasource

After the ingestion completes, navigate to http://localhost:8888/unified-console.html#datasources in a browser to see the new datasource in the web console.compaction-tutorial datasourceIn the Availability column for the compaction-tutorial datasource, click the link for 51 segments to view segments information for the datasource.The datasource comprises 51 segments, between one and three segments per hour from the input data:Original segments
3

Verify row count

Run a COUNT query on the datasource to verify there are 39,244 rows:
SELECT COUNT(*) FROM "compaction-tutorial"
Expected result:
┌────────┐
│ EXPR$0 │
├────────┤
│  39244 │
└────────┘
Retrieved 1 row in 1.38s.

​
Compact the data

Now you compact these 51 small segments and retain the segment granularity of HOUR. The Druid distribution includes a compaction task spec for this tutorial datasource at quickstart/tutorial/compaction-keep-granularity.json: 
{
  "type": "compact",
  "dataSource": "compaction-tutorial",
  "interval": "2015-09-12/2015-09-13",
  "tuningConfig" : {
    "type" : "index_parallel",
    "partitionsSpec": {
        "type": "dynamic"
    },
    "maxRowsInMemory" : 25000
  }
}
This compacts all segments for the interval 2015-09-12/2015-09-13 in the compaction-tutorial datasource.
1

Understanding compaction behavior

The parameters in the tuningConfig control the maximum number of rows present in each compacted segment and thus affect the number of segments in the compacted set.This datasource only has 39,244 rows. 39,244 is below the default limit of 5,000,000 maxRowsPerSegment for dynamic partitioning. Therefore, Druid only creates one compacted segment per hour.
2

Submit the compaction task

Submit the compaction task now:
bin/post-index-task --file quickstart/tutorial/compaction-keep-granularity.json --url http://localhost:8081
3

Monitor compaction progress

After the task finishes, refresh the segments view.Over time the Coordinator marks the original 51 segments as unused and subsequently removes them to leave only the new compacted segments.
By default, the Coordinator does not mark segments as unused until the Coordinator has been running for at least 15 minutes. During that time, you may see 75 total segments comprised of the old segment set and the new compacted set:
Compacted segments intermediate state 1Compacted segments intermediate state 2The new compacted segments have a more recent version than the original segments. Even though the web console displays both sets of segments, queries only read from the new compacted segments.
4

Verify row count after compaction

Run a COUNT query on compaction-tutorial again to verify the number of rows remains 39,244:
SELECT COUNT(*) FROM "compaction-tutorial"
Expected result:
┌────────┐
│ EXPR$0 │
├────────┤
│  39244 │
└────────┘
Retrieved 1 row in 1.30s.
5

View final compacted segments

After the Coordinator has been running for at least 15 minutes, the segments view only shows the new 24 segments, one for each hour:Compacted segments hourly granularity 1Compacted segments hourly granularity 2

​
Compact the data with new segment granularity

You can also change the segment granularity in a compaction task to produce compacted segments with a different granularity from that of the input segments. The Druid distribution includes a compaction task spec to create DAY granularity segments at quickstart/tutorial/compaction-day-granularity.json: 
{
  "type": "compact",
  "dataSource": "compaction-tutorial",
  "interval": "2015-09-12/2015-09-13",
  "tuningConfig" : {
    "type" : "index_parallel",
    "partitionsSpec": {
        "type": "dynamic"
    },
    "maxRowsInMemory" : 25000,
    "forceExtendableShardSpecs" : true
  },
  "granularitySpec" : {
    "segmentGranularity" : "DAY",
    "queryGranularity" : "none"
  }
}
Note that segmentGranularity is set to DAY in this compaction task spec.
1

Submit the task

Submit this task now:
bin/post-index-task --file quickstart/tutorial/compaction-day-granularity.json --url http://localhost:8081
2

View results

It takes some time before the Coordinator marks the old input segments as unused, so you may see an intermediate state with 25 total segments. Eventually, only one DAY granularity segment remains:Compacted segments day granularity 1Compacted segments day granularity 2

​
Learn more

This tutorial demonstrated how to use a compaction task spec to manually compact segments and how to optionally change the segment granularity for segments.

Build docs developers (and LLMs) love

Get started for freeTalk to us