It is important to use the correct type for encoding columns (e.g.,
DATETIME). While it is always possible to use string types (
VARCHAR, etc.) to encode more specific values, this is not recommended. Strings use more space and are slower to process in operations such as filtering, join, and aggregation.
When loading CSV files, you may leverage the CSV reader’s auto-detection mechanism to get the correct types for CSV inputs.
If you run in a memory-constrained environment, using smaller data types (e.g.,
TINYINT) can reduce the amount of memory and disk space required to complete a query. DuckDB’s bitpacking compression means small values stored in larger data types will not take up larger sizes on disk, but they will take up more memory during processing.
Bestpractice Use the most restrictive types possible when creating columns. Avoid using strings for encoding more specific data items.
We illustrate the difference in aggregation speed using the
creationDate column of the LDBC Comment table on scale factor 300. This table has approx. 554 million unordered timestamp values. We run a simple aggregation query that returns the average day-of-the month from the timestamps in two configurations.
First, we use a
DATETIME to encode the values and run the query using the
extract datetime function:
SELECT avg(extract('day' FROM creationDate)) FROM Comment;
Second, we use the
VARCHAR type and use string operations:
SELECT avg(CAST(creationDate[9:10] AS INT)) FROM Comment;
The results of the microbenchmark are as follows:
The results show that using the
DATETIME value yields smaller storage sizes and faster processing.
We illustrate the difference caused by joining on different types by computing a self-join on the LDBC Comment table at scale factor 100. The table has 64-bit integer identifiers used as the
id attribute of each row. We perform the following join operation:
SELECT count(*) AS count
FROM Comment c1
JOIN Comment c2 ON c1.ParentCommentId = c2.id;
In the first experiment, we use the correct (most restrictive) types, i.e., both the
id and the
ParentCommentId columns are defined as
In the second experiment, we define all columns with the
While the results of the queries are the same for all both experiments, their runtime vary significantly.
The results below show that joining on
BIGINT columns is approx. 1.8× faster than performing the same join on
VARCHAR-typed columns encoding the same value.
|Join Column Payload Type
|Join Column Schema Type
DuckDB allows defining constraints such as
PRIMARY KEY, and
FOREIGN KEY. These constraints can be beneficial for ensuring data integrity but they have a negative effect on load performance as they necessitate building indexes and performing checks. Moreover, they very rarely improve the performance of queries as DuckDB does not rely on these indexes for join and aggregation operators (see indexing for more details).
Bestpractice Do not define constraints unless your goal is to ensure data integrity.
We illustrate the effect of using primary keys with the LDBC Comment table at scale factor 300. This table has approx. 554 million entries. We first create the schema without a primary key, then load the data. In the second experiment, we create the schema with a primary key, then load the data. In both cases, we take the data from
.csv.gz files, and measure the time required to perform the loading.
|Load without primary key
|Load with primary key