Guides
Types
It is important to use the correct type for encoding columns (e.g., `BIGINT`, `DATE`, `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](#docs:data:csv:auto_detection) 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](https://duckdb.org/2022/10/28/lightweight-compression#bit-packing) 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.  
> **Best practice.  ** Use the most restrictive types possible when creating columns. Avoid using strings for encoding more specific data items.  
#### Microbenchmark: Using Timestamps {#docs:guides:performance:schema::microbenchmark-using-timestamps}  
We illustrate the difference in aggregation speed using the [`creationDate` column of the LDBC Comment table on scale factor 300](https://blobs.duckdb.org/data/ldbc-sf300-comments-creationDate.parquet). 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](#docs:sql:functions:timestamp):  
```sql
SELECT avg(extract('day' FROM creationDate)) FROM Comment;
```  
Second, we use the `VARCHAR` type and use string operations:  
```sql
SELECT avg(CAST(creationDate[9:10] AS INTEGER)) FROM Comment;
```  
The results of the microbenchmark are as follows:  
<div class="narrow_table"></div>  
| Column type | Storage size | Query time |
| ----------- | -----------: | ---------: |
| `DATETIME`  | 3.3 GB       | 0.9 s      |
| `VARCHAR`   | 5.2 GB       | 3.9 s      |  
The results show that using the `DATETIME` value yields smaller storage sizes and faster processing.  
#### Microbenchmark: Joining on Strings {#docs:guides:performance:schema::microbenchmark-joining-on-strings}  
We illustrate the difference caused by joining on different types by computing a self-join on the [LDBC Comment table at scale factor 100](https://blobs.duckdb.org/data/ldbc-sf100-comments.tar.zst). The table has 64-bit integer identifiers used as the `id` attribute of each row. We perform the following join operation:  
```sql
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 `BIGINT`.
In the second experiment, we define all columns with the `VARCHAR` type.
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.  
<div class="narrow_table"></div>  
| Join column payload type | Join column schema type | Example value                            | Query time |
| ------------------------ | ----------------------- | ---------------------------------------- | ---------: |
| `BIGINT`                 | `BIGINT`                | `70368755640078`                         | 1.2 s      |
| `BIGINT`                 | `VARCHAR`               | `'70368755640078'`                       | 2.1 s      |  
> **Best practice.  ** Avoid representing numeric values as strings, especially if you intend to perform e.g., join operations on them.