postgresql-hll

Open source

PostgreSQL extension adding HyperLogLog data structures as a native data type

1.2K stars0 likes0 views

About

PostgreSQL extension adding HyperLogLog data structures as a native data type

Overview

This Postgres module introduces a new data type hll which is a HyperLogLog data structure. HyperLogLog is a fixed-size, set-like structure used for distinct value counting with tunable precision. For example, in 1280 bytes hll can estimate the count of tens of billions of distinct values with only a few percent error.

In addition to the algorithm proposed in the original paper, this implementation is augmented to improve its accuracy and memory use without sacrificing much speed. See below for more details.

This postgresql-hll extension was originally developed by the Science team from Aggregate Knowledge, now a part of Neustar. Please see the acknowledgements section below for details about its contributors.

Algorithms

A hll is a combination of different set/distinct-value-counting algorithms that can be thought of as a hierarchy, along with rules for moving up that hierarchy. In order to distinguish between said algorithms, we have given them names:

`EMPTY`

A constant value that denotes the empty set.

`EXPLICIT`

An explicit, unique, sorted list of integers in the set, which is maintained up to a fixed cardinality.

`SPARSE`

A 'lazy', map-based implementation of HyperLogLog, a probabilistic set data structure. Only stores the indices and values of non-zero registers in a map, until the number of non-zero registers exceeds a fixed cardinality.

`FULL`

A fully-materialized, list-based implementation of HyperLogLog. Explicitly stores the value of every register in a list ordered by register index.

Motivation

Our motivation for augmenting the original HLL algorithm went something like this:

Naively, a HLL takes regwidth * 2^log2m bits to store.
In typical usage, log2m = 11 and regwidth = 5, it requires 10,240 bits or 1,280 bytes.
That's a lot of bytes!

The first addition to the original HLL algorithm came from realizing that 1,280 bytes is the size of 160 64-bit integers. So, if we wanted more accuracy at low cardinalities, we could just keep an explicit set of the inputs as a sorted list of 64-bit integers until we hit the 161st distinct value. This would give us the true representation of the distinct values in the stream while requiring the same amount of memory. (This is the EXPLICIT algorithm.)

The second came from the realization that we didn't need to store registers whose value was zero. We could simply represent the set of registers that had non-zero values as a map from index to values. This map is stored as a list of index-value pairs that are bit-packed "short words" of length log2m + regwidth. (This is the SPARSE algorithm.)

Combining these two augmentations, we get a "promotion hierarchy" that allows the algorithm to be tuned for better accuracy, memory, or performance.

Initializing and storing a new hll object will simply allocate a small sentinel value symbolizing the empty set (EMPTY). When you add the first few values, a sorted list of unique integers is stored in an EXPLICIT set. When you wish to cease trading off accuracy for memory, the values in the sorted list are "promoted" to a SPARSE map-based HyperLogLog structure. Finally, when there are enough registers, the map-based HLL will be converted to a bit-packed FULL HLL structure.

