Datasets:

duckdb-nsql-hub

/

duckdb-docs

like 4

Follow

DuckDB Text-2-SQL Bench 9

Guides

ODBC

Sample Application

The following is a sample application that includes a `cpp` file that connects to the database, executes a query, fetches the results, and prints them. It also disconnects from the database and frees the handles, and includes a function to check the return value of ODBC functions. It also includes a `CMakeLists.txt` file that can be used to build the application. #### Sample `.cpp` file {#docs:guides:odbc:general::sample-cpp-file} ```cpp #include <iostream> #include <sql.h> #include <sqlext.h> void check_ret(SQLRETURN ret, std::string msg) { if (ret != SQL_SUCCESS && ret != SQL_SUCCESS_WITH_INFO) { std::cout << ret << ": " << msg << " failed" << std::endl; exit(1); } if (ret == SQL_SUCCESS_WITH_INFO) { std::cout << ret << ": " << msg << " succeeded with info" << std::endl; } } int main() { SQLHANDLE env; SQLHANDLE dbc; SQLRETURN ret; ret = SQLAllocHandle(SQL_HANDLE_ENV, SQL_NULL_HANDLE, &env); check_ret(ret, "SQLAllocHandle(env)"); ret = SQLSetEnvAttr(env, SQL_ATTR_ODBC_VERSION, (void*)SQL_OV_ODBC3, 0); check_ret(ret, "SQLSetEnvAttr"); ret = SQLAllocHandle(SQL_HANDLE_DBC, env, &dbc); check_ret(ret, "SQLAllocHandle(dbc)"); std::string dsn = "DSN=duckdbmemory"; ret = SQLConnect(dbc, (SQLCHAR*)dsn.c_str(), SQL_NTS, NULL, 0, NULL, 0); check_ret(ret, "SQLConnect"); std::cout << "Connected!" << std::endl; SQLHANDLE stmt; ret = SQLAllocHandle(SQL_HANDLE_STMT, dbc, &stmt); check_ret(ret, "SQLAllocHandle(stmt)"); ret = SQLExecDirect(stmt, (SQLCHAR*)"SELECT * FROM integers", SQL_NTS); check_ret(ret, "SQLExecDirect(SELECT * FROM integers)"); SQLLEN int_val; SQLLEN null_val; ret = SQLBindCol(stmt, 1, SQL_C_SLONG, &int_val, 0, &null_val); check_ret(ret, "SQLBindCol"); ret = SQLFetch(stmt); check_ret(ret, "SQLFetch"); std::cout << "Value: " << int_val << std::endl; ret = SQLFreeHandle(SQL_HANDLE_STMT, stmt); check_ret(ret, "SQLFreeHandle(stmt)"); ret = SQLDisconnect(dbc); check_ret(ret, "SQLDisconnect"); ret = SQLFreeHandle(SQL_HANDLE_DBC, dbc); check_ret(ret, "SQLFreeHandle(dbc)"); ret = SQLFreeHandle(SQL_HANDLE_ENV, env); check_ret(ret, "SQLFreeHandle(env)"); } ``` #### Sample `CMakelists.txt` file {#docs:guides:odbc:general::sample-cmakeliststxt-file} ```cmake cmake_minimum_required(VERSION 3.25) project(ODBC_Tester_App) set(CMAKE_CXX_STANDARD 17) include_directories(/opt/homebrew/Cellar/unixodbc/2.3.11/include) add_executable(ODBC_Tester_App main.cpp) target_link_libraries(ODBC_Tester_App /duckdb_odbc/libduckdb_odbc.dylib) ```

Guides

Performance

Performance Guide

DuckDB aims to automatically achieve high performance by using well-chosen default configurations and having a forgiving architecture. Of course, there are still opportunities for tuning the system for specific workloads. The Performance Guide's page contain guidelines and tips for achieving good performance when loading and processing data with DuckDB. The guides include several microbenchmarks. You may find details about these on the [Benchmarks page](#docs:guides:performance:benchmarks).

Guides

Performance

Environment

The environment where DuckDB is run has an obvious impact on performance. This page focuses on the effects of the hardware configuration and the operating system used.

Guides

Performance

Hardware Configuration

#### CPU and Memory {#docs:guides:performance:environment::cpu-and-memory} As a rule of thumb, DuckDB requires a **minimum** of 125 MB of memory per thread. For example, if you use 8 threads, you need at least 1 GB of memory. For ideal performance, aggregation-heavy workloads require approx. 5 GB memory per thread and join-heavy workloads require approximately 10 GB memory per thread. > **Best practice. ** Aim for 5-10 GB memory per thread. > **Tip. ** If you have a limited amount of memory, try to [limit the number of threads](#docs:configuration:pragmas::threads), e.g., by issuing `SET threads = 4;`. #### Disk {#docs:guides:performance:environment::disk} DuckDB is capable of operating both as an in-memory and as a disk-based database system. In both cases, it can spill to disk to process larger-than-memory workloads (a.k.a. out-of-core processing) for which a fast disk is highly beneficial. However, if the workload fits in memory, the disk speed only has a limited effect on performance. #### Local Disk {#docs:guides:performance:environment::local-disk} DuckDB's disk-based mode is designed to work best with SSD and NVMe disks. While HDDs are supported, they will result in low performance, especially for write operations. #### Network-Attached Disks {#docs:guides:performance:environment::network-attached-disks} **Cloud disks.** DuckDB runs well on network-backed cloud disks such as [AWS EBS](https://aws.amazon.com/ebs/) for both read-only and read-write workloads. **Network-attached storage.** Network-attached storage can serve DuckdB for read-only workloads. However, _it is not recommended to run DuckDB in read-write mode on network-attached storage (NAS)._ These setups include [NFS](https://en.wikipedia.org/wiki/Network_File_System), network drives such as [SMB](https://en.wikipedia.org/wiki/Server_Message_Block) and [Samba](https://en.wikipedia.org/wiki/Samba_(software)). Based on user reports, running read-write workloads on network-attached storage can result in slow and unpredictable performance, as well as spurious errors cased by the underlying file system. > **Warning. ** Avoid running DuckDB in read-write mode on network-attached storage. > **Best practice. ** Fast disks are important if your workload is larger than memory and/or fast data loading is important. Only use network-backed disks if they are reliable (e.g., cloud disks) and guarantee high IO.

Guides

Performance

Operating System

We recommend using the latest stable version of operating systems: macOS, Windows, and Linux are all well-tested and DuckDB can run on them with high performance. Among Linux distributions, we recommended using Ubuntu Linux LTS due to its stability and the fact that most of DuckDB’s Linux test suite jobs run on Ubuntu workers.

Guides

Performance

Recommended Import Methods

