How do Bloom Indexes work in PostgreSQL?

Bloom indexes in PostgreSQL are a specialized type of index that provides an efficient way to test whether an element is a member of a set. They are particularly useful for speeding up queries involving multiple columns where traditional b-tree indexes would be less efficient. This makes them ideal for situations where you want to check the presence of a combination of values across several columns without the need to index each combination explicitly.

How Bloom Indexes Work?

Bloom indexes use a probabilistic data structure called a Bloom filter. Here’s how they function in PostgreSQL:

  1. Hash Functions: A Bloom filter uses multiple hash functions to map each element of a dataset to several positions in a fixed-size bit array. Each element is hashed several times, and the bits at the resulting positions in the bit array are set to 1.
  2. Insertion: When adding a value to the index, PostgreSQL applies the hash functions used in the Bloom filter to the value and sets the bits at the calculated positions in the bit array to 1.
  3. Querying: To check if a value is present in the set, PostgreSQL hashes the value with the same hash functions and checks the bit array. If all the bits at the calculated positions are 1, the value might be in the set; if any bit is 0, the value is definitely not in the set.
  4. False Positives: One of the characteristics of Bloom filters is that they can yield false positives but not false negatives. This means a query on a Bloom index can incorrectly indicate the presence of a value (although it’s not there), but it will never fail to detect a value that is present.

Use in PostgreSQL

In PostgreSQL, you can create a Bloom index using the bloom access method, which needs to be installed from the bloomextension if not already available:

To create a Bloom index on a table, specify the columns you want to include:

You can also tune the Bloom index by setting parameters like the length of the bit array (length) and the number of hash functions (colwidth). These parameters balance between the space used by the index and the accuracy (likelihood of false positives).

Advantages of Bloom Indexes

  • Space Efficiency: Bloom indexes are much more space-efficient than standard indexes, especially for composite indexing of multiple columns.
  • Performance: They can greatly improve the performance of queries that test for the presence of multiple attribute combinations, as they reduce the need for multiple or composite b-tree indexes.
  • Flexibility: They support indexing on several columns together without the need to create individual indexes on each combination of columns.


  • False Positives: The possibility of false positives means that while Bloom indexes can speed up query performance, they may require additional filtering after the index lookup to ensure accuracy.
  • Write Cost: Like all indexes, maintaining a Bloom index has a cost in terms of data modification operations. Each insert, update, or delete in the table may require updates to the Bloom index.


Bloom indexes are a powerful feature in PostgreSQL for scenarios involving quick membership testing across multiple columns. They are particularly useful for large datasets where traditional indexing strategies would consume too much space or degrade performance. However, it’s essential to understand their probabilistic nature and plan for handling false positives in application logic.

How do Bloom Filters Work in MyRocks?

RocksDB use case: Building ultra low-latency Mobile Advertising Network

How to identify strings that can be treated as numbers in PostgreSQL?


About Shiv Iyer 452 Articles
Open Source Database Systems Engineer with a deep understanding of Optimizer Internals, Performance Engineering, Scalability and Data SRE. Shiv currently is the Founder, Investor, Board Member and CEO of multiple Database Systems Infrastructure Operations companies in the Transaction Processing Computing and ColumnStores ecosystem. He is also a frequent speaker in open source software conferences globally.