Empirically, the insertion rate of EMPTY, EXPLICIT, and SPARSE representations is measured in 200k/s - 300k/s range, while the throughput of the FULL representation is in the millions of inserts per second on relatively new hardware ('10 Xeon).

Naturally, the cardinality estimates of the EMPTY and EXPLICIT representations is exact, while the SPARSE and FULL representations' accuracies are governed by the guarantees provided by the original HLL algorithm.

Usage

"Hello World"

sql

--- Make a dummy table
CREATE TABLE helloworld (
        id              integer,
        set     hll
);

--- Insert an empty HLL
INSERT INTO helloworld(id, set) VALUES (1, hll_empty());

--- Add a hashed integer to the HLL
UPDATE helloworld SET set = hll_add(set, hll_hash_integer(12345)) WHERE id = 1;

--- Or add a hashed string to the HLL
UPDATE helloworld SET set = hll_add(set, hll_hash_text('hello world')) WHERE id = 1;

--- Get the cardinality of the HLL
SELECT hll_cardinality(set) FROM helloworld WHERE id = 1;

Now with the silly stuff out of the way, here's a more realistic use case.

Data Warehouse Use Case

Let's assume I've got a fact table that records users' visits to my site, what they did, and where they came from. It's got hundreds of millions of rows. Table scans take minutes (or at least lots and lots of seconds.)

sql

CREATE TABLE facts (
  date            date,
  user_id         integer,
  activity_type   smallint,
  referrer        varchar(255)
);

I'd really like a quick (milliseconds) idea of how many unique users are visiting per day for my dashboard. No problem, let's set up an aggregate table:

sql

-- Create the destination table
CREATE TABLE daily_uniques (
  date            date UNIQUE,
  users           hll
);

-- Fill it with the aggregated unique statistics
INSERT INTO daily_uniques(date, users)
  SELECT date, hll_add_agg(hll_hash_integer(user_id))
  FROM facts
  GROUP BY 1;

We're first hashing the user_id, then aggregating those hashed values into one hll per day. Now we can ask for the cardinality of the hll for each day:

sql

SELECT date, hll_cardinality(users) FROM daily_uniques;

You're probably thinking, "But I could have done this with COUNT DISTINCT!" And you're right, you could have. But then you only ever answer a single question: "How many unique users did I see each day?"

What if you wanted to this week's uniques?

sql

SELECT hll_cardinality(hll_union_agg(users)) FROM daily_uniques WHERE date >= '2012-01-02'::date AND date = '2012-01-01' AND
      date log2m). Note that increasing `log2m` by 1 doubles the required storage for the `hll`.

### `regwidth` ###

The number of bits used per register in the HyperLogLog algorithm. Must be at least 1 and at most 8. This parameter, in conjunction with `log2m`, tunes the maximum cardinality of the set whose cardinality can be estimated. For clarity, we've provided a table of `regwidth`s and `log2m`s and the approximate maximum cardinality that can be estimated with those parameters. (The size of the resulting structure is provided as well.)

    
        logm2regwidth=1regwidth=2regwidth=3regwidth=4regwidth=5regwidth=6
    
    

107.4e+02 &nbsp;&nbsp;128B3.0e+03 &nbsp;&nbsp;256B4.7e+04 &nbsp;&nbsp;384B1.2e+07 &nbsp;&nbsp;512B7.9e+11 &nbsp;&nbsp;640B3.4e+21 &nbsp;&nbsp;768B

111.5e+03 &nbsp;&nbsp;256B5.9e+03 &nbsp;&nbsp;512B9.5e+04 &nbsp;&nbsp;768B2.4e+07 &nbsp;&nbsp;1.0KB1.6e+12 &nbsp;&nbsp;1.2KB6.8e+21 &nbsp;&nbsp;1.5KB

123.0e+03 &nbsp;&nbsp;512B1.2e+04 &nbsp;&nbsp;1.0KB1.9e+05 &nbsp;&nbsp;1.5KB4.8e+07 &nbsp;&nbsp;2.0KB3.2e+12 &nbsp;&nbsp;2.5KB1.4e+22 &nbsp;&nbsp;3KB

135.9e+03 &nbsp;&nbsp;1.0KB2.4e+04 &nbsp;&nbsp;2.0KB3.8e+05 &nbsp;&nbsp;3KB9.7e+07 &nbsp;&nbsp;4KB6.3e+12 &nbsp;&nbsp;5KB2.7e+22 &nbsp;&nbsp;6KB

141.2e+04 &nbsp;&nbsp;2.0KB4.7e+04 &nbsp;&nbsp;4KB7.6e+05 &nbsp;&nbsp;6KB1.9e+08 &nbsp;&nbsp;8KB1.3e+13 &nbsp;&nbsp;10KB5.4e+22 &nbsp;&nbsp;12KB

152.4e+04 &nbsp;&nbsp;4KB9.5e+04 &nbsp;&nbsp;8KB1.5e+06 &nbsp;&nbsp;12KB3.9e+08 &nbsp;&nbsp;16KB2.5e+13 &nbsp;&nbsp;20KB1.1e+23 &nbsp;&nbsp;24KB

164.7e+04 &nbsp;&nbsp;8KB1.9e+05 &nbsp;&nbsp;16KB3.0e+06 &nbsp;&nbsp;24KB7.7e+08 &nbsp;&nbsp;32KB5.1e+13 &nbsp;&nbsp;40KB2.2e+23 &nbsp;&nbsp;48KB