When importing data from other systems to DuckDB, there are several considerations to take into account. We recommend importing using the following order: 1. For systems which are supported by a DuckDB scanner extension, it's preferable to use the scanner. DuckDB currently offers scanners for [MySQL](#docs:guides:database_integration:mysql), [PostgreSQL](#docs:guides:database_integration:postgres), and [SQLite](#docs:guides:database_integration:sqlite). 2. If there is a bulk export feature in the data source system, export the data to Parquet or CSV format, then load it using DuckDB's [Parquet](#docs:guides:file_formats:parquet_import) or [CSV loader](#docs:guides:file_formats:csv_import). 3. If the approaches above are not applicable, consider using the DuckDB [appender](#docs:data:appender), currently available in the C, C++, Go, Java, and Rust APIs. 4. If the data source system supports Apache Arrow and the data transfer is a recurring task, consider using the DuckDB [Arrow](#docs:extensions:arrow) extension.

Guides

Performance

Methods to Avoid

If possible, avoid looping row-by-row (tuple-at-a-time) in favor of bulk operations. Performing row-by-row inserts (even with prepared statements) is detrimental to performance and will result in slow load times. > **Best practice. ** Unless your data is small (<100k rows), avoid using inserts in loops.

Guides

Performance

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.

Guides

Performance

Constraints

DuckDB allows defining [constraints](#docs:sql:constraints) such as `UNIQUE`, `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](#docs:guides:performance:indexing) for more details). > **Best practice. ** Do not define constraints unless your goal is to ensure data integrity. #### Microbenchmark: The Effect of Primary Keys {#docs:guides:performance:schema::microbenchmark-the-effect-of-primary-keys} We illustrate the effect of using primary keys with the [LDBC Comment table at scale factor 300](https://blobs.duckdb.org/data/ldbc-sf300-comments.tar.zst). 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. <div class="narrow_table"></div> | Operation | Execution time | | ------------------------ | -------------: | | Load without primary key | 92.2 s | | Load with primary key | 286.8 s | In this case, primary keys will only have a (small) positive effect on highly selective queries such as when filtering on a single identifier. They do not have an effect on join and aggregation operators. > **Best practice. ** For best bulk load performance, avoid defining primary key constraints if possible.

Guides

Performance

Indexing

DuckDB has two types of indexes: zonemaps and ART indexes.

Guides

Performance

Zonemaps

DuckDB automatically creates [zonemaps](https://en.wikipedia.org/wiki/Block_Range_Index) (also known as min-max indexes) for the columns of all [general-purpose data types](#docs:sql:data_types:overview::general-purpose-data-types). These indexes are used for predicate pushdown into scan operators and computing aggregations. This means that if a filter criterion (like `WHERE column1 = 123`) is in use, DuckDB can skip any row group whose min-max range does not contain that filter value (e.g., a block with a min-max range of 1000 to 2000 will be omitted when comparing for `= 123` or `< 400`). #### The Effect of Ordering on Zonemaps {#docs:guides:performance:indexing::the-effect-of-ordering-on-zonemaps} The more ordered the data within a column, the more useful the zonemap indexes will be. For example, in the worst case, a column could contain a random number on every row. DuckDB will be unlikely to be able to skip any row groups. The best case of ordered data commonly arises with `DATETIME` columns. If specific columns will be queried with selective filters, it is best to pre-order data by those columns when inserting it. Even an imperfect ordering will still be helpful. #### Microbenchmark: The Effect of Ordering {#docs:guides:performance:indexing::microbenchmark-the-effect-of-ordering} For an example, let’s repeat the [microbenchmark for timestamps](#docs:guides:performance:schema::microbenchmark-using-timestamps) with a timestamp column that sorted using an ascending order vs. an unordered one. <div class="narrow_table"></div> | Column type | Ordered | Storage size | Query time | |---|---|--:|--:| | `DATETIME` | yes | 1.3 GB | 0.6 s | | `DATETIME` | no | 3.3 GB | 0.9 s | The results show that simply keeping the column order allows for improved compression, yielding a 2.5× smaller storage size. It also allows the computation to be 1.5× faster. #### Ordered Integers {#docs:guides:performance:indexing::ordered-integers} Another practical way to exploit ordering is to use the `INTEGER` type with automatic increments rather than `UUID` for columns that will be queried using selective filters. `UUID`s will likely be inserted in a random order, so many row groups in the table will need to be scanned to find a specific `UUID` value, while an ordered `INTEGER` column will allow all row groups to be skipped except the one that contains the value.

Guides

Performance

ART Indexes

DuckDB allows defining [Adaptive Radix Tree (ART) indexes](https://db.in.tum.de/~leis/papers/ART.pdf) in two ways. First, such an index is created implicitly for columns with `PRIMARY KEY`, `FOREIGN KEY`, and `UNIQUE` [constraints](#docs:guides:performance:schema::constraints). Second, explicitly running a the [`CREATE INDEX`](#docs:sql:indexes) statement creates an ART index on the target column(s). The tradeoffs of having an ART index on a column are as follows: 1. It enables efficient constraint checking upon changes (inserts, updates, and deletes) for non-bulky changes. 2. Having an ART index makes changes to the affected column(s) slower compared to non-indexed performance. That is because of index maintenance for these operations. Regarding query performance, an ART index has the following effects: 1. It speeds up point queries and other highly selective queries using the indexed column(s), where the filtering condition returns approx. 0.1% of all rows or fewer. When in doubt, use [`EXPLAIN`](#docs:guides:meta:explain) to verify that your query plan uses the index scan. 2. An ART index has no effect on the performance of join, aggregation, and sorting queries. Indexes are serialized to disk and deserialized lazily, i.e., when the database is reopened, operations using the index will only load the required parts of the index. Therefore, having an index will not cause any slowdowns when opening an existing database. > **Best practice. ** We recommend following these guidelines: > > * Only use primary keys, foreign keys, or unique constraints, if these are necessary for enforcing constraints on your data. > * Do not define explicit indexes unless you have highly selective queries. > * If you define an ART index, do so after bulk loading the data to the table. Adding an index prior to loading, either explicitly or via primary/foreign keys, is [detrimental to load performance](#docs:guides:performance:schema::microbenchmark-the-effect-of-primary-keys).

Guides

Performance

How to Force a Join Order

DuckDB has a cost-based query optimizer, which uses statistics in the base tables (stored in a DuckDB database or Parquet files) to estimate the cardinality of operations. #### Turn off the Join Order Optimizer {#docs:guides:performance:join_operations::turn-off-the-join-order-optimizer} To turn off the join order optimizer, set the following [`PRAGMA`s](#docs:configuration:pragmas): ```sql SET disabled_optimizers = 'join_order,build_side_probe_side'; ``` This disables both the join order optimizer and left/right swapping for joins. This way, DuckDB builds a left-deep join tree following the order of `JOIN` clauses. ```sql SELECT … FROM … JOIN … -- this join is performed first JOIN … -- this join is performed second ``` Once the query in question has been executed, turn back the optimizers with the following command: ```sql SET disabled_optimizers = ''; ``` #### Create Temporary Tables {#docs:guides:performance:join_operations::create-temporary-tables} To force a particular join order, you can break up the query into multiple queries with each creating a temporary tables: ```sql CREATE OR REPLACE TEMPORARY TABLE t1 AS …; -- join on the result of the first query, t1 CREATE OR REPLACE TEMPORARY TABLE t2 AS SELECT * FROM t1 …; -- compute the final result using t2 SELECT * FROM t1 … ``` To clean up, drop the interim tables: ```sql DROP TABLE IF EXISTS t1; DROP TABLE IF EXISTS t2; ```

Guides

Performance

Handling Parquet Files

DuckDB has advanced support for Parquet files, which includes [directly querying Parquet files](https://duckdb.org/2021/06/25/querying-parquet). When deciding on whether to query these files directly or to first load them to the database, you need to consider several factors. #### Reasons for Querying Parquet Files {#docs:guides:performance:file_formats::reasons-for-querying-parquet-files} **Availability of basic statistics:** Parquet files use a columnar storage format and contain basic statistics such as [zonemaps](#docs:guides:performance:indexing::zonemaps). Thanks to these features, DuckDB can leverage optimizations such as projection and filter pushdown on Parquet files. Therefore, workloads that combine projection, filtering, and aggregation tend to perform quite well when run on Parquet files. **Storage considerations:** Loading the data from Parquet files will require approximately the same amount of space for the DuckDB database file. Therefore, if the available disk space is constrained, it is worth running the queries directly on Parquet files. #### Reasons against Querying Parquet Files {#docs:guides:performance:file_formats::reasons-against-querying-parquet-files} **Lack of advanced statistics:** The DuckDB database format has the [hyperloglog statistics](https://en.wikipedia.org/wiki/HyperLogLog) that Parquet files do not have. These improve the accuracy of cardinality estimates, and are especially important if the queries contain a large number of join operators. **Tip.** If you find that DuckDB produces a suboptimal join order on Parquet files, try loading the Parquet files to DuckDB tables. The improved statistics likely help obtain a better join order. **Repeated queries:** If you plan to run multiple queries on the same data set, it is worth loading the data into DuckDB. The queries will always be somewhat faster, which over time amortizes the initial load time. **High decompression times:** Some Parquet files are compressed using heavyweight compression algorithms such as gzip. In these cases, querying the Parquet files will necessitate an expensive decompression time every time the file is accessed. Meanwhile, lightweight compression methods like Snappy, LZ4, and zstd, are faster to decompress. You may use the [`parquet_metadata` function](#docs:data:parquet:metadata::parquet-metadata) to find out the compression algorithm used.

Guides

Performance

Handling Parquet Files

Microbenchmark: Running TPC-H on a DuckDB Database vs. Parquet

The queries on the [TPC-H benchmark](#docs:extensions:tpch) run approximately 1.1-5.0× slower on Parquet files than on a DuckDB database. > **Best practice. ** If you have the storage space available, and have a join-heavy workload and/or plan to run many queries on the same dataset, load the Parquet files into the database first. The compression algorithm and the row group sizes in the Parquet files have a large effect on performance: study these using the [`parquet_metadata` function](#docs:data:parquet:metadata::parquet-metadata). #### The Effect of Row Group Sizes {#docs:guides:performance:file_formats::the-effect-of-row-group-sizes} DuckDB works best on Parquet files with row groups of 100K-1M rows each. The reason for this is that DuckDB can only [parallelize over row groups](#docs:guides:performance:how_to_tune_workloads::parallelism-multi-core-processing) – so if a Parquet file has a single giant row group it can only be processed by a single thread. You can use the [`parquet_metadata` function](#docs:data:parquet:metadata::parquet-metadata) to figure out how many row groups a Parquet file has. When writing Parquet files, use the [`row_group_size`](#docs:sql:statements:copy::parquet-options) option.

Guides

Performance

Handling Parquet Files

Microbenchmark: Running Aggregation Query at Different Row Group Sizes

We run a simple aggregation query over Parquet files using different row group sizes, selected between 960 and 1,966,080. The results are as follows. <div class="narrow_table"></div> | Row group size | Execution time | |---------------:|---------------:| | 960 | 8.77 s | | 1920 | 8.95 s | | 3840 | 4.33 s | | 7680 | 2.35 s | | 15360 | 1.58 s | | 30720 | 1.17 s | | 61440 | 0.94 s | | 122880 | 0.87 s | | 245760 | 0.93 s | | 491520 | 0.95 s | | 983040 | 0.97 s | | 1966080 | 0.88 s | The results show that row group sizes <5,000 have a strongly detrimental effect, making runtimes more than 5-10× larger than ideally-sized row groups, while row group sizes between 5,000 and 20,000 are still 1.5-2.5× off from best performance. Above row group size of 100,000, the differences are small: the gap is about 10% between the best and the worst runtime. #### Parquet File Sizes {#docs:guides:performance:file_formats::parquet-file-sizes} DuckDB can also parallelize across multiple Parquet files. It is advisable to have at least as many total row groups across all files as there are CPU threads. For example, with a machine having 10 threads, both 10 files with 1 row group or 1 file with 10 row groups will achieve full parallelism. It is also beneficial to keep the size of individual Parquet files moderate. > **Best practice. ** The ideal range is between 100 MB and 10 GB per individual Parquet file. #### Hive Partitioning for Filter Pushdown {#docs:guides:performance:file_formats::hive-partitioning-for-filter-pushdown} When querying many files with filter conditions, performance can be improved by using a [Hive-format folder structure](#docs:data:partitioning:hive_partitioning) to partition the data along the columns used in the filter condition. DuckDB will only need to read the folders and files that meet the filter criteria. This can be especially helpful when querying remote files. #### More Tips on Reading and Writing Parquet Files {#docs:guides:performance:file_formats::more-tips-on-reading-and-writing-parquet-files} For tips on reading and writing Parquet files, see the [Parquet Tips page](#docs:data:parquet:tips).

Guides

Performance

Loading CSV Files

CSV files are often distributed in compressed format such as GZIP archives (` .csv.gz`). DuckDB can decompress these files on the fly. In fact, this is typically faster than decompressing the files first and loading them due to reduced IO. <div class="narrow_table"></div> | Schema | Load Time | |---|--:| | Load from GZIP-compressed CSV files (` .csv.gz`) | 107.1 s | | Decompressing (using parallel `gunzip`) and loading from decompressed CSV files | 121.3 s | #### Loading Many Small CSV Files {#docs:guides:performance:file_formats::loading-many-small-csv-files} The [CSV reader](#docs:data:csv:overview) runs the [CSV sniffer](https://duckdb.org/2023/10/27/csv-sniffer) on all files. For many small files, this may cause an unnecessarily high overhead. A potential optimization to speed this up is to turn the sniffer off. Assuming that all files have the same CSV dialect and colum names/types, get the sniffer options as follows: ```sql .mode line SELECT Prompt FROM sniff_csv('part-0001.csv'); ``` ```text Prompt = FROM read_csv('file_path.csv', auto_detect=false, delim=',', quote='"', escape='"', new_line='\n', skip=0, header=true, columns={'hello': 'BIGINT', 'world': 'VARCHAR'}); ``` Then, you can adjust `read_csv` command, by e.g., applying [filename expansion (globbing)](#docs:sql:functions:pattern_matching::globbing), and run with the rest of the options detected by the sniffer: ```sql FROM read_csv('part-*.csv', auto_detect=false, delim=',', quote='"', escape='"', new_line='\n', skip=0, header=true, columns={'hello': 'BIGINT', 'world': 'VARCHAR'}); ```

Guides

Performance

Parallelism (Multi-Core Processing)

#### The Effect of Row Groups on Parallelism {#docs:guides:performance:how_to_tune_workloads::the-effect-of-row-groups-on-parallelism} DuckDB parallelizes the workload based on _[row groups](#docs:internals:storage::row-groups),_ i.e., groups of rows that are stored together at the storage level. A row group in DuckDB's database format consists of max. 122,880 rows. Parallelism starts at the level of row groups, therefore, for a query to run on _k_ threads, it needs to scan at least _k_ * 122,880 rows. #### Too Many Threads {#docs:guides:performance:how_to_tune_workloads::too-many-threads} Note that in certain cases DuckDB may launch _too many threads_ (e.g., due to HyperThreading), which can lead to slowdowns. In these cases, it’s worth manually limiting the number of threads using [`SET threads = X`](#docs:configuration:pragmas::threads).

Guides

Performance

Larger-Than-Memory Workloads (Out-of-Core Processing)

A key strength of DuckDB is support for larger-than-memory workloads, i.e., it is able to process data sets that are larger than the available system memory (also known as _out-of-core processing_). It can also run queries where the intermediate results cannot fit into memory. This section explains the prerequisites, scope, and known limitations of larger-than-memory processing in DuckDB. #### Spilling to Disk {#docs:guides:performance:how_to_tune_workloads::spilling-to-disk} Larger-than-memory workloads are supported by spilling to disk. With the default configuration, DuckDB creates the `⟨database_file_name⟩.tmp` temporary directory (in persistent mode) or the `.tmp` directory (in in-memory mode). This directory can be changed using the [`temp_directory` configuration option](#docs:configuration:pragmas::temp-directory-for-spilling-data-to-disk), e.g.: ```sql SET temp_directory = '/path/to/temp_dir.tmp/'; ``` #### Blocking Operators {#docs:guides:performance:how_to_tune_workloads::blocking-operators} Some operators cannot output a single row until the last row of their input has been seen. These are called _blocking operators_ as they require their entire input to be buffered, and are the most memory-intensive operators in relational database systems. The main blocking operators are the following: * _sorting:_ [`ORDER BY`](#docs:sql:query_syntax:orderby) * _grouping:_ [`GROUP BY`](#docs:sql:query_syntax:groupby) * _windowing:_ [`OVER ... (PARTITION BY ... ORDER BY ...)`](#docs:sql:functions:window_functions) * _joining:_ [`JOIN`](#docs:sql:query_syntax:from::joins) DuckDB supports larger-than-memory processing for all of these operators. #### Limitations {#docs:guides:performance:how_to_tune_workloads::limitations} DuckDB strives to always complete workloads even if they are larger-than-memory. That said, there are some limitations at the moment: * If multiple blocking operators appear in the same query, DuckDB may still throw an out-of-memory exception due to the complex interplay of these operators. * Some [aggregate functions](#docs:sql:functions:aggregates), such as `list()` and `string_agg()`, do not support offloading to disk. * [Aggregate functions that use sorting](#docs:sql:functions:aggregates::order-by-clause-in-aggregate-functions) are holistic, i.e., they need all inputs before the aggregation can start. As DuckDB cannot yet offload some complex intermediate aggregate states to disk, these functions can cause an out-of-memory exception when run on large data sets. * The `PIVOT` operation [internally uses the `list()` function](#docs:sql:statements:pivot::internals), therefore it is subject to the same limitation.

Guides

Performance

Profiling

If your queries are not performing as well as expected, it’s worth studying their query plans: * Use [`EXPLAIN`](#docs:guides:meta:explain) to print the physical query plan without running the query. * Use [`EXPLAIN ANALYZE`](#docs:guides:meta:explain_analyze) to run and profile the query. This will show the CPU time that each step in the query takes. Note that due to multi-threading, adding up the individual times will be larger than the total query processing time. Query plans can point to the root of performance issues. A few general directions: * Avoid nested loop joins in favor of hash joins. * A scan that does not include a filter pushdown for a filter condition that is later applied performs unnecessary IO. Try rewriting the query to apply a pushdown. * Bad join orders where the cardinality of an operator explodes to billions of tuples should be avoided at all costs.

Guides

Performance

Prepared Statements

[Prepared statements](#docs:sql:query_syntax:prepared_statements) can improve performance when running the same query many times, but with different parameters. When a statement is prepared, it completes several of the initial portions of the query execution process (parsing, planning, etc.) and caches their output. When it is executed, those steps can be skipped, improving performance. This is beneficial mostly for repeatedly running small queries (with a runtime of < 100ms) with different sets of parameters. Note that it is not a primary design goal for DuckDB to quickly execute many small queries concurrently. Rather, it is optimized for running larger, less frequent queries.

Guides

Performance

Querying Remote Files

DuckDB uses synchronous IO when reading remote files. This means that each DuckDB thread can make at most one HTTP request at a time. If a query must make many small requests over the network, increasing DuckDB's [`threads` setting](#docs:configuration:pragmas::threads) to larger than the total number of CPU cores (approx. 2-5 times CPU cores) can improve parallelism and performance. #### Avoid Reading Unnecessary Data {#docs:guides:performance:how_to_tune_workloads::avoid-reading-unnecessary-data} The main bottleneck in workloads reading remote files is likely to be the IO. This means that minimizing the unnecessarily read data can be highly beneficial. Some basic SQL tricks can help with this: * Avoid `SELECT *`. Instead, only select columns that are actually used. DuckDB will try to only download the data it actually needs. * Apply filters on remote parquet files when possible. DuckDB can use these filters to reduce the amount of data that is scanned. * Either [sort](#docs:sql:query_syntax:orderby) or [partition](#docs:data:partitioning:partitioned_writes) data by columns that are regularly used for filters: this increases the effectiveness of the filters in reducing IO. To inspect how much remote data is transferred for a query, [`EXPLAIN ANALYZE`](#docs:guides:meta:explain_analyze) can be used to print out the total number of requests and total data transferred for queries on remote files. #### Avoid Reading Data More Than Once {#docs:guides:performance:how_to_tune_workloads::avoid-reading-data-more-than-once} DuckDB does not cache data from remote files automatically. This means that running a query on a remote file twice will download the required data twice. So if data needs to be accessed multiple times, storing it locally can make sense. To illustrate this, lets look at an example: Consider the following queries: ```sql SELECT col_a + col_b FROM 's3://bucket/file.parquet' WHERE col_a > 10; SELECT col_a * col_b FROM 's3://bucket/file.parquet' WHERE col_a > 10; ``` These queries download the columns `col_a` and `col_b` from `s3://bucket/file.parquet` twice. Now consider the following queries: ```sql CREATE TABLE local_copy_of_file AS SELECT col_a, col_b FROM 's3://bucket/file.parquet' WHERE col_a > 10; SELECT col_a + col_b FROM local_copy_of_file; SELECT col_a * col_b FROM local_copy_of_file; ``` Here DuckDB will first copy `col_a` and `col_b` from `s3://bucket/file.parquet` into a local table, and then query the local in-memory columns twice. Note also that the filter `WHERE col_a > 10` is also now applied only once. An important side note needs to be made here though. The first two queries are fully streaming, with only a small memory footprint, whereas the second requires full materialization of columns `col_a` and `col_b`. This means that in some rare cases (e.g., with a high-speed network, but with very limited memory available) it could actually be beneficial to download the data twice.

Guides

Performance

Best Practices for Using Connections

DuckDB will perform best when reusing the same database connection many times. Disconnecting and reconnecting on every query will incur some overhead, which can reduce performance when running many small queries. DuckDB also caches some data and metadata in memory, and that cache is lost when the last open connection is closed. Frequently, a single connection will work best, but a connection pool may also be used. Using multiple connections can parallelize some operations, although it is typically not necessary. DuckDB does attempt to parallelize as much as possible within each individual query, but it is not possible to parallelize in all cases. Making multiple connections can process more operations concurrently. This can be more helpful if DuckDB is not CPU limited, but instead bottlenecked by another resource like network transfer speed.

Guides

Performance

The `preserve_insertion_order` Option

When importing or exporting data sets (from/to the Parquet or CSV formats), which are much larger than the available memory, an out of memory error may occur: ```console Error: Out of Memory Error: failed to allocate data of size ... (.../... used) ``` In these cases, consider setting the [`preserve_insertion_order` configuration option](#docs:configuration:overview) to `false`: ```sql SET preserve_insertion_order = false; ``` This allows the systems to re-order any results that do not contain `ORDER BY` clauses, potentially reducing memory usage.

Guides

Performance

Persistent vs. In-Memory Tables

DuckDB supports [lightweight compression techniques](https://duckdb.org/2022/10/28/lightweight-compression). Currently, these are only applied on persistent (on-disk) databases. DuckDB does not compress its in-memory tables. The reason for this is that compression is performed during checkpointing, and in-memory tables are not checkpointed. In rare cases, this can result in unintuitive performance results where queries are faster on on-disk tables compared to in-memory ones. For example, Q1 of the [TPC-H workload](#docs:extensions:tpch) is faster when running on-disk compared to the in-memory mode: ```sql INSTALL tpch; LOAD tpch; CALL dbgen(sf = 30); .timer on PRAGMA tpch(1); ``` | Database setup | Execution time | |---------------------|---------------:| | In-memory database | 4.80 s | | Persistent database | 0.57 s |

Guides

Performance

My Workload Is Slow

If you find that your workload in DuckDB is slow, we recommend performing the following checks. More detailed instructions are linked for each point. 1. Do you have enough memory? DuckDB works best if you have [5-10 GB memory per CPU core](#docs:guides:performance:environment::cpu-and-memory). 1. Are you using a fast disk? Network-attached disks (such as cloud block storage) cause write-intenstive and[larger than memory](#docs:guides:performance:how_to_tune_workloads::spilling-to-disk) workloads to slow down. For running such workloads in cloud environments, it is recommended to use instance-attached storage (NVMe SSDs). 1. Are you using indexes or constraints (primary key, unique, etc.)? If possible, try [disabling them](#docs:guides:performance:schema::indexing), which boosts load and update performance. 1. Are you using the correct types? For example, [use `TIMESTAMP` to encode datetime values](#docs:guides:performance:schema::types). 1. Are you reading from Parquet files? If so, do they have [row group sizes between 100k and 1M](#docs:guides:performance:file_formats::the-effect-of-row-group-sizes) and file sizes between 100 MB to 10 GB? 1. Does the query plan look right? Study it with [`EXPLAIN`](#docs:guides:performance:how_to_tune_workloads::profiling). 1. Is the workload running [in parallel](#docs:guides:performance:how_to_tune_workloads::parallelism)? Use `htop` or the operating system's task manager to observe this. 1. Is DuckDB using too many threads? Try [limiting the amount of threads](#docs:guides:performance:how_to_tune_workloads::parallelism-multi-core-processing). Are you aware of other common issues? If so, please click the _Report content issue_ link below and describe them along with their workarounds.

Guides

Performance

Benchmarks

For several of the recommendations in our performance guide, we use microbenchmarks to back up our claims. For these benchmarks, we use data sets from the [TPC-H benchmark](#docs:extensions:tpch) and the [LDBC Social Network Benchmark’s BI workload](https://github.com/ldbc/ldbc_snb_bi/blob/main/snb-bi-pre-generated-data-sets.md#compressed-csvs-in-the-composite-merged-fk-format). <!--

Guides

Performance

Benchmark Environment

The benchmarks in the performance guide executed on a 2022 MacBook Pro with a 12-core M2 Pro CPU, 32 GiB RAM and 1 TB disk. -->

Guides

Performance

Data Sets

We use the [LDBC BI SF300 data set's Comment table](https://blobs.duckdb.org/data/ldbc-sf300-comments.tar.zst) (20 GB `.tar.zst` archive, 21 GB when decompressed into `.csv.gz` files), while others use the same table's [`creationDate` column](https://blobs.duckdb.org/data/ldbc-sf300-comments-creationDate.parquet) (4 GB `.parquet` file). The TPC data sets used in the benchmark are generated with the DuckDB [tpch extension](#docs:extensions:tpch).

Guides

Performance

A Note on Benchmarks

Running [fair benchmarks is difficult](https://hannes.muehleisen.org/publications/DBTEST2018-performance-testing.pdf), especially when performing system-to-system comparison. When running benchmarks on DuckDB, please make sure you are using the latest version (preferably the [nightly build](https://duckdb.org/docs/installation/index.html?version=main)). If in doubt about your benchmark results, feel free to contact us at `gabor@duckdb.org`.

Guides

Performance

Disclaimer on Benchmarks

Note that the benchmark results presented in this guide do not constitute official TPC or LDBC benchmark results. Instead, they merely use the data sets of and some queries provided by the TPC-H and the LDBC BI benchmark frameworks, and omit other parts of the workloads such as updates.

Guides

Python

Installing via Pip

The latest release of the Python client can be installed using `pip`. ```bash pip install duckdb ``` The pre-release Python client can be installed using `--pre`. ```bash pip install duckdb --upgrade --pre ```

Guides

Python

Installing from Source

The latest Python client can be installed from source from the [`tools/pythonpkg` directory in the DuckDB GitHub repository](https://github.com/duckdb/duckdb/tree/main/tools/pythonpkg). ```batch BUILD_PYTHON=1 GEN=ninja make cd tools/pythonpkg python setup.py install ``` For detailed instructions on how to compile DuckDB from source, see the [Building guide](#docs:dev:building:build_instructions).

Guides

Python

Executing SQL in Python

SQL queries can be executed using the `duckdb.sql` function. ```python import duckdb duckdb.sql("SELECT 42").show() ``` By default this will create a relation object. The result can be converted to various formats using the result conversion functions. For example, the `fetchall` method can be used to convert the result to Python objects. ```python results = duckdb.sql("SELECT 42").fetchall() print(results) ``` ```text [(42,)] ``` Several other result objects exist. For example, you can use `df` to convert the result to a Pandas DataFrame. ```python results = duckdb.sql("SELECT 42").df() print(results) ``` ```text 42 0 42 ``` By default, a global in-memory connection will be used. Any data stored in files will be lost after shutting down the program. A connection to a persistent database can be created using the `connect` function. After connecting, SQL queries can be executed using the `sql` command. ```python con = duckdb.connect("file.db") con.sql("CREATE TABLE integers (i INTEGER)") con.sql("INSERT INTO integers VALUES (42)") con.sql("SELECT * FROM integers").show() ```

Guides

Python

Jupyter Notebooks

DuckDB's Python client can be used directly in Jupyter notebooks with no additional configuration if desired. However, additional libraries can be used to simplify SQL query development. This guide will describe how to utilize those additional libraries. See other guides in the Python section for how to use DuckDB and Python together. In this example, we use the [JupySQL](https://github.com/ploomber/jupysql) package. This example workflow is also available as a [Google Colab notebook](https://colab.research.google.com/drive/1eOA2FYHqEfZWLYssbUxdIpSL3PFxWVjk?usp=sharing).

Guides

Python

Library Installation

Four additional libraries improve the DuckDB experience in Jupyter notebooks. 1. [jupysql](https://github.com/ploomber/jupysql): Convert a Jupyter code cell into a SQL cell 2. [Pandas](https://github.com/pandas-dev/pandas): Clean table visualizations and compatibility with other analysis 3. [matplotlib](https://github.com/matplotlib/matplotlib): Plotting with Python 4. [duckdb-engine (DuckDB SQLAlchemy driver)](https://github.com/Mause/duckdb_engine): Used by SQLAlchemy to connect to DuckDB (optional) Run these `pip install` commands from the command line if Jupyter Notebook is not yet installed. Otherwise, see Google Colab link above for an in-notebook example: ```bash pip install duckdb ``` Install Jupyter Notebook ```bash pip install notebook ``` Or JupyterLab: ```bash pip install jupyterlab ``` Install supporting libraries: ```bash pip install jupysql pandas matplotlib duckdb-engine ```

Guides

Python

Library Import and Configuration

Open a Jupyter Notebook and import the relevant libraries. #### Connecting to DuckDB Natively {#docs:guides:python:jupyter::connecting-to-duckdb-natively} To connect to DuckDB, run: ```python import duckdb import pandas as pd %load_ext sql conn = duckdb.connect() %sql conn --alias duckdb ``` #### Connecting to DuckDB via SQLAlchemy Using `duckdb_engine` {#docs:guides:python:jupyter::connecting-to-duckdb-via-sqlalchemy-using-duckdb_engine} Alternatively, you can connect to DuckDB via SQLAlchemy using `duckdb_engine`. See the [performance and feature differences](https://jupysql.ploomber.io/en/latest/tutorials/duckdb-native-sqlalchemy.html). ```python import duckdb import pandas as pd # No need to import duckdb_engine # jupysql will auto-detect the driver needed based on the connection string! # Import jupysql Jupyter extension to create SQL cells %load_ext sql ``` Set configurations on jupysql to directly output data to Pandas and to simplify the output that is printed to the notebook. ```python %config SqlMagic.autopandas = True %config SqlMagic.feedback = False %config SqlMagic.displaycon = False ``` Connect jupysql to DuckDB using a SQLAlchemy-style connection string. Either connect to a new [in-memory DuckDB](#docs:api:python:dbapi::in-memory-connection), the [default connection](#docs:api:python:dbapi::default-connection) or a file backed database: ```sql %sql duckdb:///:memory: ``` ```sql %sql duckdb:///:default: ``` ```sql %sql duckdb:///path/to/file.db ``` > The `%sql` command and `duckdb.sql` share the same [default connection](#docs:api:python:dbapi) if you provide `duckdb:///:default:` as the SQLAlchemy connection string.

Guides

Python

Querying DuckDB

Single line SQL queries can be run using `%sql` at the start of a line. Query results will be displayed as a Pandas DataFrame. ```sql %sql SELECT 'Off and flying!' AS a_duckdb_column; ``` An entire Jupyter cell can be used as a SQL cell by placing `%%sql` at the start of the cell. Query results will be displayed as a Pandas DataFrame. ```sql %%sql SELECT schema_name, function_name FROM duckdb_functions() ORDER BY ALL DESC LIMIT 5; ``` To store the query results in a Python variable, use `<<` as an assignment operator. This can be used with both the `%sql` and `%%sql` Jupyter magics. ```sql %sql res << SELECT 'Off and flying!' AS a_duckdb_column; ``` If the `%config SqlMagic.autopandas = True` option is set, the variable is a Pandas dataframe, otherwise, it is a `ResultSet` that can be converted to Pandas with the `DataFrame()` function.

Guides

Python

Querying Pandas Dataframes

DuckDB is able to find and query any dataframe stored as a variable in the Jupyter notebook. ```python input_df = pd.DataFrame.from_dict({"i": [1, 2, 3], "j": ["one", "two", "three"]}) ``` The dataframe being queried can be specified just like any other table in the `FROM` clause. ```sql %sql output_df << SELECT sum(i) AS total_i FROM input_df; ```

Guides

Python

Visualizing DuckDB Data

The most common way to plot datasets in Python is to load them using Pandas and then use matplotlib or seaborn for plotting. This approach requires loading all data into memory which is highly inefficient. The plotting module in JupySQL runs computations in the SQL engine. This delegates memory management to the engine and ensures that intermediate computations do not keep eating up memory, efficiently plotting massive datasets. #### Install and Load DuckDB httpfs Extension {#docs:guides:python:jupyter::install-and-load-duckdb-httpfs-extension} DuckDB's [httpfs extension](#docs:extensions:httpfs:overview) allows Parquet and CSV files to be queried remotely over http. These examples query a Parquet file that contains historical taxi data from NYC. Using the Parquet format allows DuckDB to only pull the rows and columns into memory that are needed rather than downloading the entire file. DuckDB can be used to process local [Parquet files](#docs:data:parquet:overview) as well, which may be desirable if querying the entire Parquet file, or running multiple queries that require large subsets of the file. ```sql %%sql INSTALL httpfs; LOAD httpfs; ``` #### Boxplot & Histogram {#docs:guides:python:jupyter::boxplot--histogram} To create a boxplot, call `%sqlplot boxplot`, passing the name of the table and the column to plot. In this case, the name of the table is the URL of the remotely stored Parquet file. ```python %sqlplot boxplot --table https://d37ci6vzurychx.cloudfront.net/trip-data/yellow_tripdata_2021-01.parquet --column trip_distance ```  Now, create a query that filters by the 90th percentile. Note the use of the `--save`, and `--no-execute` functions. This tells JupySQL to store the query, but skips execution. It will be referenced in the next plotting call. ```sql %%sql --save short_trips --no-execute SELECT * FROM 'https://d37ci6vzurychx.cloudfront.net/trip-data/yellow_tripdata_2021-01.parquet' WHERE trip_distance < 6.3 ``` To create a histogram, call `%sqlplot histogram` and pass the name of the table, the column to plot, and the number of bins. This uses `--with short-trips` so JupySQL uses the query defined previously and therefore only plots a subset of the data. ```python %sqlplot histogram --table short_trips --column trip_distance --bins 10 --with short_trips ``` 

Guides

Python

Summary

You now have the ability to alternate between SQL and Pandas in a simple and highly performant way! You can plot massive datasets directly through the engine (avoiding both the download of the entire file and loading all of it into Pandas in memory). Dataframes can be read as tables in SQL, and SQL results can be output into Dataframes. Happy analyzing!

Guides

Python

SQL on Pandas

Pandas DataFrames stored in local variables can be queried as if they are regular tables within DuckDB. ```python import duckdb import pandas # Create a Pandas dataframe my_df = pandas.DataFrame.from_dict({'a': [42]}) # query the Pandas DataFrame "my_df" # Note: duckdb.sql connects to the default in-memory database connection results = duckdb.sql("SELECT * FROM my_df").df() ``` The seamless integration of Pandas DataFrames to DuckDB SQL queries is allowed by [replacement scans](#docs:api:c:replacement_scans), which replace instances of accessing the `my_df` table (which does not exist in DuckDB) with a table function that reads the `my_df` dataframe.

Guides

Python

Import from Pandas

[`CREATE TABLE ... AS`]({% link docs/sql/statements/create_table.md %}#create-table--as-select-ctas) and [`INSERT INTO`](#docs:sql:statements:insert) can be used to create a table from any query. We can then create tables or insert into existing tables by referring to referring to the [Pandas](https://pandas.pydata.org/) DataFrame in the query. There is no need to register the DataFrames manually – DuckDB can find them in the Python process by name thanks to [replacement scans](#docs:guides:glossary::replacement-scan). ```python import duckdb import pandas # Create a Pandas dataframe my_df = pandas.DataFrame.from_dict({'a': [42]}) # create the table "my_table" from the DataFrame "my_df" # Note: duckdb.sql connects to the default in-memory database connection duckdb.sql("CREATE TABLE my_table AS SELECT * FROM my_df") # insert into the table "my_table" from the DataFrame "my_df" duckdb.sql("INSERT INTO my_table SELECT * FROM my_df") ``` If the order of columns is different or not all columns are present in the DataFrame, use [`INSERT INTO ... BY NAME`](#docs:sql:statements:insert::insert-into--by-name): ```python duckdb.sql("INSERT INTO my_table BY NAME SELECT * FROM my_df") ```

Guides

Python

See Also

DuckDB also supports [exporting to Pandas](#docs:guides:python:export_pandas).

Guides

Python

Export to Pandas

The result of a query can be converted to a [Pandas](https://pandas.pydata.org/) DataFrame using the `df()` function. ```python import duckdb # read the result of an arbitrary SQL query to a Pandas DataFrame results = duckdb.sql("SELECT 42").df() results ``` ```text 42 0 42 ```

Guides

Python

See Also

DuckDB also supports [importing from Pandas](#docs:guides:python:import_pandas).

Guides

Python

Import from Numpy

It is possible to query Numpy arrays from DuckDB. There is no need to register the arrays manually – DuckDB can find them in the Python process by name thanks to [replacement scans](#docs:guides:glossary::replacement-scan). For example: ```python import duckdb import numpy as np my_arr = np.array([(1, 9.0), (2, 8.0), (3, 7.0)]) duckdb.sql("SELECT * FROM my_arr") ``` ```text ┌─────────┬─────────┬─────────┐ │ column0 │ column1 │ column2 │ │ double │ double │ double │ ├─────────┼─────────┼─────────┤ │ 1.0 │ 2.0 │ 3.0 │ │ 9.0 │ 8.0 │ 7.0 │ └─────────┴─────────┴─────────┘ ```

Guides

Python

See Also

DuckDB also supports [exporting to Numpy](#docs:guides:python:export_numpy).

Guides

Python

Export to Numpy

The result of a query can be converted to a Numpy array using the `fetchnumpy()` function. For example: ```python import duckdb import numpy as np my_arr = duckdb.sql("SELECT unnest([1, 2, 3]) AS x, 5.0 AS y").fetchnumpy() my_arr ``` ```text {'x': array([1, 2, 3], dtype=int32), 'y': masked_array(data=[5.0, 5.0, 5.0], mask=[False, False, False], fill_value=1e+20)} ``` Then, the array can be processed using Numpy functions, e.g.: ```python np.sum(my_arr['x']) ``` ```text 6 ```

Guides

Python

See Also

DuckDB also supports [importing from Numpy](#docs:guides:python:import_numpy).

Guides

Python

SQL on Apache Arrow

DuckDB can query multiple different types of Apache Arrow objects.

Guides

Python

Apache Arrow Tables

[Arrow Tables](https://arrow.apache.org/docs/python/generated/pyarrow.Table.html) stored in local variables can be queried as if they are regular tables within DuckDB. ```python import duckdb import pyarrow as pa # connect to an in-memory database con = duckdb.connect() my_arrow_table = pa.Table.from_pydict({'i': [1, 2, 3, 4], 'j': ["one", "two", "three", "four"]}) # query the Apache Arrow Table "my_arrow_table" and return as an Arrow Table results = con.execute("SELECT * FROM my_arrow_table WHERE i = 2").arrow() ```

Guides

Python

Apache Arrow Datasets

[Arrow Datasets](https://arrow.apache.org/docs/python/dataset.html) stored as variables can also be queried as if they were regular tables. Datasets are useful to point towards directories of Parquet files to analyze large datasets. DuckDB will push column selections and row filters down into the dataset scan operation so that only the necessary data is pulled into memory. ```python import duckdb import pyarrow as pa import tempfile import pathlib import pyarrow.parquet as pq import pyarrow.dataset as ds # connect to an in-memory database con = duckdb.connect() my_arrow_table = pa.Table.from_pydict({'i': [1, 2, 3, 4], 'j': ["one", "two", "three", "four"]}) # create example Parquet files and save in a folder base_path = pathlib.Path(tempfile.gettempdir()) (base_path / "parquet_folder").mkdir(exist_ok = True) pq.write_to_dataset(my_arrow_table, str(base_path / "parquet_folder")) # link to Parquet files using an Arrow Dataset my_arrow_dataset = ds.dataset(str(base_path / 'parquet_folder/')) # query the Apache Arrow Dataset "my_arrow_dataset" and return as an Arrow Table results = con.execute("SELECT * FROM my_arrow_dataset WHERE i = 2").arrow() ```

Guides

Python

Apache Arrow Scanners

[Arrow Scanners](https://arrow.apache.org/docs/python/generated/pyarrow.dataset.Scanner.html) stored as variables can also be queried as if they were regular tables. Scanners read over a dataset and select specific columns or apply row-wise filtering. This is similar to how DuckDB pushes column selections and filters down into an Arrow Dataset, but using Arrow compute operations instead. Arrow can use asynchronous IO to quickly access files. ```python import duckdb import pyarrow as pa import tempfile import pathlib import pyarrow.parquet as pq import pyarrow.dataset as ds import pyarrow.compute as pc # connect to an in-memory database con = duckdb.connect() my_arrow_table = pa.Table.from_pydict({'i': [1, 2, 3, 4], 'j': ["one", "two", "three", "four"]}) # create example Parquet files and save in a folder base_path = pathlib.Path(tempfile.gettempdir()) (base_path / "parquet_folder").mkdir(exist_ok = True) pq.write_to_dataset(my_arrow_table, str(base_path / "parquet_folder")) # link to Parquet files using an Arrow Dataset my_arrow_dataset = ds.dataset(str(base_path / 'parquet_folder/')) # define the filter to be applied while scanning # equivalent to "WHERE i = 2" scanner_filter = (pc.field("i") == pc.scalar(2)) arrow_scanner = ds.Scanner.from_dataset(my_arrow_dataset, filter = scanner_filter) # query the Apache Arrow scanner "arrow_scanner" and return as an Arrow Table results = con.execute("SELECT * FROM arrow_scanner").arrow() ```

Guides

Python

Apache Arrow RecordBatchReaders

[Arrow RecordBatchReaders](https://arrow.apache.org/docs/python/generated/pyarrow.RecordBatchReader.html) are a reader for Arrow's streaming binary format and can also be queried directly as if they were tables. This streaming format is useful when sending Arrow data for tasks like interprocess communication or communicating between language runtimes. ```python import duckdb import pyarrow as pa # connect to an in-memory database con = duckdb.connect() my_recordbatch = pa.RecordBatch.from_pydict({'i': [1, 2, 3, 4], 'j': ["one", "two", "three", "four"]}) my_recordbatchreader = pa.ipc.RecordBatchReader.from_batches(my_recordbatch.schema, [my_recordbatch]) # query the Apache Arrow RecordBatchReader "my_recordbatchreader" and return as an Arrow Table results = con.execute("SELECT * FROM my_recordbatchreader WHERE i = 2").arrow() ```

Guides

Python

Import from Apache Arrow

`CREATE TABLE AS` and `INSERT INTO` can be used to create a table from any query. We can then create tables or insert into existing tables by referring to referring to the Apache Arrow object in the query. This example imports from an [Arrow Table](https://arrow.apache.org/docs/python/generated/pyarrow.Table.html), but DuckDB can query different Apache Arrow formats as seen in the [SQL on Arrow guide](#docs:guides:python:sql_on_arrow). ```python import duckdb import pyarrow as pa # connect to an in-memory database my_arrow = pa.Table.from_pydict({'a': [42]}) # create the table "my_table" from the DataFrame "my_arrow" duckdb.sql("CREATE TABLE my_table AS SELECT * FROM my_arrow") # insert into the table "my_table" from the DataFrame "my_arrow" duckdb.sql("INSERT INTO my_table SELECT * FROM my_arrow") ```

Guides

Python

Export to Apache Arrow

All results of a query can be exported to an [Apache Arrow Table](https://arrow.apache.org/docs/python/generated/pyarrow.Table.html) using the `arrow` function. Alternatively, results can be returned as a [RecordBatchReader](https://arrow.apache.org/docs/python/generated/pyarrow.ipc.RecordBatchStreamReader.html) using the `fetch_record_batch` function and results can be read one batch at a time. In addition, relations built using DuckDB's [Relational API](#docs:guides:python:relational_api_pandas) can also be exported.

Guides

Python

Export to an Arrow Table

```python import duckdb import pyarrow as pa my_arrow_table = pa.Table.from_pydict({'i': [1, 2, 3, 4], 'j': ["one", "two", "three", "four"]}) # query the Apache Arrow Table "my_arrow_table" and return as an Arrow Table results = duckdb.sql("SELECT * FROM my_arrow_table").arrow() ```

Guides

Python

Export as a RecordBatchReader

```python import duckdb import pyarrow as pa my_arrow_table = pa.Table.from_pydict({'i': [1, 2, 3, 4], 'j': ["one", "two", "three", "four"]}) # query the Apache Arrow Table "my_arrow_table" and return as an Arrow RecordBatchReader chunk_size = 1_000_000 results = duckdb.sql("SELECT * FROM my_arrow_table").fetch_record_batch(chunk_size) # Loop through the results. A StopIteration exception is thrown when the RecordBatchReader is empty while True: try: # Process a single chunk here (just printing as an example) print(results.read_next_batch().to_pandas()) except StopIteration: print('Already fetched all batches') break ```

Guides

Python

Export from Relational API

Arrow objects can also be exported from the Relational API. A relation can be converted to an Arrow table using the `arrow` or `to_arrow_table` functions, or a record batch using `record_batch`. A result can be exported to an Arrow table with `arrow` or the alias `fetch_arrow_table`, or to a RecordBatchReader using `fetch_arrow_reader`. ```python import duckdb # connect to an in-memory database con = duckdb.connect() con.execute('CREATE TABLE integers (i integer)') con.execute('INSERT INTO integers VALUES (0), (1), (2), (3), (4), (5), (6), (7), (8), (9), (NULL)') # Create a relation from the table and export the entire relation as Arrow rel = con.table("integers") relation_as_arrow = rel.arrow() # or .to_arrow_table() # Or, calculate a result using that relation and export that result to Arrow res = rel.aggregate("sum(i)").execute() result_as_arrow = res.arrow() # or fetch_arrow_table() ```

Guides

Python

Relational API on Pandas

DuckDB offers a relational API that can be used to chain together query operations. These are lazily evaluated so that DuckDB can optimize their execution. These operators can act on Pandas DataFrames, DuckDB tables or views (which can point to any underlying storage format that DuckDB can read, such as CSV or Parquet files, etc.). Here we show a simple example of reading from a Pandas DataFrame and returning a DataFrame. ```python import duckdb import pandas # connect to an in-memory database con = duckdb.connect() input_df = pandas.DataFrame.from_dict({'i': [1, 2, 3, 4], 'j': ["one", "two", "three", "four"]}) # create a DuckDB relation from a dataframe rel = con.from_df(input_df) # chain together relational operators (this is a lazy operation, so the operations are not yet executed) # equivalent to: SELECT i, j, i*2 AS two_i FROM input_df WHERE i >= 2 ORDER BY i DESC LIMIT 2 transformed_rel = rel.filter('i >= 2').project('i, j, i*2 AS two_i').order('i DESC').limit(2) # trigger execution by requesting .df() of the relation # .df() could have been added to the end of the chain above - it was separated for clarity output_df = transformed_rel.df() ``` Relational operators can also be used to group rows, aggregate, find distinct combinations of values, join, union, and more. They are also able to directly insert results into a DuckDB table or write to a CSV. Please see [these additional examples](https://github.com/duckdb/duckdb/blob/main/examples/python/duckdb-python.py) and [the available relational methods on the `DuckDBPyRelation` class](#docs:api:python:reference:index::duckdb.DuckDBPyRelation).

Guides

Python

Multiple Python Threads

This page demonstrates how to simultaneously insert into and read from a DuckDB database across multiple Python threads. This could be useful in scenarios where new data is flowing in and an analysis should be periodically re-run. Note that this is all within a single Python process (see the [FAQ](#faq) for details on DuckDB concurrency). Feel free to follow along in this [Google Colab notebook](https://colab.research.google.com/drive/190NB2m-LIfDcMamCY5lIzaD2OTMnYclB?usp=sharing).

Guides

Python

Setup

First, import DuckDB and several modules from the Python standard library. Note: if using Pandas, add `import pandas` at the top of the script as well (as it must be imported prior to the multi-threading). Then connect to a file-backed DuckDB database and create an example table to store inserted data. This table will track the name of the thread that completed the insert and automatically insert the timestamp when that insert occurred using the [`DEFAULT` expression](#docs:sql:statements:create_table::syntax). ```python import duckdb from threading import Thread, current_thread import random duckdb_con = duckdb.connect('my_peristent_db.duckdb') # Use connect without parameters for an in-memory database # duckdb_con = duckdb.connect() duckdb_con.execute(""" CREATE OR REPLACE TABLE my_inserts ( thread_name VARCHAR, insert_time TIMESTAMP DEFAULT current_timestamp ) """) ```

Guides

Python

Reader and Writer Functions

Next, define functions to be executed by the writer and reader threads. Each thread must use the `.cursor()` method to create a thread-local connection to the same DuckDB file based on the original connection. This approach also works with in-memory DuckDB databases. ```python def write_from_thread(duckdb_con): # Create a DuckDB connection specifically for this thread local_con = duckdb_con.cursor() # Insert a row with the name of the thread. insert_time is auto-generated. thread_name = str(current_thread().name) result = local_con.execute(""" INSERT INTO my_inserts (thread_name) VALUES (?) """, (thread_name,)).fetchall() def read_from_thread(duckdb_con): # Create a DuckDB connection specifically for this thread local_con = duckdb_con.cursor() # Query the current row count thread_name = str(current_thread().name) results = local_con.execute(""" SELECT ? AS thread_name, count(*) AS row_counter, current_timestamp FROM my_inserts """, (thread_name,)).fetchall() print(results) ```

Guides

Python

Create Threads

We define how many writers and readers to use, and define a list to track all of the threads that will be created. Then, create first writer and then reader threads. Next, shuffle them so that they will be kicked off in a random order to simulate simultaneous writers and readers. Note that the threads have not yet been executed, only defined. ```python write_thread_count = 50 read_thread_count = 5 threads = [] # Create multiple writer and reader threads (in the same process) # Pass in the same connection as an argument for i in range(write_thread_count): threads.append(Thread(target = write_from_thread, args = (duckdb_con,), name = 'write_thread_' + str(i))) for j in range(read_thread_count): threads.append(Thread(target = read_from_thread, args = (duckdb_con,), name = 'read_thread_' + str(j))) # Shuffle the threads to simulate a mix of readers and writers random.seed(6) # Set the seed to ensure consistent results when testing random.shuffle(threads) ```

Guides

Python

Run Threads and Show Results

Now, kick off all threads to run in parallel, then wait for all of them to finish before printing out the results. Note that the timestamps of readers and writers are interspersed as expected due to the randomization. ```python # Kick off all threads in parallel for thread in threads: thread.start() # Ensure all threads complete before printing final results for thread in threads: thread.join() print(duckdb_con.execute(""" SELECT * FROM my_inserts ORDER BY insert_time """).df()) ```

Guides

Python

Integration with Ibis

[Ibis](https://ibis-project.org) is a Python dataframe library that supports 20+ backends, with DuckDB as the default. Ibis with DuckDB provides a Pythonic interface for SQL with great performance.

Guides

Python

Installation

You can pip install Ibis with the DuckDB backend: ```bash pip install 'ibis-framework[duckdb,examples]' # examples is only required to access the sample data Ibis provides ``` or use conda: ```bash conda install ibis-framework ``` or use mamba: ```bash mamba install ibis-framework ```

Guides

Python

Create a Database File

Ibis can work with several file types, but at its core, it connects to existing databases and interacts with the data there. You can get started with your own DuckDB databases or create a new one with example data. ```python import ibis con = ibis.connect("duckdb://penguins.ddb") con.create_table( "penguins", ibis.examples.penguins.fetch().to_pyarrow(), overwrite = True ) ``` ```python # Output: DatabaseTable: penguins species string island string bill_length_mm float64 bill_depth_mm float64 flipper_length_mm int64 body_mass_g int64 sex string year int64 ``` You can now see the example dataset copied over to the database: ```python # reconnect to the persisted database (dropping temp tables) con = ibis.connect("duckdb://penguins.ddb") con.list_tables() ``` ```python # Output: ['penguins'] ``` There's one table, called `penguins`. We can ask Ibis to give us an object that we can interact with. ```python penguins = con.table("penguins") penguins ``` ```text # Output: DatabaseTable: penguins species string island string bill_length_mm float64 bill_depth_mm float64 flipper_length_mm int64 body_mass_g int64 sex string year int64 ``` Ibis is lazily evaluated, so instead of seeing the data, we see the schema of the table. To peek at the data, we can call `head` and then `to_pandas` to get the first few rows of the table as a pandas DataFrame. ```python penguins.head().to_pandas() ``` ```text species island bill_length_mm bill_depth_mm flipper_length_mm body_mass_g sex year 0 Adelie Torgersen 39.1 18.7 181.0 3750.0 male 2007 1 Adelie Torgersen 39.5 17.4 186.0 3800.0 female 2007 2 Adelie Torgersen 40.3 18.0 195.0 3250.0 female 2007 3 Adelie Torgersen NaN NaN NaN NaN None 2007 4 Adelie Torgersen 36.7 19.3 193.0 3450.0 female 2007 ``` `to_pandas` takes the existing lazy table expression and evaluates it. If we leave it off, you'll see the Ibis representation of the table expression that `to_pandas` will evaluate (when you're ready!). ```python penguins.head() ``` ```python # Output: r0 := DatabaseTable: penguins species string island string bill_length_mm float64 bill_depth_mm float64 flipper_length_mm int64 body_mass_g int64 sex string year int64 Limit[r0, n=5] ``` Ibis returns results as a pandas DataFrame using `to_pandas`, but isn't using pandas to perform any of the computation. The query is executed by DuckDB. Only when `to_pandas` is called does Ibis then pull back the results and convert them into a DataFrame.

Guides

Python

Interactive Mode

For the rest of this intro, we'll turn on interactive mode, which partially executes queries to give users a preview of the results. There is a small difference in the way the output is formatted, but otherwise this is the same as calling `to_pandas` on the table expression with a limit of 10 result rows returned. ```python ibis.options.interactive = True penguins.head() ``` ```text ┏━━━━━━━━━┳━━━━━━━━━━━┳━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━┳━━━━━━━━┳━━━━━━━┓ ┃ species ┃ island ┃ bill_length_mm ┃ bill_depth_mm ┃ flipper_length_mm ┃ body_mass_g ┃ sex ┃ year ┃ ┡━━━━━━━━━╇━━━━━━━━━━━╇━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━╇━━━━━━━━╇━━━━━━━┩ │ string │ string │ float64 │ float64 │ int64 │ int64 │ string │ int64 │ ├─────────┼───────────┼────────────────┼───────────────┼───────────────────┼─────────────┼────────┼───────┤ │ Adelie │ Torgersen │ 39.1 │ 18.7 │ 181 │ 3750 │ male │ 2007 │ │ Adelie │ Torgersen │ 39.5 │ 17.4 │ 186 │ 3800 │ female │ 2007 │ │ Adelie │ Torgersen │ 40.3 │ 18.0 │ 195 │ 3250 │ female │ 2007 │ │ Adelie │ Torgersen │ nan │ nan │ NULL │ NULL │ NULL │ 2007 │ │ Adelie │ Torgersen │ 36.7 │ 19.3 │ 193 │ 3450 │ female │ 2007 │ └─────────┴───────────┴────────────────┴───────────────┴───────────────────┴─────────────┴────────┴───────┘ ```

Guides

Python

Common Operations

Ibis has a collection of useful table methods to manipulate and query the data in a table. #### filter {#docs:guides:python:ibis::filter} `filter` allows you to select rows based on a condition or set of conditions. We can filter so we only have penguins of the species Adelie: ```python penguins.filter(penguins.species == "Gentoo") ``` ```text ┏━━━━━━━━━┳━━━━━━━━┳━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━┳━━━━━━━━┳━━━━━━━┓ ┃ species ┃ island ┃ bill_length_mm ┃ bill_depth_mm ┃ flipper_length_mm ┃ body_mass_g ┃ sex ┃ year ┃ ┡━━━━━━━━━╇━━━━━━━━╇━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━╇━━━━━━━━╇━━━━━━━┩ │ string │ string │ float64 │ float64 │ int64 │ int64 │ string │ int64 │ ├─────────┼────────┼────────────────┼───────────────┼───────────────────┼─────────────┼────────┼───────┤ │ Gentoo │ Biscoe │ 46.1 │ 13.2 │ 211 │ 4500 │ female │ 2007 │ │ Gentoo │ Biscoe │ 50.0 │ 16.3 │ 230 │ 5700 │ male │ 2007 │ │ Gentoo │ Biscoe │ 48.7 │ 14.1 │ 210 │ 4450 │ female │ 2007 │ │ Gentoo │ Biscoe │ 50.0 │ 15.2 │ 218 │ 5700 │ male │ 2007 │ │ Gentoo │ Biscoe │ 47.6 │ 14.5 │ 215 │ 5400 │ male │ 2007 │ │ Gentoo │ Biscoe │ 46.5 │ 13.5 │ 210 │ 4550 │ female │ 2007 │ │ Gentoo │ Biscoe │ 45.4 │ 14.6 │ 211 │ 4800 │ female │ 2007 │ │ Gentoo │ Biscoe │ 46.7 │ 15.3 │ 219 │ 5200 │ male │ 2007 │ │ Gentoo │ Biscoe │ 43.3 │ 13.4 │ 209 │ 4400 │ female │ 2007 │ │ Gentoo │ Biscoe │ 46.8 │ 15.4 │ 215 │ 5150 │ male │ 2007 │ │ … │ … │ … │ … │ … │ … │ … │ … │ └─────────┴────────┴────────────────┴───────────────┴───────────────────┴─────────────┴────────┴───────┘ ``` Or filter for Gentoo penguins that have a body mass larger than 6 kg. ```python penguins.filter((penguins.species == "Gentoo") & (penguins.body_mass_g > 6000)) ``` ```text ┏━━━━━━━━━┳━━━━━━━━┳━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━┳━━━━━━━━┳━━━━━━━┓ ┃ species ┃ island ┃ bill_length_mm ┃ bill_depth_mm ┃ flipper_length_mm ┃ body_mass_g ┃ sex ┃ year ┃ ┡━━━━━━━━━╇━━━━━━━━╇━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━╇━━━━━━━━╇━━━━━━━┩ │ string │ string │ float64 │ float64 │ int64 │ int64 │ string │ int64 │ ├─────────┼────────┼────────────────┼───────────────┼───────────────────┼─────────────┼────────┼───────┤ │ Gentoo │ Biscoe │ 49.2 │ 15.2 │ 221 │ 6300 │ male │ 2007 │ │ Gentoo │ Biscoe │ 59.6 │ 17.0 │ 230 │ 6050 │ male │ 2007 │ └─────────┴────────┴────────────────┴───────────────┴───────────────────┴─────────────┴────────┴───────┘ ``` You can use any Boolean comparison in a filter (although if you try to do something like use `<` on a string, Ibis will yell at you). #### select {#docs:guides:python:ibis::select} Your data analysis might not require all the columns present in a given table. `select` lets you pick out only those columns that you want to work with. To select a column you can use the name of the column as a string: ```python penguins.select("species", "island", "year").limit(3) ``` ```text ┏━━━━━━━━━┳━━━━━━━━━━━┳━━━━━━━┓ ┃ species ┃ island ┃ year ┃ ┡━━━━━━━━━╇━━━━━━━━━━━╇━━━━━━━┩ │ string │ string │ int64 │ ├─────────┼───────────┼───────┤ │ Adelie │ Torgersen │ 2007 │ │ Adelie │ Torgersen │ 2007 │ │ Adelie │ Torgersen │ 2007 │ │ … │ … │ … │ └─────────┴───────────┴───────┘ ``` Or you can use column objects directly (this can be convenient when paired with tab-completion): ```python penguins.select(penguins.species, penguins.island, penguins.year).limit(3) ``` ```text ┏━━━━━━━━━┳━━━━━━━━━━━┳━━━━━━━┓ ┃ species ┃ island ┃ year ┃ ┡━━━━━━━━━╇━━━━━━━━━━━╇━━━━━━━┩ │ string │ string │ int64 │ ├─────────┼───────────┼───────┤ │ Adelie │ Torgersen │ 2007 │ │ Adelie │ Torgersen │ 2007 │ │ Adelie │ Torgersen │ 2007 │ │ … │ … │ … │ └─────────┴───────────┴───────┘ ``` Or you can mix-and-match: ```python penguins.select("species", "island", penguins.year).limit(3) ``` ```text ┏━━━━━━━━━┳━━━━━━━━━━━┳━━━━━━━┓ ┃ species ┃ island ┃ year ┃ ┡━━━━━━━━━╇━━━━━━━━━━━╇━━━━━━━┩ │ string │ string │ int64 │ ├─────────┼───────────┼───────┤ │ Adelie │ Torgersen │ 2007 │ │ Adelie │ Torgersen │ 2007 │ │ Adelie │ Torgersen │ 2007 │ │ … │ … │ … │ └─────────┴───────────┴───────┘ ``` #### mutate {#docs:guides:python:ibis::mutate} `mutate` lets you add new columns to your table, derived from the values of existing columns. ```python penguins.mutate(bill_length_cm=penguins.bill_length_mm / 10) ``` ```text ┏━━━━━━━━━┳━━━━━━━━━━━┳━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━┳━━━━━━━━┳━━━━━━━┳━━━━━━━━━━━━━━━━┓ ┃ species ┃ island ┃ bill_length_mm ┃ bill_depth_mm ┃ flipper_length_mm ┃ body_mass_g ┃ sex ┃ year ┃ bill_length_cm ┃ ┡━━━━━━━━━╇━━━━━━━━━━━╇━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━╇━━━━━━━━╇━━━━━━━╇━━━━━━━━━━━━━━━━┩ │ string │ string │ float64 │ float64 │ int64 │ int64 │ string │ int64 │ float64 │ ├─────────┼───────────┼────────────────┼───────────────┼───────────────────┼─────────────┼────────┼───────┼────────────────┤ │ Adelie │ Torgersen │ 39.1 │ 18.7 │ 181 │ 3750 │ male │ 2007 │ 3.91 │ │ Adelie │ Torgersen │ 39.5 │ 17.4 │ 186 │ 3800 │ female │ 2007 │ 3.95 │ │ Adelie │ Torgersen │ 40.3 │ 18.0 │ 195 │ 3250 │ female │ 2007 │ 4.03 │ │ Adelie │ Torgersen │ nan │ nan │ NULL │ NULL │ NULL │ 2007 │ nan │ │ Adelie │ Torgersen │ 36.7 │ 19.3 │ 193 │ 3450 │ female │ 2007 │ 3.67 │ │ Adelie │ Torgersen │ 39.3 │ 20.6 │ 190 │ 3650 │ male │ 2007 │ 3.93 │ │ Adelie │ Torgersen │ 38.9 │ 17.8 │ 181 │ 3625 │ female │ 2007 │ 3.89 │ │ Adelie │ Torgersen │ 39.2 │ 19.6 │ 195 │ 4675 │ male │ 2007 │ 3.92 │ │ Adelie │ Torgersen │ 34.1 │ 18.1 │ 193 │ 3475 │ NULL │ 2007 │ 3.41 │ │ Adelie │ Torgersen │ 42.0 │ 20.2 │ 190 │ 4250 │ NULL │ 2007 │ 4.20 │ │ … │ … │ … │ … │ … │ … │ … │ … │ … │ └─────────┴───────────┴────────────────┴───────────────┴───────────────────┴─────────────┴────────┴───────┴────────────────┘ ``` Notice that the table is a little too wide to display all the columns now (depending on your screen-size). `bill_length` is now present in millimeters _and_ centimeters. Use a `select` to trim down the number of columns we're looking at. ```python penguins.mutate(bill_length_cm=penguins.bill_length_mm / 10).select( "species", "island", "bill_depth_mm", "flipper_length_mm", "body_mass_g", "sex", "year", "bill_length_cm", ) ``` ```text ┏━━━━━━━━━┳━━━━━━━━━━━┳━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━┳━━━━━━━━┳━━━━━━━┳━━━━━━━━━━━━━━━━┓ ┃ species ┃ island ┃ bill_depth_mm ┃ flipper_length_mm ┃ body_mass_g ┃ sex ┃ year ┃ bill_length_cm ┃ ┡━━━━━━━━━╇━━━━━━━━━━━╇━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━╇━━━━━━━━╇━━━━━━━╇━━━━━━━━━━━━━━━━┩ │ string │ string │ float64 │ int64 │ int64 │ string │ int64 │ float64 │ ├─────────┼───────────┼───────────────┼───────────────────┼─────────────┼────────┼───────┼────────────────┤ │ Adelie │ Torgersen │ 18.7 │ 181 │ 3750 │ male │ 2007 │ 3.91 │ │ Adelie │ Torgersen │ 17.4 │ 186 │ 3800 │ female │ 2007 │ 3.95 │ │ Adelie │ Torgersen │ 18.0 │ 195 │ 3250 │ female │ 2007 │ 4.03 │ │ Adelie │ Torgersen │ nan │ NULL │ NULL │ NULL │ 2007 │ nan │ │ Adelie │ Torgersen │ 19.3 │ 193 │ 3450 │ female │ 2007 │ 3.67 │ │ Adelie │ Torgersen │ 20.6 │ 190 │ 3650 │ male │ 2007 │ 3.93 │ │ Adelie │ Torgersen │ 17.8 │ 181 │ 3625 │ female │ 2007 │ 3.89 │ │ Adelie │ Torgersen │ 19.6 │ 195 │ 4675 │ male │ 2007 │ 3.92 │ │ Adelie │ Torgersen │ 18.1 │ 193 │ 3475 │ NULL │ 2007 │ 3.41 │ │ Adelie │ Torgersen │ 20.2 │ 190 │ 4250 │ NULL │ 2007 │ 4.20 │ │ … │ … │ … │ … │ … │ … │ … │ … │ └─────────┴───────────┴───────────────┴───────────────────┴─────────────┴────────┴───────┴────────────────┘ ``` #### selectors {#docs:guides:python:ibis::selectors} Typing out _all_ of the column names _except_ one is a little annoying. Instead of doing that again, we can use a `selector` to quickly select or deselect groups of columns. ```python import ibis.selectors as s penguins.mutate(bill_length_cm=penguins.bill_length_mm / 10).select( ~s.matches("bill_length_mm") # match every column except `bill_length_mm` ) ``` ```text ┏━━━━━━━━━┳━━━━━━━━━━━┳━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━┳━━━━━━━━┳━━━━━━━┳━━━━━━━━━━━━━━━━┓ ┃ species ┃ island ┃ bill_depth_mm ┃ flipper_length_mm ┃ body_mass_g ┃ sex ┃ year ┃ bill_length_cm ┃ ┡━━━━━━━━━╇━━━━━━━━━━━╇━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━╇━━━━━━━━╇━━━━━━━╇━━━━━━━━━━━━━━━━┩ │ string │ string │ float64 │ int64 │ int64 │ string │ int64 │ float64 │ ├─────────┼───────────┼───────────────┼───────────────────┼─────────────┼────────┼───────┼────────────────┤ │ Adelie │ Torgersen │ 18.7 │ 181 │ 3750 │ male │ 2007 │ 3.91 │ │ Adelie │ Torgersen │ 17.4 │ 186 │ 3800 │ female │ 2007 │ 3.95 │ │ Adelie │ Torgersen │ 18.0 │ 195 │ 3250 │ female │ 2007 │ 4.03 │ │ Adelie │ Torgersen │ nan │ NULL │ NULL │ NULL │ 2007 │ nan │ │ Adelie │ Torgersen │ 19.3 │ 193 │ 3450 │ female │ 2007 │ 3.67 │ │ Adelie │ Torgersen │ 20.6 │ 190 │ 3650 │ male │ 2007 │ 3.93 │ │ Adelie │ Torgersen │ 17.8 │ 181 │ 3625 │ female │ 2007 │ 3.89 │ │ Adelie │ Torgersen │ 19.6 │ 195 │ 4675 │ male │ 2007 │ 3.92 │ │ Adelie │ Torgersen │ 18.1 │ 193 │ 3475 │ NULL │ 2007 │ 3.41 │ │ Adelie │ Torgersen │ 20.2 │ 190 │ 4250 │ NULL │ 2007 │ 4.20 │ │ … │ … │ … │ … │ … │ … │ … │ … │ └─────────┴───────────┴───────────────┴───────────────────┴─────────────┴────────┴───────┴────────────────┘ ``` You can also use a `selector` alongside a column name. ```python penguins.select("island", s.numeric()) ``` ```text ┏━━━━━━━━━━━┳━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━┳━━━━━━━┓ ┃ island ┃ bill_length_mm ┃ bill_depth_mm ┃ flipper_length_mm ┃ body_mass_g ┃ year ┃ ┡━━━━━━━━━━━╇━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━╇━━━━━━━┩ │ string │ float64 │ float64 │ int64 │ int64 │ int64 │ ├───────────┼────────────────┼───────────────┼───────────────────┼─────────────┼───────┤ │ Torgersen │ 39.1 │ 18.7 │ 181 │ 3750 │ 2007 │ │ Torgersen │ 39.5 │ 17.4 │ 186 │ 3800 │ 2007 │ │ Torgersen │ 40.3 │ 18.0 │ 195 │ 3250 │ 2007 │ │ Torgersen │ nan │ nan │ NULL │ NULL │ 2007 │ │ Torgersen │ 36.7 │ 19.3 │ 193 │ 3450 │ 2007 │ │ Torgersen │ 39.3 │ 20.6 │ 190 │ 3650 │ 2007 │ │ Torgersen │ 38.9 │ 17.8 │ 181 │ 3625 │ 2007 │ │ Torgersen │ 39.2 │ 19.6 │ 195 │ 4675 │ 2007 │ │ Torgersen │ 34.1 │ 18.1 │ 193 │ 3475 │ 2007 │ │ Torgersen │ 42.0 │ 20.2 │ 190 │ 4250 │ 2007 │ │ … │ … │ … │ … │ … │ … │ └───────────┴────────────────┴───────────────┴───────────────────┴─────────────┴───────┘ ``` You can read more about [`selectors`](https://ibis-project.org/reference/selectors/) in the docs! #### `order_by` {#docs:guides:python:ibis::order_by} `order_by` arranges the values of one or more columns in ascending or descending order. By default, `ibis` sorts in ascending order: ```python penguins.order_by(penguins.flipper_length_mm).select( "species", "island", "flipper_length_mm" ) ``` ```text ┏━━━━━━━━━━━┳━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━┓ ┃ species ┃ island ┃ flipper_length_mm ┃ ┡━━━━━━━━━━━╇━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━┩ │ string │ string │ int64 │ ├───────────┼───────────┼───────────────────┤ │ Adelie │ Biscoe │ 172 │ │ Adelie │ Biscoe │ 174 │ │ Adelie │ Torgersen │ 176 │ │ Adelie │ Dream │ 178 │ │ Adelie │ Dream │ 178 │ │ Adelie │ Dream │ 178 │ │ Chinstrap │ Dream │ 178 │ │ Adelie │ Dream │ 179 │ │ Adelie │ Torgersen │ 180 │ │ Adelie │ Biscoe │ 180 │ │ … │ … │ … │ └───────────┴───────────┴───────────────────┘ ``` You can sort in descending order using the `desc` method of a column: ```python penguins.order_by(penguins.flipper_length_mm.desc()).select( "species", "island", "flipper_length_mm" ) ``` ```text ┏━━━━━━━━━┳━━━━━━━━┳━━━━━━━━━━━━━━━━━━━┓ ┃ species ┃ island ┃ flipper_length_mm ┃ ┡━━━━━━━━━╇━━━━━━━━╇━━━━━━━━━━━━━━━━━━━┩ │ string │ string │ int64 │ ├─────────┼────────┼───────────────────┤ │ Gentoo │ Biscoe │ 231 │ │ Gentoo │ Biscoe │ 230 │ │ Gentoo │ Biscoe │ 230 │ │ Gentoo │ Biscoe │ 230 │ │ Gentoo │ Biscoe │ 230 │ │ Gentoo │ Biscoe │ 230 │ │ Gentoo │ Biscoe │ 230 │ │ Gentoo │ Biscoe │ 230 │ │ Gentoo │ Biscoe │ 229 │ │ Gentoo │ Biscoe │ 229 │ │ … │ … │ … │ └─────────┴────────┴───────────────────┘ ``` Or you can use `ibis.desc` ```python penguins.order_by(ibis.desc("flipper_length_mm")).select( "species", "island", "flipper_length_mm" ) ``` ```text ┏━━━━━━━━━┳━━━━━━━━┳━━━━━━━━━━━━━━━━━━━┓ ┃ species ┃ island ┃ flipper_length_mm ┃ ┡━━━━━━━━━╇━━━━━━━━╇━━━━━━━━━━━━━━━━━━━┩ │ string │ string │ int64 │ ├─────────┼────────┼───────────────────┤ │ Gentoo │ Biscoe │ 231 │ │ Gentoo │ Biscoe │ 230 │ │ Gentoo │ Biscoe │ 230 │ │ Gentoo │ Biscoe │ 230 │ │ Gentoo │ Biscoe │ 230 │ │ Gentoo │ Biscoe │ 230 │ │ Gentoo │ Biscoe │ 230 │ │ Gentoo │ Biscoe │ 230 │ │ Gentoo │ Biscoe │ 229 │ │ Gentoo │ Biscoe │ 229 │ │ … │ … │ … │ └─────────┴────────┴───────────────────┘ ``` #### aggregate {#docs:guides:python:ibis::aggregate} Ibis has several aggregate functions available to help summarize data. `mean`, `max`, `min`, `count`, `sum` (the list goes on). To aggregate an entire column, call the corresponding method on that column. ```python penguins.flipper_length_mm.mean() ``` ```python # Output: 200.91520467836258 ``` You can compute multiple aggregates at once using the `aggregate` method: ```python penguins.aggregate([penguins.flipper_length_mm.mean(), penguins.bill_depth_mm.max()]) ``` ```text ┏━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━┓ ┃ Mean(flipper_length_mm) ┃ Max(bill_depth_mm) ┃ ┡━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━┩ │ float64 │ float64 │ ├─────────────────────────┼────────────────────┤ │ 200.915205 │ 21.5 │ └─────────────────────────┴────────────────────┘ ``` But `aggregate` _really_ shines when it's paired with `group_by`. #### `group_by` {#docs:guides:python:ibis::group_by} `group_by` creates groupings of rows that have the same value for one or more columns. But it doesn't do much on its own -- you can pair it with `aggregate` to get a result. ```python penguins.group_by("species").aggregate() ``` ```text ┏━━━━━━━━━━━┓ ┃ species ┃ ┡━━━━━━━━━━━┩ │ string │ ├───────────┤ │ Adelie │ │ Gentoo │ │ Chinstrap │ └───────────┘ ``` We grouped by the `species` column and handed it an “empty” aggregate command. The result of that is a column of the unique values in the `species` column. If we add a second column to the `group_by`, we'll get each unique pairing of the values in those columns. ```python penguins.group_by(["species", "island"]).aggregate() ``` ```text ┏━━━━━━━━━━━┳━━━━━━━━━━━┓ ┃ species ┃ island ┃ ┡━━━━━━━━━━━╇━━━━━━━━━━━┩ │ string │ string │ ├───────────┼───────────┤ │ Adelie │ Torgersen │ │ Adelie │ Biscoe │ │ Adelie │ Dream │ │ Gentoo │ Biscoe │ │ Chinstrap │ Dream │ └───────────┴───────────┘ ``` Now, if we add an aggregation function to that, we start to really open things up. ```python penguins.group_by(["species", "island"]).aggregate(penguins.bill_length_mm.mean()) ``` ```text ┏━━━━━━━━━━━┳━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━┓ ┃ species ┃ island ┃ Mean(bill_length_mm) ┃ ┡━━━━━━━━━━━╇━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━┩ │ string │ string │ float64 │ ├───────────┼───────────┼──────────────────────┤ │ Adelie │ Torgersen │ 38.950980 │ │ Adelie │ Biscoe │ 38.975000 │ │ Adelie │ Dream │ 38.501786 │ │ Gentoo │ Biscoe │ 47.504878 │ │ Chinstrap │ Dream │ 48.833824 │ └───────────┴───────────┴──────────────────────┘ ``` By adding that `mean` to the `aggregate`, we now have a concise way to calculate aggregates over each of the distinct groups in the `group_by`. And we can calculate as many aggregates as we need. ```python penguins.group_by(["species", "island"]).aggregate( [penguins.bill_length_mm.mean(), penguins.flipper_length_mm.max()] ) ``` ```text ┏━━━━━━━━━━━┳━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━┓ ┃ species ┃ island ┃ Mean(bill_length_mm) ┃ Max(flipper_length_mm) ┃ ┡━━━━━━━━━━━╇━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━┩ │ string │ string │ float64 │ int64 │ ├───────────┼───────────┼──────────────────────┼────────────────────────┤ │ Adelie │ Torgersen │ 38.950980 │ 210 │ │ Adelie │ Biscoe │ 38.975000 │ 203 │ │ Adelie │ Dream │ 38.501786 │ 208 │ │ Gentoo │ Biscoe │ 47.504878 │ 231 │ │ Chinstrap │ Dream │ 48.833824 │ 212 │ └───────────┴───────────┴──────────────────────┴────────────────────────┘ ``` If we need more specific groups, we can add to the `group_by`. ```python penguins.group_by(["species", "island", "sex"]).aggregate( [penguins.bill_length_mm.mean(), penguins.flipper_length_mm.max()] ) ``` ```text ┏━━━━━━━━━┳━━━━━━━━━━━┳━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━┓ ┃ species ┃ island ┃ sex ┃ Mean(bill_length_mm) ┃ Max(flipper_length_mm) ┃ ┡━━━━━━━━━╇━━━━━━━━━━━╇━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━┩ │ string │ string │ string │ float64 │ int64 │ ├─────────┼───────────┼────────┼──────────────────────┼────────────────────────┤ │ Adelie │ Torgersen │ male │ 40.586957 │ 210 │ │ Adelie │ Torgersen │ female │ 37.554167 │ 196 │ │ Adelie │ Torgersen │ NULL │ 37.925000 │ 193 │ │ Adelie │ Biscoe │ female │ 37.359091 │ 199 │ │ Adelie │ Biscoe │ male │ 40.590909 │ 203 │ │ Adelie │ Dream │ female │ 36.911111 │ 202 │ │ Adelie │ Dream │ male │ 40.071429 │ 208 │ │ Adelie │ Dream │ NULL │ 37.500000 │ 179 │ │ Gentoo │ Biscoe │ female │ 45.563793 │ 222 │ │ Gentoo │ Biscoe │ male │ 49.473770 │ 231 │ │ … │ … │ … │ … │ … │ └─────────┴───────────┴────────┴──────────────────────┴────────────────────────┘ ```

Guides

Python

Chaining It All Together

We've already chained some Ibis calls together. We used `mutate` to create a new column and then `select` to only view a subset of the new table. We were just chaining `group_by` with `aggregate`. There's nothing stopping us from putting all of these concepts together to ask questions of the data. How about: * What was the largest female penguin (by body mass) on each island in the year 2008? ```python penguins.filter((penguins.sex == "female") & (penguins.year == 2008)).group_by( ["island"] ).aggregate(penguins.body_mass_g.max()) ``` ```text ┏━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━┓ ┃ island ┃ Max(body_mass_g) ┃ ┡━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━┩ │ string │ int64 │ ├───────────┼──────────────────┤ │ Biscoe │ 5200 │ │ Torgersen │ 3800 │ │ Dream │ 3900 │ └───────────┴──────────────────┘ ``` * What about the largest male penguin (by body mass) on each island for each year of data collection? ```python penguins.filter(penguins.sex == "male").group_by(["island", "year"]).aggregate( penguins.body_mass_g.max().name("max_body_mass") ).order_by(["year", "max_body_mass"]) ``` ```text ┏━━━━━━━━━━━┳━━━━━━━┳━━━━━━━━━━━━━━━┓ ┃ island ┃ year ┃ max_body_mass ┃ ┡━━━━━━━━━━━╇━━━━━━━╇━━━━━━━━━━━━━━━┩ │ string │ int64 │ int64 │ ├───────────┼───────┼───────────────┤ │ Dream │ 2007 │ 4650 │ │ Torgersen │ 2007 │ 4675 │ │ Biscoe │ 2007 │ 6300 │ │ Torgersen │ 2008 │ 4700 │ │ Dream │ 2008 │ 4800 │ │ Biscoe │ 2008 │ 6000 │ │ Torgersen │ 2009 │ 4300 │ │ Dream │ 2009 │ 4475 │ │ Biscoe │ 2009 │ 6000 │ └───────────┴───────┴───────────────┘ ```

Guides

Python

Learn More

That's all for this quick-start guide. If you want to learn more, check out the [Ibis documentation](https://ibis-project.org).

Guides

Python

Integration with Polars

[Polars](https://github.com/pola-rs/polars) is a DataFrames library built in Rust with bindings for Python and Node.js. It uses [Apache Arrow's columnar format](https://arrow.apache.org/docs/format/Columnar.html) as its memory model. DuckDB can read Polars DataFrames and convert query results to Polars DataFrames. It does this internally using the efficient Apache Arrow integration. Note that the `pyarrow` library must be installed for the integration to work.

Guides

Python

Installation

```bash pip install -U duckdb 'polars[pyarrow]' ```

Guides

Python

Polars to DuckDB

DuckDB can natively query Polars DataFrames by referring to the name of Polars DataFrames as they exist in the current scope. ```python import duckdb import polars as pl df = pl.DataFrame( { "A": [1, 2, 3, 4, 5], "fruits": ["banana", "banana", "apple", "apple", "banana"], "B": [5, 4, 3, 2, 1], "cars": ["beetle", "audi", "beetle", "beetle", "beetle"], } ) duckdb.sql("SELECT * FROM df").show() ```

Guides

Python

DuckDB to Polars

DuckDB can output results as Polars DataFrames using the `.pl()` result-conversion method. ```python df = duckdb.sql(""" SELECT 1 AS id, 'banana' AS fruit UNION ALL SELECT 2, 'apple' UNION ALL SELECT 3, 'mango'""" ).pl() print(df) ``` ```text shape: (3, 2) ┌─────┬────────┐ │ id ┆ fruit │ │ --- ┆ --- │ │ i32 ┆ str │ ╞═════╪════════╡ │ 1 ┆ banana │ │ 2 ┆ apple │ │ 3 ┆ mango │ └─────┴────────┘ ``` To learn more about Polars, feel free to explore their [Python API Reference](https://pola-rs.github.io/polars/py-polars/html/reference/index.html).

Guides

Python

Using fsspec Filesystems

DuckDB support for [`fsspec`](https://filesystem-spec.readthedocs.io) filesystems allows querying data in filesystems that DuckDB's [`httpfs` extension](#docs:extensions:httpfs:overview) does not support. `fsspec` has a large number of [inbuilt filesystems](https://filesystem-spec.readthedocs.io/en/latest/api.html#built-in-implementations), and there are also many [external implementations](https://filesystem-spec.readthedocs.io/en/latest/api.html#other-known-implementations). This capability is only available in DuckDB's Python client because `fsspec` is a Python library, while the `httpfs` extension is available in many DuckDB clients.

Guides

Python

Example

The following is an example of using `fsspec` to query a file in Google Cloud Storage (instead of using their S3-compatible API). Firstly, you must install `duckdb` and `fsspec`, and a filesystem interface of your choice. ```bash pip install duckdb fsspec gcsfs ``` Then, you can register whichever filesystem you'd like to query: ```python import duckdb from fsspec import filesystem # this line will throw an exception if the appropriate filesystem interface is not installed duckdb.register_filesystem(filesystem('gcs')) duckdb.sql("SELECT * FROM read_csv('gcs:///bucket/file.csv')") ``` > These filesystems are not implemented in C++, hence, their performance may not be comparable to the ones provided by the `httpfs` extension. > It is also worth noting that as they are third-party libraries, they may contain bugs that are beyond our control.

Guides

SQL Editors

DBeaver SQL IDE

[DBeaver](https://dbeaver.io/) is a powerful and popular desktop sql editor and integrated development environment (IDE). It has both an open source and enterprise version. It is useful for visually inspecting the available tables in DuckDB and for quickly building complex queries. DuckDB's [JDBC connector](https://search.maven.org/artifact/org.duckdb/duckdb_jdbc) allows DBeaver to query DuckDB files, and by extension, any other files that DuckDB can access (like [Parquet files](#docs:guides:file_formats:query_parquet)).

Guides

SQL Editors

Installing DBeaver

1. Install DBeaver using the download links and instructions found at their [download page](https://dbeaver.io/download/). 2. Open DBeaver and create a new connection. Either click on the “New Database Connection” button or go to Database > New Database Connection in the menu bar. <img src="/images/guides/DBeaver_new_database_connection.png" alt="DBeaver New Database Connection" title="DBeaver New Database Connection"/> <img src="/images/guides/DBeaver_new_database_connection_menu.png" alt="DBeaver New Database Connection Menu" title="DBeaver New Database Connection Menu"/> 3. Search for DuckDB, select it, and click Next. <img src="/images/guides/DBeaver_select_database_driver.png" alt="DBeaver Select Database Driver" title="DBeaver Select Database Driver"/> 4. Enter the path or browse to the DuckDB database file you wish to query. To use an in-memory DuckDB (useful primarily if just interested in querying Parquet files, or for testing) enter `:memory:` as the path. <img src="/images/guides/DBeaver_connection_settings_path.png" alt="DBeaver Set Path" title="DBeaver Set Path"/> 5. Click “Test Connection”. This will then prompt you to install the DuckDB JDBC driver. If you are not prompted, see alternative driver installation instructions below. <img src="/images/guides/DBeaver_connection_settings_test_connection.png" alt="DBeaver Test Connection" title="DBeaver Test Connection"/> 6. Click “Download” to download DuckDB's JDBC driver from Maven. Once download is complete, click “OK”, then click “Finish”. * Note: If you are in a corporate environment or behind a firewall, before clicking download, click the “Download Configuration” link to configure your proxy settings. <img src="/images/guides/DBeaver_download_driver_files.png" alt="DBeaver Download Driver Files" title="DBeaver Download Driver Files"/> 7. You should now see a database connection to your DuckDB database in the left hand “Database Navigator” pane. Expand it to see the tables and views in your database. Right click on that connection and create a new SQL script. <img src="/images/guides/DBeaver_new_sql_script.png" alt="DBeaver New SQL Script" title="DBeaver New SQL Script"/> 8. Write some SQL and click the “Execute” button. <img src="/images/guides/DBeaver_execute_query.png" alt="DBeaver Execute Query" title="DBeaver Execute Query"/> 9. Now you're ready to fly with DuckDB and DBeaver! <img src="/images/guides/DBeaver_query_results.png" alt="DBeaver Query Results" title="DBeaver Query Results"/>

Guides

SQL Editors

Alternative Driver Installation

1. If not prompted to install the DuckDB driver when testing your connection, return to the “Connect to a database” dialog and click “Edit Driver Settings”. <img src="/images/guides/DBeaver_edit_driver_settings.png" alt="DBeaver Edit Driver Settings" title="DBeaver Edit Driver Settings"/> 2. (Alternate) You may also access the driver settings menu by returning to the main DBeaver window and clicking Database > Driver Manager in the menu bar. Then select DuckDB, then click Edit. <img src="/images/guides/DBeaver_driver_manager.png" alt="DBeaver Driver Manager" title="DBeaver Driver Manager"/> <img src="/images/guides/DBeaver_driver_manager_edit.png" alt="DBeaver Driver Manager Edit" title="DBeaver Driver Manager Edit"/> 3. Go to the “Libraries” tab, then click on the DuckDB driver and click “Download/Update”. If you do not see the DuckDB driver, first click on “Reset to Defaults”. <img src="/images/guides/DBeaver_edit_driver_duckdb.png" alt="DBeaver Edit Driver" title="DBeaver Edit Driver"/> 4. Click “Download” to download DuckDB's JDBC driver from Maven. Once download is complete, click “OK”, then return to the main DBeaver window and continue with step 7 above. * Note: If you are in a corporate environment or behind a firewall, before clicking download, click the “Download Configuration” link to configure your proxy settings. <img src="/images/guides/DBeaver_download_driver_files_from_driver_settings.png" alt="DBeaver Download Driver Files 2" title="DBeaver Download Driver Files 2" />

Guides

SQL Features

What is an AsOf Join?

Time series data is not always perfectly aligned. Clocks may be slightly off, or there may be a delay between cause and effect. This can make connecting two sets of ordered data challenging. AsOf joins are a tool for solving this and other similar problems. One of the problems that AsOf joins are used to solve is finding the value of a varying property at a specific point in time. This use case is so common that it is where the name came from: _Give me the value of the property **as of this time**_. More generally, however, AsOf joins embody some common temporal analytic semantics, which can be cumbersome and slow to implement in standard SQL.

Guides

SQL Features

Portfolio Example Data Set

Let's start with a concrete example. Suppose we have a table of stock [`prices`](https://duckdb.org/data/prices.csv) with timestamps: <div class="narrow_table"></div> | ticker | when | price | | :----- | :--- | ----: | | APPL | 2001-01-01 00:00:00 | 1 | | APPL | 2001-01-01 00:01:00 | 2 | | APPL | 2001-01-01 00:02:00 | 3 | | MSFT | 2001-01-01 00:00:00 | 1 | | MSFT | 2001-01-01 00:01:00 | 2 | | MSFT | 2001-01-01 00:02:00 | 3 | | GOOG | 2001-01-01 00:00:00 | 1 | | GOOG | 2001-01-01 00:01:00 | 2 | | GOOG | 2001-01-01 00:02:00 | 3 | We have another table containing portfolio [`holdings`](https://duckdb.org/data/holdings.csv) at various points in time: <div class="narrow_table"></div> | ticker | when | shares | | :----- | :--- | -----: | | APPL | 2000-12-31 23:59:30 | 5.16 | | APPL | 2001-01-01 00:00:30 | 2.94 | | APPL | 2001-01-01 00:01:30 | 24.13 | | GOOG | 2000-12-31 23:59:30 | 9.33 | | GOOG | 2001-01-01 00:00:30 | 23.45 | | GOOG | 2001-01-01 00:01:30 | 10.58 | | DATA | 2000-12-31 23:59:30 | 6.65 | | DATA | 2001-01-01 00:00:30 | 17.95 | | DATA | 2001-01-01 00:01:30 | 18.37 | To load these tables to DuckDB, run: ```sql CREATE TABLE prices AS FROM 'https://duckdb.org/data/prices.csv'; CREATE TABLE holdings AS FROM 'https://duckdb.org/data/holdings.csv'; ```

Guides

SQL Features

Inner AsOf Joins

We can compute the value of each holding at that point in time by finding the most recent price before the holding's timestamp by using an AsOf Join: ```sql SELECT h.ticker, h.when, price * shares AS value FROM holdings h ASOF JOIN prices p ON h.ticker = p.ticker AND h.when >= p.when; ``` This attaches the value of the holding at that time to each row: <div class="narrow_table"></div> | ticker | when | value | | :----- | :--- | ----: | | APPL | 2001-01-01 00:00:30 | 2.94 | | APPL | 2001-01-01 00:01:30 | 48.26 | | GOOG | 2001-01-01 00:00:30 | 23.45 | | GOOG | 2001-01-01 00:01:30 | 21.16 | It essentially executes a function defined by looking up nearby values in the `prices` table. Note also that missing `ticker` values do not have a match and don't appear in the output.

Guides

SQL Features

Outer AsOf Joins

Because AsOf produces at most one match from the right hand side, the left side table will not grow as a result of the join, but it could shrink if there are missing times on the right. To handle this situation, you can use an *outer* AsOf Join: ```sql SELECT h.ticker, h.when, price * shares AS value FROM holdings h ASOF LEFT JOIN prices p ON h.ticker = p.ticker AND h.when >= p.when ORDER BY ALL; ``` As you might expect, this will produce `NULL` prices and values instead of dropping left side rows when there is no ticker or the time is before the prices begin. <div class="narrow_table"></div> | ticker | when | value | | :----- | :--- | ----: | | APPL | 2000-12-31 23:59:30 | | | APPL | 2001-01-01 00:00:30 | 2.94 | | APPL | 2001-01-01 00:01:30 | 48.26 | | GOOG | 2000-12-31 23:59:30 | | | GOOG | 2001-01-01 00:00:30 | 23.45 | | GOOG | 2001-01-01 00:01:30 | 21.16 | | DATA | 2000-12-31 23:59:30 | | | DATA | 2001-01-01 00:00:30 | | | DATA | 2001-01-01 00:01:30 | |

Guides

SQL Features

AsOf Joins with the `USING` Keyword

So far we have been explicit about specifying the conditions for AsOf, but SQL also has a simplified join condition syntax for the common case where the column names are the same in both tables. This syntax uses the `USING` keyword to list the fields that should be compared for equality. AsOf also supports this syntax, but with two restrictions: * The last field is the inequality * The inequality is `>=` (the most common case) Our first query can then be written as: ```sql SELECT ticker, h.when, price * shares AS value FROM holdings h ASOF JOIN prices p USING (ticker, "when"); ``` #### Clarification on Column Selection with `USING` in ASOF Joins {#docs:guides:sql_features:asof_join::clarification-on-column-selection-with-using-in-asof-joins} When you use the `USING` keyword in a join, the columns specified in the `USING` clause are merged in the result set. This means that if you run: ```sql SELECT * FROM holdings h ASOF JOIN prices p USING (ticker, "when"); ``` You will get back only the columns `h.ticker, h.when, h.shares, p.price`. The columns `ticker` and `when` will appear only once, with `ticker` and `when` coming from the left table (holdings). This behavior is fine for the `ticker` column because the value is the same in both tables. However, for the `when` column, the values might differ between the two tables due to the `>=` condition used in the AsOf join. The AsOf join is designed to match each row in the left table (` holdings`) with the nearest preceding row in the right table (` prices`) based on the `when` column. If you want to retrieve the `when` column from both tables to see both timestamps, you need to list the columns explicitly rather than relying on `*`, like so: ```sql SELECT h.ticker, h.when AS holdings_when, p.when AS prices_when, h.shares, p.price FROM holdings h ASOF JOIN prices p USING (ticker, "when"); ``` This ensures that you get the complete information from both tables, avoiding any potential confusion caused by the default behavior of the `USING` keyword.

Guides

SQL Features

See Also

For implementation details, see the [blog post “DuckDB's AsOf joins: Fuzzy Temporal Lookups”](https://duckdb.org/2023/09/15/asof-joins-fuzzy-temporal-lookups).

Guides

SQL Features

Full-Text Search

DuckDB supports full-text search via the [`fts` extension](#docs:extensions:full_text_search). A full-text index allows for a query to quickly search for all occurrences of individual words within longer text strings.

Guides

SQL Features

Example: Shakespeare Corpus

Here's an example of building a full-text index of Shakespeare's plays. ```sql CREATE TABLE corpus AS SELECT * FROM 'https://blobs.duckdb.org/data/shakespeare.parquet'; ``` ```sql DESCRIBE corpus; ``` | column_name | column_type | null | key | default | extra | |-------------|-------------|------|------|---------|-------| | line_id | VARCHAR | YES | NULL | NULL | NULL | | play_name | VARCHAR | YES | NULL | NULL | NULL | | line_number | VARCHAR | YES | NULL | NULL | NULL | | speaker | VARCHAR | YES | NULL | NULL | NULL | | text_entry | VARCHAR | YES | NULL | NULL | NULL | The text of each line is in `text_entry`, and a unique key for each line is in `line_id`.

Guides

SQL Features

Creating a Full-Text Search Index

First, we create the index, specifying the table name, the unique id column, and the column(s) to index. We will just index the single column `text_entry`, which contains the text of the lines in the play. ```sql PRAGMA create_fts_index('corpus', 'line_id', 'text_entry'); ``` The table is now ready to query using the [Okapi BM25](https://en.wikipedia.org/wiki/Okapi_BM25) ranking function. Rows with no match return a null score. What does Shakespeare say about butter? ```sql SELECT fts_main_corpus.match_bm25(line_id, 'butter') AS score, line_id, play_name, speaker, text_entry FROM corpus WHERE score IS NOT NULL ORDER BY score DESC; ``` | score | line_id | play_name | speaker | text_entry | |-------------------:|-------------|--------------------------|--------------|----------------------------------------------------| | 4.427313429798464 | H4/2.4.494 | Henry IV | Carrier | As fat as butter. | | 3.836270302568675 | H4/1.2.21 | Henry IV | FALSTAFF | prologue to an egg and butter. | | 3.836270302568675 | H4/2.1.55 | Henry IV | Chamberlain | They are up already, and call for eggs and butter; | | 3.3844488405497115 | H4/4.2.21 | Henry IV | FALSTAFF | toasts-and-butter, with hearts in their bellies no | | 3.3844488405497115 | H4/4.2.62 | Henry IV | PRINCE HENRY | already made thee butter. But tell me, Jack, whose | | 3.3844488405497115 | AWW/4.1.40 | Alls well that ends well | PAROLLES | butter-womans mouth and buy myself another of | | 3.3844488405497115 | AYLI/3.2.93 | As you like it | TOUCHSTONE | right butter-womens rank to market. | | 3.3844488405497115 | KL/2.4.132 | King Lear | Fool | kindness to his horse, buttered his hay. | | 3.0278411214953107 | AWW/5.2.9 | Alls well that ends well | Clown | henceforth eat no fish of fortunes buttering. | | 3.0278411214953107 | MWW/2.2.260 | Merry Wives of Windsor | FALSTAFF | Hang him, mechanical salt-butter rogue! I will | | 3.0278411214953107 | MWW/2.2.284 | Merry Wives of Windsor | FORD | rather trust a Fleming with my butter, Parson Hugh | | 3.0278411214953107 | MWW/3.5.7 | Merry Wives of Windsor | FALSTAFF | Ill have my brains taen out and buttered, and give | | 3.0278411214953107 | MWW/3.5.102 | Merry Wives of Windsor | FALSTAFF | to heat as butter; a man of continual dissolution | | 2.739219044070792 | H4/2.4.115 | Henry IV | PRINCE HENRY | Didst thou never see Titan kiss a dish of butter? | Unlike standard indexes, full-text indexes don't auto-update as the underlying data is changed, so you need to `PRAGMA drop_fts_index(my_fts_index)` and recreate it when appropriate.

Guides

SQL Features

Note on Generating the Corpus Table

For more details, see the [“Generating a Shakespeare corpus for full-text searching from JSON” blog post](https://duckdb.blogspot.com/2023/04/generating-shakespeare-corpus-for-full.html) * The Columns are: line_id, play_name, line_number, speaker, text_entry. * We need a unique key for each row in order for full-text searching to work. * The line_id `KL/2.4.132` means King Lear, Act 2, Scene 4, Line 132.

Guides

SQL Features

query and query_table Functions

The [`query`](#docs:sql:functions:utility::queryquery_string_literal) and [`query_table`](#docs:sql:functions:utility::query_tabletbl_name) functions take a string literal, and convert it into a `SELECT` subquery and a table reference, respectively. Note that these functions only accept literal strings. As such, they are not as powerful (or dangerous) as a generic `eval`. These functions are conceptually simple, but enable powerful and more dynamic SQL. For example, they allow passing in a table name as a prepared statement parameter: ```sql CREATE TABLE my_table(i INT); INSERT INTO my_table VALUES (42); PREPARE select_from_table AS SELECT * FROM query_table($1); EXECUTE select_from_table('my_table'); ``` | i | |---:| | 42 | When combined with the [`COLUMNS` expression](#docs:sql:expressions:star::columns), we can write very generic SQL-only macros. For example, below is a custom version of `SUMMARIZE` that computes the `min` and `max` of every column in a table: ```sql CREATE OR REPLACE MACRO my_summarize(table_name) AS TABLE SELECT unnest([*COLUMNS('alias_.*')]) AS column_name, unnest([*COLUMNS('min_.*')]) AS min_value, unnest([*COLUMNS('max_.*')]) AS max_value FROM ( SELECT any_value(alias(COLUMNS(*))) AS "alias_\0", min(COLUMNS(*))::VARCHAR AS "min_\0", max(COLUMNS(*))::VARCHAR AS "max_\0" FROM query_table(table_name::VARCHAR) ); SELECT * FROM my_summarize('https://blobs.duckdb.org/data/ontime.parquet') LIMIT 3; ``` | column_name | min_value | max_value | |-------------|----------:|----------:| | year | 2017 | 2017 | | quarter | 1 | 3 | | month | 1 | 9 |

Guides

Snippets

Create Synthetic Data

DuckDB allows you to quickly generate synthetic data sets. To do so, you may use: * [range functions](#docs:sql:functions:list::range-functions) * hash functions, e.g., [`hash`](#docs:sql:functions:utility::hashvalue), [`md5`](#docs:sql:functions:utility::md5string), [`sha256`](#docs:sql:functions:utility::sha256value) * the [Faker Python package](https://faker.readthedocs.io/) via the [Python function API](#docs:api:python:function) * using [cross products (Cartesian products)](#docs:sql:query_syntax:from::cross-product-joins-cartesian-product) For example: ```python import duckdb from duckdb.typing import * from faker import Faker fake = Faker() def random_date(): return fake.date_between() def random_short_text(): return fake.text(max_nb_chars=20) def random_long_text(): return fake.text(max_nb_chars=200) con = duckdb.connect() con.create_function("random_date", random_date, [], DATE, type="native", side_effects=True) con.create_function("random_short_text", random_short_text, [], VARCHAR, type="native", side_effects=True) con.create_function("random_long_text", random_long_text, [], VARCHAR, type="native", side_effects=True) res = con.sql(""" SELECT hash(i * 10 + j) AS id, random_date() AS creationDate, random_short_text() AS short, random_long_text() AS long, IF (j % 2, true, false) AS bool FROM generate_series(1, 5) s(i) CROSS JOIN generate_series(1, 2) t(j) """) res.show() ``` This generates the following: ```text ┌──────────────────────┬──────────────┬─────────┐ │ id │ creationDate │ flag │ │ uint64 │ date │ boolean │ ├──────────────────────┼──────────────┼─────────┤ │ 6770051751173734325 │ 2019-11-05 │ true │ │ 16510940941872865459 │ 2002-08-03 │ true │ │ 13285076694688170502 │ 1998-11-27 │ true │ │ 11757770452869451863 │ 1998-07-03 │ true │ │ 2064835973596856015 │ 2010-09-06 │ true │ │ 17776805813723356275 │ 2020-12-26 │ false │ │ 13540103502347468651 │ 1998-03-21 │ false │ │ 4800297459639118879 │ 2015-06-12 │ false │ │ 7199933130570745587 │ 2005-04-13 │ false │ │ 18103378254596719331 │ 2014-09-15 │ false │ ├──────────────────────┴──────────────┴─────────┤ │ 10 rows 3 columns │ └───────────────────────────────────────────────┘ ```

Guides

Snippets

Sharing Macros

DuckDB has a powerful [macro mechanism](#docs:sql:statements:create_macro) that allows creating shorthands for common tasks. For example, we can define a macro that pretty-prints a non-negative integer as a short string that contains billions, millions, and thousands (without rounding) as follows: ```bash duckdb pretty_print_integer_macro.duckdb ``` ```sql CREATE MACRO pretty_print_integer(n) AS CASE WHEN n >= 1_000_000_000 THEN printf('%dB', n // 1_000_000_000) WHEN n >= 1_000_000 THEN printf('%dM', n // 1_000_000) WHEN n >= 1_000 THEN printf('%dk', n // 1_000) ELSE printf('%d', n) END; SELECT pretty_print_integer(25_500_000) AS x; ``` ```text ┌─────────┐ │ x │ │ varchar │ ├─────────┤ │ 25M │ └─────────┘ ``` As one would expect, the macro gets persisted in the database. But this also means that we can host it on an HTTPS endpoint and share it with anyone! We have published this macro on `blobs.duckdb.org` Let's start a new DuckDB session and try it: ```bash duckdb ``` We can now attach to the remote endpoint and use the macro: ```sql ATTACH 'https://blobs.duckdb.org/data/pretty_print_integer_macro.duckdb' AS db; USE db; SELECT pretty_print_integer(42_123) AS x; ``` ```text ┌─────────┐ │ x │ │ varchar │ ├─────────┤ │ 42k │ └─────────┘ ``` > **Warning. ** Currently, sharing table macros via attaching is not supported.

Guides

Glossary of Terms

This page contains a glossary of a few common terms used in DuckDB.

Guides

Glossary of Terms

Terms

#### In-Process Database Management System {#docs:guides:glossary::in-process-database-management-system} The DBMS runs in the client application's process instead of running as a separate process, which is common in the traditional client–server setup. An alternative term is **embeddable** database management system. In general, the term _“embedded database management system”_ should be avoided, as it can be confused with DBMSs targeting _embedded systems_ (which run on e.g., microcontrollers). #### Replacement Scan {#docs:guides:glossary::replacement-scan} In DuckDB, replacement scans are used when a table name used by a query does not exist in the catalog. These scans can substitute another data source instead of the table. Using replacement scans allows DuckDB to, e.g., seamlessly read [Pandas DataFrames](#docs:guides:python:sql_on_pandas) or read input data from remote sources without explicitly invoking the functions that perform this (e.g., [reading Parquet files from https](#docs:guides:network_cloud_storage:http_import)). For details, see the [C API - Replacement Scans page](#docs:api:c:replacement_scans). #### Extension {#docs:guides:glossary::extension} DuckDB has a flexible extension mechanism that allows for dynamically loading extensions. These may extend DuckDB's functionality by providing support for additional file formats, introducing new types, and domain-specific functionality. For details, see the [Extensions page](#docs:extensions:overview). #### Platform {#docs:guides:glossary::platform} The platform is a combination of the operating system (e.g., Linux, macOS, Windows), system architecture (e.g., AMD64, ARM64), and, optionally, the compiler used (e.g., GCC4). Platforms are used to distributed DuckDB binaries and [extension packages](#docs:extensions:working_with_extensions::platforms).

Guides

Browse Offline

You can browse the DuckDB documentation offline in the following formats: * As a [single Markdown file](https://duckdb.org/duckdb-docs.md) (approx. 3 MB) * As a [single PDF file](https://duckdb.org/duckdb-docs.pdf) (approx. 4 MB) * As a [website packaged in a single ZIP file](https://duckdb.org/duckdb-docs.zip) (approx. 50 MB). To browse the website locally, decompress the package, navigate to the `duckdb-docs` directory, and run: ```bash python -m http.server ``` Then, connect to <http://localhost:8000/>.

Operations Manual

Overview

We designed DuckDB to be easy to deploy and operate. We believe that most users do not need to consult the pages of the operations manual. However, there are certain setups – e.g., when DuckDB is running in mission-critical infrastructure – where we would like to offer advice on how to configure DuckDB. The operations manual contains advice for these cases and also offers convenient configuration snippets such as Gitignore files. For advice on getting the best performance from DuckDB, see also the [Performance Guide](#docs:guides:performance:overview).

Operations Manual

Limits

This page contains DuckDB's built-in limit values. | Limit | Default value | Configuration option | |---|---|---| | Array size | 100000 | - | | BLOB size | 4 GB | - | | Expression depth | 1000 | [`max_expression_depth`](#docs:configuration:overview) | | Memory allocation for a vector | 128 GB | - | | Memory use | 80% of RAM | [`memory_limit`](#docs:configuration:overview) | | String size | 4 GB | - | | Temporary directory size | unlimited | [`max_temp_directory_size`](#docs:configuration:overview) |