179.5e+04 &nbsp;&nbsp;16KB3.8e+05 &nbsp;&nbsp;32KB6.0e+06 &nbsp;&nbsp;48KB1.5e+09 &nbsp;&nbsp;64KB1.0e+14 &nbsp;&nbsp;80KB4.4e+23 &nbsp;&nbsp;96KB

    

### `expthresh` ###

Tunes when the `EXPLICIT` to `SPARSE` promotion occurs, based on the set's cardinality. It is also possible to turn off the use of the `EXPLICIT` representation entirely. If the `EXPLICIT` representation is turned off, the `EMPTY` set is promoted directly to `SPARSE`. Must be -1, 0, or 1-18 inclusive.

    expthresh valueMeaning
    
-1Promote at whatever cutoff makes sense for optimal memory usage. ('auto' mode)

    
0Skip EXPLICIT representation in hierarchy.

    
1-18Promote at 2expthresh - 1 cardinality

You can choose the `EXPLICIT` cutoff such that it will end up taking more memory than a `FULL` `hll` representation. This is allowed for those cases where perfect precision and accuracy are required up through some pre-set cardinality range, after which estimates of the cardinality are sufficient.

**NOTE:** The restriction of `expthresh` to a maximum value of 18 (for the third case in the table above) is an implementation tradeoff between performance and general appeal. If you want access to higher `expthresh` values, let us know in the Issues section and we'll see what we can do.

### `sparseon` ###

Enables or disables the `SPARSE` representation. If both the `EXPLICIT` and `SPARSE` representations are disabled, an `EMPTY` set will be promoted directly to a `FULL` set. If `SPARSE` is enabled, the promotion from `SPARSE` to `FULL` will occur when the internal `SPARSE` representation's memory footprint would exceed that of the `FULL` version. Must be either `0` (zero) or `1` (one). Zero means disabled, one is enabled.

Defaults
--------

In all the examples above, the type `hll` has been used without adornment. This is a shortcut. In reality, the type can have up to 4 arguments. The defaults are shown as well.

    hll(log2m=11, regwidth=5, expthresh=-1, sparseon=1)

You can provide any prefix of the full list of arguments. The named arguments are the same as those mentioned in the 'Explanation of Parameters' section, above. If you'd like to change these (they're hardcoded in the source) look in `hll.c` for `DEFAULT_LOG2M` and that should get you there pretty quickly.

Debugging
---------

`hll_print` is your friend! It will show you all the parameters of the `hll` as well as nicely-formatted representation of the contents.

* * * * * * * * * * * * * * * * * * * * * * * * *

Compatibility
=============

This module has been tested on:

* **Postgres 9.4, 9.5, 9.6, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19-dev**

If you end up needing to change something to get this running on another system, send us the diff and we'll try to work it in!

Note: At the moment postgresql-hll does not work with 32bit systems.

Build
=====

## With `rpmbuild` ##

Specify versions:

    export VER=2.21
    export PGSHRT=11

Make sure `Makefile` points to the correct `pg_config` for the specified version, since `rpmbuild` doesn't respect env variables:

    PG_CONFIG = /usr/pgsql-11/bin/pg_config

Create a tarball from the source tree:

    tar cvfz postgresql${PGSHRT}-hll-${VER}.tar.gz postgresql-hll \
        --transform="s/postgresql-hll/postgresql${PGSHRT}-hll/g"

Execute rpmbuild:

    rpmbuild -tb postgresql${PGSHRT}-hll-${VER}.tar.gz

Install RPM:

    rpm -Uv rpmbuild/RPMS/x86_64/postgresql11-hll-2.21.x86_64.rpm

And if you want the debugging build:

    rpm -Uv rpmbuild/RPMS/x86_64/postgresql11-hll-debuginfo-2.21.x86_64.rpm

## From source ##

If you aren't using the `pg_config` on your path (or don't have it on your path), specify the correct one to build against:

        PG_CONFIG=/usr/pgsql-9.11/bin/pg_config make

Or to build with what's on your path, just:

        make

If you wish to build with an alternate C/C++ compiler, say `gcc`, then you can specify it like so:

        make CC=gcc CXX=gcc

(This may be useful if an older `clang` is the default compiler.)

Or for the debug build:

        DEBUG=1 make

Then install:

        sudo make install

### Troubleshoo