DuckDB Documentation

https://duckdb.org/docs/
Admin
DuckDB is an in-process analytical data management system. It is designed to be fast, efficient, and...
Tokens:285,265
Snippets:3,480
Trust Score:9.8
Update:1 month ago
Show doc for...
Tokens:
Raw
### View Install Script Output

Source: https://duckdb.org/docs/current/operations_manual/installing_duckdb/install_script

Example output showing the installation process and the resulting binary location.

```text
  % Total    % Received % Xferd  Average Speed   Time    Time     Time  Current
                                 Dload  Upload   Total   Spent    Left  Speed
100  3507  100  3507    0     0  34367      0 --:--:-- --:--:-- --:--:-- 34382
https://install.duckdb.org/v1.4.1/duckdb_cli-osx-universal.gz

*** DuckDB Linux/MacOS installation script, version 1.4.1 ***


         .;odxdl,
       .xXXXXXXXXKc
       0XXXXXXXXXXXd  cooo:
      ,XXXXXXXXXXXXK  OXXXXd
       0XXXXXXXXXXXo  cooo:
       .xXXXXXXXXKc
         .;odxdl,


######################################################################## 100.0%

Successfully installed DuckDB binary to /Users/your_user/.duckdb/cli/1.4.1/duckdb
  with a link from                      /Users/your_user/.duckdb/cli/latest/duckdb

Hint: Append the following line to your shell profile:
export PATH='/Users/your_user/.duckdb/cli/latest':$PATH


To launch DuckDB now, type
/Users/your_user/.duckdb/cli/latest/duckdb
```

--------------------------------

### Loading and Installing Extensions

Source: https://duckdb.org/docs/current/clients/wasm/extensions.html

Examples of loading core extensions, installing community extensions, and fetching external extensions from specific repositories.

```sql
-- Explicitly load a core extension
LOAD icu;

-- Load spatial for geospatial support
INSTALL spatial;
LOAD spatial;

-- Install a community extension, then load it
INSTALL h3 FROM community;
LOAD h3;

-- Install an external extension from a repository
INSTALL sqlite_scanner FROM 'https://extensions.duckdb.org';
LOAD sqlite_scanner;
```

--------------------------------

### Start Caddy Server

Source: https://duckdb.org/docs/current/quack/setup/reverse_proxy.html

Commands to install and execute Caddy using the provided configuration file.

```bash
brew install caddy # macOS, for other platforms see https://caddyserver.com/docs/install
caddy run --config Caddyfile
```

--------------------------------

### CLI startup output

Source: https://duckdb.org/docs/current/clients/cli/overview

Example output displayed when starting the DuckDB CLI.

```text
DuckDB v1.5.5 (Variegata) d8cdaa33fd
Enter ".help" for usage hints.
Connected to a transient in-memory database.
Use ".open FILENAME" to reopen on a persistent database.
D
```

--------------------------------

### Install DuckDB Go Client

Source: https://duckdb.org/docs/current/clients/go.html

Use the go get command to add the duckdb-go package to your project.

```bash
go get github.com/duckdb/duckdb-go/v2
```

--------------------------------

### install_extension

Source: https://duckdb.org/docs/current/clients/python/reference

Install an extension by name, with an optional version and/or repository to get the extension from.

```APIDOC
## install_extension(extension: str, force_install: bool = False, repository: object = None, repository_url: object = None, version: object = None) -> None

### Description
Install an extension by name, with an optional version and/or repository to get the extension from.
```

--------------------------------

### Install pdo_duckdb via PIE

Source: https://duckdb.org/docs/current/clients/tertiary_clients/php_pdo.html

Use the PHP Installer for Extensions (PIE) to install the driver.

```bash
pie install thomas-0816/pdo-duckdb-php
```

--------------------------------

### PostgreSQL Connection String Examples

Source: https://duckdb.org/docs/current/core_extensions/postgres/overview.html

Example connection strings using libpq format for the ATTACH command.

```text
dbname=postgresscanner
host=localhost port=5432 dbname=mydb connect_timeout=10
```

--------------------------------

### Simple DuckDB Go Example

Source: https://duckdb.org/docs/current/clients/go.html

A complete example demonstrating database connection, table creation, data insertion, and row scanning using database/sql.

```go
package main

import (
	"database/sql"
	"errors"
	"fmt"
	"log"

	_ "github.com/duckdb/duckdb-go/v2"
)

func main() {
	db, err := sql.Open("duckdb", "")
	if err != nil {
		log.Fatal(err)
	}
	defer db.Close()

	_, err = db.Exec(`CREATE TABLE people (id INTEGER, name VARCHAR)`)
	if err != nil {
		log.Fatal(err)
	}
	_, err = db.Exec(`INSERT INTO people VALUES (42, 'John')`)
	if err != nil {
		log.Fatal(err)
	}

	var (
		id   int
		name string
	)
	row := db.QueryRow(`SELECT id, name FROM people`)
	err = row.Scan(&id, &name)
	if errors.Is(err, sql.ErrNoRows) {
		log.Println("no rows")
	} else if err != nil {
		log.Fatal(err)
	}

	fmt.Printf("id: %d, name: %s\n", id, name)
}
```

--------------------------------

### Install and Load MySQL Extension

Source: https://duckdb.org/docs/current/core_extensions/mysql.html

Commands to install and manually load the MySQL extension.

```sql
INSTALL mysql;
```

```sql
LOAD mysql;
```

--------------------------------

### Install and Load Unity Catalog Extension

Source: https://duckdb.org/docs/current/core_extensions/unity_catalog.html

Run these commands to install and load the extension into your DuckDB environment.

```sql
INSTALL unity_catalog;
LOAD unity_catalog;
```

--------------------------------

### Install and Load INET Extension

Source: https://duckdb.org/docs/current/core_extensions/inet.html

Manually install and load the extension if not using automatic loading.

```sql
INSTALL inet;
LOAD inet;
```

--------------------------------

### Install DuckDB PHP Client

Source: https://duckdb.org/docs/current/clients/tertiary_clients/php.html

Use Composer to install the library. Note that you must allow the package to execute code during installation.

```bash
composer require satur.io/duckdb-auto
```

--------------------------------

### Install DuckDB on Windows

Source: https://duckdb.org/docs/current/operations_manual/installing_duckdb/install_script

Executes the beta PowerShell install script for Windows environments.

```powershell
powershell -NoExit iex (iwr "https://install.duckdb.org/install.ps1").Content
```

--------------------------------

### Install and Load Iceberg Extension

Source: https://duckdb.org/docs/current/core_extensions/iceberg/overview.html

Manually install and load the extension if it is not automatically handled.

```sql
INSTALL iceberg;
LOAD iceberg;
```

--------------------------------

### Install and Load Encodings Extension

Source: https://duckdb.org/docs/current/core_extensions/encodings.html

Required setup to enable support for additional character encodings in DuckDB.

```sql
INSTALL encodings;
LOAD encodings;
```

--------------------------------

### Install and Load Quack Extension

Source: https://duckdb.org/docs/current/core_extensions/quack.html

Commands to explicitly install and load the Quack extension in DuckDB.

```sql
INSTALL quack;
```

```sql
LOAD quack;
```

--------------------------------

### Install and Load AWS Extension

Source: https://duckdb.org/docs/current/core_extensions/aws.html

Manually install and load the AWS extension if it is not automatically loaded.

```sql
INSTALL aws;
LOAD aws;
```

--------------------------------

### Install and Load Azure Extension

Source: https://duckdb.org/docs/current/core_extensions/azure.html

Manually install and load the extension if not using automatic loading.

```sql
INSTALL azure;
LOAD azure;
```

--------------------------------

### Install and Load Excel Extension

Source: https://duckdb.org/docs/current/core_extensions/excel.html

Manually install and load the extension if autoloading is not desired.

```sql
INSTALL excel;
LOAD excel;
```

--------------------------------

### Install and Load TPC-H Extension

Source: https://duckdb.org/docs/current/core_extensions/tpch.html

Manually install and load the extension if it is not automatically handled by the environment.

```sql
INSTALL tpch;
LOAD tpch;
```

--------------------------------

### Install and Load httpfs Extension

Source: https://duckdb.org/docs/current/core_extensions/httpfs/overview.html

Manually install and load the httpfs extension if autoloading is not desired.

```sql
INSTALL httpfs;
LOAD httpfs;
```

--------------------------------

### Install build dependencies

Source: https://duckdb.org/docs/current/dev/building/macos.html

Install required tools using Homebrew before building DuckDB.

```bash
brew install git cmake ninja
```

--------------------------------

### Install and Load DuckLake Extension

Source: https://duckdb.org/docs/current/core_extensions/ducklake.html

Commands to install the extension and manually load it into the current session.

```sql
INSTALL ducklake;
```

```sql
LOAD ducklake;
```

--------------------------------

### Install and Build DuckDB on Arch Linux

Source: https://duckdb.org/docs/current/dev/building/linux.html

Install the pre-built package from the repository or build from source.

```bash
sudo pacman -S duckdb
```

```bash
sudo pacman -S git gcc cmake ninja openssl
git clone https://github.com/duckdb/duckdb
cd duckdb
GEN=ninja make
```

--------------------------------

### Install and Load MotherDuck Extension

Source: https://duckdb.org/docs/current/core_extensions/motherduck.html

Manually install and load the MotherDuck extension using the 'md' shorthand.

```sql
INSTALL md;
LOAD md;
```

--------------------------------

### ST_Envelope_Agg and ST_Extent_Agg Examples

Source: https://duckdb.org/docs/current/core_extensions/spatial/functions.html

Examples for computing the minimal bounding box of a set of geometries.

```sql
SELECT ST_Extent_Agg(geom) FROM UNNEST([ST_Point(1,1), ST_Point(5,5)]) AS _(geom);
-- POLYGON ((1 1, 1 5, 5 5, 5 1, 1 1))
```

--------------------------------

### Install and Load Delta Extension

Source: https://duckdb.org/docs/current/core_extensions/delta.html

Manually install and load the extension if not using automatic loading.

```sql
INSTALL delta;
LOAD delta;
```

--------------------------------

### Start in-memory database

Source: https://duckdb.org/docs/current/clients/cli/overview

Launches the CLI with a transient in-memory database.

```bash
duckdb
```

--------------------------------

### Install build dependencies on Linux

Source: https://duckdb.org/docs/current/dev/building/python.html

Install ccache on Ubuntu 24.04 to support the build process.

```bash
sudo apt-get update
sudo apt-get install ccache

```

--------------------------------

### Install and Load SQLSmith

Source: https://duckdb.org/docs/current/core_extensions/sqlsmith

Commands to install and load the SQLSmith extension into the current DuckDB session.

```sql
INSTALL sqlsmith;
LOAD sqlsmith;
```

--------------------------------

### Start Quack Server

Source: https://duckdb.org/docs/current/quack/setup/reverse_proxy.html

Initializes the Quack server within a DuckDB session.

```sql
CALL quack_serve('quack:localhost');
```

--------------------------------

### Install and Load TPC-DS Extension

Source: https://duckdb.org/docs/current/core_extensions/tpcds.html

Manually install and load the extension if not using automatic autoloading.

```sql
INSTALL tpcds;
LOAD tpcds;
```

--------------------------------

### Install built extensions

Source: https://duckdb.org/docs/current/dev/building/building_extensions.html

Iterate through the build directory to install the generated extension files into the DuckDB environment.

```bash
# for release builds
cd build/release/extension/
# for debug builds
cd build/debug/extension/
# install extensions
for EXTENSION in *; do
    ../duckdb -c "INSTALL '${EXTENSION}/${EXTENSION}.duckdb_extension';"
done
```

--------------------------------

### Install and Load PostgreSQL Extension

Source: https://duckdb.org/docs/current/core_extensions/postgres/overview.html

Manually install and load the extension if not using the automatic autoloading feature.

```sql
INSTALL postgres;
LOAD postgres;
```

--------------------------------

### INSTALL and LOAD vortex

Source: https://duckdb.org/docs/current/core_extensions/vortex.html

Commands to install and load the Vortex extension into the current DuckDB session.

```APIDOC
## INSTALL and LOAD

### Description
Installs and loads the Vortex extension to enable Vortex file format support.

### Commands
```sql
INSTALL vortex;
LOAD vortex;
```
```

--------------------------------

### Install and Load SQLite Extension

Source: https://duckdb.org/docs/current/core_extensions/sqlite.html

Manually install and load the SQLite extension if not using automatic loading.

```sql
INSTALL sqlite;
LOAD sqlite;
```

--------------------------------

### duckdb.begin

Source: https://duckdb.org/docs/current/clients/python/reference

Start a new transaction.

```APIDOC
## duckdb.begin(connection)

### Description
Start a new transaction.
```

--------------------------------

### unixodbc_setup.sh Help Output

Source: https://duckdb.org/docs/current/clients/odbc/linux.html

The help output displayed by the setup script showing usage and available options.

```text
Usage: ./unixodbc_setup.sh <level> [options]

Example: ./unixodbc_setup.sh -u -db ~/database_path -D ~/driver_path/libduckdb_odbc.so

Level:
-s: System-level, using 'sudo' to configure DuckDB ODBC at the system-level, changing the files: /etc/odbc[inst].ini
-u: User-level, configuring the DuckDB ODBC at the user-level, changing the files: ~/.odbc[inst].ini.

Options:
-db database_path>: the DuckDB database file path, the default is ':memory:' if not provided.
-D driver_path: the driver file path (i.e., the path for libduckdb_odbc.so), the default is using the base script directory
```

--------------------------------

### Setup DataFrame for Expression API

Source: https://duckdb.org/docs/current/clients/python/expression

Initializes a pandas DataFrame to be used in subsequent expression examples.

```python
import duckdb
import pandas as pd

df = pd.DataFrame({
    'a': [1, 2, 3, 4],
    'b': [True, None, False, True],
    'c': [42, 21, 13, 14]
})
```

--------------------------------

### Initialize CLI with a configuration file

Source: https://duckdb.org/docs/current/clients/cli/overview

Starts the CLI using a specific initialization file.

```bash
duckdb -init prompt.sql
```

--------------------------------

### View macOS Installation Warning

Source: https://duckdb.org/docs/current/clients/r

Example of the warning message encountered on macOS when X11 dependencies are missing.

```text
Warning message:
In doTryCatch(return(expr), name, parentenv, handler) :
  unable to load shared object '/Library/Frameworks/R.framework/Resources/modules//R_X11.so':
  dlopen(/Library/Frameworks/R.framework/Resources/modules//R_X11.so, 0x0006): Library not loaded: /opt/X11/lib/libSM.6.dylib
  Referenced from: <31EADEB5-0A17-3546-9944-9B3747071FE8> /Library/Frameworks/R.framework/Versions/4.4-arm64/Resources/modules/R_X11.so
  Reason: tried: '/opt/X11/lib/libSM.6.dylib' (no such file) ...
> ')
```

--------------------------------

### Initialize and Connect to DuckDB

Source: https://duckdb.org/docs/current/clients/c/connect.html

Demonstrates the basic lifecycle of opening a database, establishing a connection, and performing cleanup.

```c
duckdb_database db;
duckdb_connection con;

if (duckdb_open(NULL, &db) == DuckDBError) {
    // handle error
}
if (duckdb_connect(db, &con) == DuckDBError) {
    // handle error
}

// run queries...

// cleanup
duckdb_disconnect(&con);
duckdb_close(&db);
```

--------------------------------

### Expected Output for Go ADBC Example

Source: https://duckdb.org/docs/current/clients/adbc.html

The console output generated by running the provided Go example code.

```text
record:
  schema:
  fields: 1
    - column1: type=float64
  rows: 3
  col[0][column1]: [1 2 3]

record:
  schema:
  fields: 1
    - (column1 + 1): type=float64, nullable
  rows: 3
  col[0][(column1 + 1)]: [2 3 4]
```

--------------------------------

### Import DuckDB

Source: https://duckdb.org/docs/current/clients/python/data_ingestion.html

Initial setup required before executing any DuckDB operations.

```python
import duckdb
```

--------------------------------

### Run SQL on Arrow RecordBatches with Go

Source: https://duckdb.org/docs/current/clients/adbc.html

This example demonstrates how to initialize an in-memory DuckDB database, ingest Arrow RecordBatches, execute SQL queries, and clean up resources.

```go
package main

import (
    "bytes"
    "context"
    "fmt"
    "io"

    "github.com/apache/arrow-adbc/go/adbc"
    "github.com/apache/arrow-adbc/go/adbc/drivermgr"
    "github.com/apache/arrow-go/v18/arrow"
    "github.com/apache/arrow-go/v18/arrow/array"
    "github.com/apache/arrow-go/v18/arrow/ipc"
    "github.com/apache/arrow-go/v18/arrow/memory"
)

func _makeSampleArrowRecord() arrow.Record {
    b := array.NewFloat64Builder(memory.DefaultAllocator)
    b.AppendValues([]float64{1, 2, 3}, nil)
    col := b.NewArray()

    defer col.Release()
    defer b.Release()

    schema := arrow.NewSchema([]arrow.Field{{Name: "column1", Type: arrow.PrimitiveTypes.Float64}}, nil)
    return array.NewRecord(schema, []arrow.Array{col}, int64(col.Len()))
}

type DuckDBSQLRunner struct {
    ctx  context.Context
    conn adbc.Connection
    db   adbc.Database
}

func NewDuckDBSQLRunner(ctx context.Context) (*DuckDBSQLRunner, error) {
    var drv drivermgr.Driver
    db, err := drv.NewDatabase(map[string]string{
        "driver":     "duckdb",
        "entrypoint": "duckdb_adbc_init",
        "path":       ":memory:",
    })
    if err != nil {
        return nil, fmt.Errorf("failed to create new in-memory DuckDB database: %w", err)
    }
    conn, err := db.Open(ctx)
    if err != nil {
        return nil, fmt.Errorf("failed to open connection to new in-memory DuckDB database: %w", err)
    }
    return &DuckDBSQLRunner{ctx: ctx, conn: conn, db: db}, nil
}

func serializeRecord(record arrow.Record) (io.Reader, error) {
    buf := new(bytes.Buffer)
    wr := ipc.NewWriter(buf, ipc.WithSchema(record.Schema()))
    if err := wr.Write(record); err != nil {
        return nil, fmt.Errorf("failed to write record: %w", err)
    }
    if err := wr.Close(); err != nil {
        return nil, fmt.Errorf("failed to close writer: %w", err)
    }
    return buf, nil
}

func (r *DuckDBSQLRunner) importRecord(sr io.Reader) error {
    rdr, err := ipc.NewReader(sr)
    if err != nil {
        return fmt.Errorf("failed to create IPC reader: %w", err)
    }
    defer rdr.Release()

    _, err = adbc.IngestStream(r.ctx, r.conn, rdr, "temp_table", adbc.OptionValueIngestModeCreate, adbc.IngestStreamOptions{})

    return err
}

func (r *DuckDBSQLRunner) runSQL(sql string) ([]arrow.Record, error) {
    stmt, err := r.conn.NewStatement()
    if err != nil {
        return nil, fmt.Errorf("failed to create new statement: %w", err)
    }
    defer stmt.Close()

    if err := stmt.SetSqlQuery(sql); err != nil {
        return nil, fmt.Errorf("failed to set SQL query: %w", err)
    }
    out, n, err := stmt.ExecuteQuery(r.ctx)
    if err != nil {
        return nil, fmt.Errorf("failed to execute query: %w", err)
    }
    defer out.Release()

    result := make([]arrow.Record, 0, n)
    for out.Next() {
        rec := out.Record()
        rec.Retain() // .Next() will release the record, so we need to retain it
        result = append(result, rec)
    }
    if out.Err() != nil {
        return nil, out.Err()
    }
    return result, nil
}

func (r *DuckDBSQLRunner) RunSQLOnRecord(record arrow.Record, sql string) ([]arrow.Record, error) {
    serializedRecord, err := serializeRecord(record)
    if err != nil {
        return nil, fmt.Errorf("failed to serialize record: %w", err)
    }
    if err := r.importRecord(serializedRecord); err != nil {
        return nil, fmt.Errorf("failed to import record: %w", err)
    }
    result, err := r.runSQL(sql)
    if err != nil {
        return nil, fmt.Errorf("failed to run SQL: %w", err)
    }

    if _, err := r.runSQL("DROP TABLE temp_table"); err != nil {
        return nil, fmt.Errorf("failed to drop temp table after running query: %w", err)
    }
    return result, nil
}

func (r *DuckDBSQLRunner) Close() {
    r.conn.Close()
    r.db.Close()
}

func main() {
    rec := _makeSampleArrowRecord()
    fmt.Println(rec)

    runner, err := NewDuckDBSQLRunner(context.Background())
    if err != nil {
        panic(err)
    }
    defer runner.Close()

    resultRecords, err := runner.RunSQLOnRecord(rec, "SELECT column1+1 FROM temp_table")
    if err != nil {
        panic(err)
    }

    for _, resultRecord := range resultRecords {
        fmt.Println(resultRecord)
        resultRecord.Release()
    }
}
```

--------------------------------

### Read Parquet files into a relation

Source: https://duckdb.org/docs/current/clients/python/relational_api.html

Creates a relation object from Parquet files using read_parquet. Requires pyarrow for the example setup.

```python
import duckdb
import pyarrow as pa
import pyarrow.parquet as pq

ids = pa.array([1], type=pa.int8())
texts = pa.array(['a'], type=pa.string())
example_table = pa.table([ids, texts], names=["id", "text"])

pq.write_table(example_table, "code_example.parquet")

duckdb_conn = duckdb.connect()

rel = duckdb_conn.read_parquet("code_example.parquet")

rel.show()
```

--------------------------------

### Configure and Open a DuckDB Database

Source: https://duckdb.org/docs/current/clients/c/config

Demonstrates creating a configuration object, setting various options, and using it to open a database instance.

```c
duckdb_database db;
duckdb_config config;

// create the configuration object
if (duckdb_create_config(&config) == DuckDBError) {
    // handle error
}
// set some configuration options
duckdb_set_config(config, "access_mode", "READ_WRITE"); // or READ_ONLY
duckdb_set_config(config, "threads", "8");
duckdb_set_config(config, "max_memory", "8GB");
duckdb_set_config(config, "default_order", "DESC");

// open the database using the configuration
if (duckdb_open_ext(NULL, &db, config, NULL) == DuckDBError) {
    // handle error
}
// cleanup the configuration object
duckdb_destroy_config(&config);

// run queries...

// cleanup
duckdb_close(&db);
```

--------------------------------

### Install DuckDB on Linux and macOS

Source: https://duckdb.org/docs/current/operations_manual/installing_duckdb/install_script

Executes the installation script to download and install the latest DuckDB CLI binary.

```bash
curl https://install.duckdb.org | bash
```

--------------------------------

### Execute SQL Queries and Retrieve Results

Source: https://duckdb.org/docs/current/clients/python/dbapi.html

Demonstrates creating tables, inserting data, and retrieving results using fetchall and fetchone.

```python
# create a table
con.execute("CREATE TABLE items (item VARCHAR, value DECIMAL(10, 2), count INTEGER)")
# insert two items into the table
con.execute("INSERT INTO items VALUES ('jeans', 20.0, 1), ('hammer', 42.2, 2)")

# retrieve the items again
con.execute("SELECT * FROM items")
print(con.fetchall())
# [('jeans', Decimal('20.00'), 1), ('hammer', Decimal('42.20'), 2)]

# retrieve the items one at a time
con.execute("SELECT * FROM items")
print(con.fetchone())
# ('jeans', Decimal('20.00'), 1)
print(con.fetchone())
# ('hammer', Decimal('42.20'), 2)
print(con.fetchone()) # This closes the transaction. Any subsequent calls to .fetchone will return None
# None
```

--------------------------------

### Autocomplete FROM Clause Suggestion

Source: https://duckdb.org/docs/current/clients/cli/autocomplete.html

Example showing the shell suggesting the FROM keyword.

```sql
SELECT student_id F
```

```sql
FROM
```

--------------------------------

### Install duckplyr Client

Source: https://duckdb.org/docs/current/clients/r

Command to install the dplyr-compatible API for DuckDB.

```R
install.packages("duckplyr")
```

--------------------------------

### Initialize DuckDB Instance and Connection

Source: https://duckdb.org/docs/current/clients/cpp.html

Create an in-memory database instance and a connection to it.

```cpp
DuckDB db(nullptr);
Connection con(db);
```

--------------------------------

### Connect to Instance

Source: https://duckdb.org/docs/current/clients/node_neo/overview.html

Establish a connection from an existing instance.

```javascript
const connection = await instance.connect();
```

--------------------------------

### Install DuckDB R Client

Source: https://duckdb.org/docs/current/clients/r

Command to install the DuckDB package from CRAN.

```R
install.packages("duckdb")
```

--------------------------------

### Create and Populate HNSW Index

Source: https://duckdb.org/docs/current/core_extensions/vss.html

Install the extension, create a table with an ARRAY column, and build an HNSW index.

```sql
INSTALL vss;
LOAD vss;

CREATE TABLE my_vector_table (vec FLOAT[3]);
INSERT INTO my_vector_table
    SELECT array_value(a, b, c)
    FROM range(1, 10) ra(a), range(1, 10) rb(b), range(1, 10) rc(c);
CREATE INDEX my_hnsw_index ON my_vector_table USING HNSW (vec);
```

--------------------------------

### Logging configuration shorthand

Source: https://duckdb.org/docs/current/operations_manual/logging/overview.html

Demonstrates equivalent ways to invoke the enable_logging procedure using different parameter combinations.

```sql
-- regular invocation 
CALL enable_logging(storage = 'file', storage_config = {'path': 'path/to/store/logs'});
-- using shorthand for common path storage config param 
CALL enable_logging(storage = 'file', storage_path = 'path/to/store/logs');
-- omitting `storage = 'file'` -> is implied from presence of `storage_config`
CALL enable_logging(storage_config = {'path': 'path/to/store/logs'});
```

--------------------------------

### Install specific commit version

Source: https://duckdb.org/docs/current/core_extensions/odbc/overview.html

Install a version of the extension built from a specific commit.

```sql
FORCE INSTALL 'http://nightly-extensions.duckdb.org/odbc_scanner/7_character_commit_id/v1.2.0/platform/odbc_scanner.duckdb_extension.gz';
```

--------------------------------

### Install dependencies and build project

Source: https://duckdb.org/docs/current/dev/building/python.html

Use uv to sync dependencies and build the project without isolation to ensure correct CMake integration.

```bash
# Install all development dependencies without building the project
uv sync --no-install-project

# Build and install the project without build isolation
uv sync --no-build-isolation

```

--------------------------------

### Example output format

Source: https://duckdb.org/docs/current/clients/cli/overview

The default terminal output format for a query.

```text
| generate_series |
|----------------:|
| 0               |
| 1               |
| 2               |
| 3               |
| 4               |
| 5               |
```

--------------------------------

### Install nightly ODBC extension

Source: https://duckdb.org/docs/current/core_extensions/odbc/overview.html

Install the nightly version of the extension from the DuckDB repository.

```sql
INSTALL 'http://nightly-extensions.duckdb.org/v1.2.0/platform/odbc_scanner.duckdb_extension.gz';
```

--------------------------------

### Execute Prepared Statements in C

Source: https://duckdb.org/docs/current/clients/c/prepared

Demonstrates preparing a statement, binding integer parameters, executing the query, and cleaning up resources.

```c
duckdb_prepared_statement stmt;
duckdb_result result;
if (duckdb_prepare(con, "INSERT INTO integers VALUES ($1, $2)", &stmt) == DuckDBError) {
    // handle error
}

duckdb_bind_int32(stmt, 1, 42); // the parameter index starts counting at 1!
duckdb_bind_int32(stmt, 2, 43);
// NULL as second parameter means no result set is requested
duckdb_execute_prepared(stmt, NULL);
duckdb_destroy_prepare(&stmt);

// we can also query result sets using prepared statements
if (duckdb_prepare(con, "SELECT * FROM integers WHERE i = ?", &stmt) == DuckDBError) {
    // handle error
}
duckdb_bind_int32(stmt, 1, 42);
duckdb_execute_prepared(stmt, &result);

// do something with result

// clean up
duckdb_destroy_result(&result);
duckdb_destroy_prepare(&stmt);
```

--------------------------------

### Install Spatial Extension

Source: https://duckdb.org/docs/current/core_extensions/spatial/overview.html

Run this command to install the spatial extension into your DuckDB environment.

```sql
INSTALL spatial;
```

--------------------------------

### Configure and Attach Unity Catalog

Source: https://duckdb.org/docs/current/core_extensions/unity_catalog.html

Set up authentication credentials and attach the catalog to your session.

```sql
CREATE SECRET (
    TYPE unity_catalog,
    TOKEN 'token',
    ENDPOINT 'endpoint',
    AWS_REGION 'region'
);
ATTACH 'my_catalog' AS my_catalog (TYPE unity_catalog, DEFAULT_SCHEMA 'main');
```

--------------------------------

### Establish various database connections

Source: https://duckdb.org/docs/current/clients/python/dbapi.html

Shows how to connect to in-memory databases, persistent files, and read-only shared files.

```python
import duckdb

# to start an in-memory database
con = duckdb.connect(database = ":memory:")
# to use a database file (not shared between processes)
con = duckdb.connect(database = "my-db.duckdb", read_only = False)
# to use a database file (shared between processes)
con = duckdb.connect(database = "my-db.duckdb", read_only = True)
# to explicitly get the default connection
con = duckdb.connect(database = ":default:")
```

--------------------------------

### Initialize C++ ADBC Database

Source: https://duckdb.org/docs/current/clients/adbc.html

Configure driver, entrypoint, and path options before initializing the database instance.

```cpp
AdbcDatabaseNew(&adbc_database, &adbc_error);
AdbcDatabaseSetOption(&adbc_database, "driver", "path/to/libduckdb.dylib", &adbc_error);
AdbcDatabaseSetOption(&adbc_database, "entrypoint", "duckdb_adbc_init", &adbc_error);
// By default, we start an in-memory database, but you can optionally define a path to store it on disk.
AdbcDatabaseSetOption(&adbc_database, "path", "test.db", &adbc_error);
AdbcDatabaseInit(&adbc_database, &adbc_error);
```

--------------------------------

### Install Python ADBC Dependencies

Source: https://duckdb.org/docs/current/clients/adbc.html

Install the required driver manager and PyArrow packages.

```bash
pip install adbc_driver_manager pyarrow
```

--------------------------------

### Start DuckDB UI from SQL

Source: https://duckdb.org/docs/current/core_extensions/ui.html

Initializes the UI interface from within a SQL session.

```sql
CALL start_ui();
```

--------------------------------

### List CLI Help Options

Source: https://duckdb.org/docs/current/clients/cli/arguments.html

Displays all available command line options for the DuckDB CLI.

```bash
duckdb -help
```

--------------------------------

### Set Configuration via Environment Variable

Source: https://duckdb.org/docs/current/dev/sqllogictest/test_configuration

Example of setting a configuration option using an environment variable prefix.

```bash
DUCKDB_TEST_CHECKPOINT_ON_SHUTDOWN=1 unittest
```

--------------------------------

### Autocomplete File Path Suggestion

Source: https://duckdb.org/docs/current/clients/cli/autocomplete.html

Example showing the shell suggesting a file path.

```sql
SELECT student_id FROM 'd
```

```sql
'data/
```

--------------------------------

### Install unixODBC on Alpine

Source: https://duckdb.org/docs/current/core_extensions/odbc/overview.html

Use the apk package manager to install unixODBC on Alpine Linux.

```bash
sudo apk add unixodbc
```

--------------------------------

### Install unixODBC on RHEL/Fedora

Source: https://duckdb.org/docs/current/core_extensions/odbc/overview.html

Use the dnf package manager to install unixODBC on RHEL-based systems.

```bash
sudo dnf install unixODBC
```

--------------------------------

### Connect to Database

Source: https://duckdb.org/docs/current/clients/tertiary_clients/swift.html

Establish a connection to an existing database instance.

```swift
let connection = try database.connect()
```

--------------------------------

### Install unixODBC on Debian/Ubuntu

Source: https://duckdb.org/docs/current/core_extensions/odbc/overview.html

Use the apt package manager to install unixODBC on Debian-based systems.

```bash
sudo apt-get install unixodbc
```

--------------------------------

### Check installed extension version

Source: https://duckdb.org/docs/current/core_extensions/odbc/overview.html

Verify the installed version and commit ID of the odbc_scanner extension.

```sql
FROM duckdb_extensions()
WHERE extension_name = 'odbc_scanner';
```

--------------------------------

### prepared.start()

Source: https://duckdb.org/docs/current/clients/node_neo/overview.html

Starts the execution of a prepared statement and returns a pending result object for task control.

```APIDOC
## prepared.start()

### Description
Initiates the execution of a prepared statement, returning a pending result object that allows for manual control over the evaluation process.

### Methods
- **runTask()**: Executes a portion of the task. Returns `DuckDBPendingResultState.RESULT_READY` when complete.
- **getResult()**: Retrieves the final result set once the task is ready.
```

--------------------------------

### Install DuckDB Python Client in Termux

Source: https://duckdb.org/docs/current/dev/building/android.html

Install the DuckDB Python package via pip.

```bash
pip install --pre --upgrade duckdb
```

--------------------------------

### CLI initialization output

Source: https://duckdb.org/docs/current/clients/cli/overview

The output displayed upon successful initialization.

```text
-- Loading resources from prompt.sql
v⟨version⟩ ⟨git_hash⟩
Enter ".help" for usage hints.
Connected to a transient in-memory database.
Use ".open FILENAME" to reopen on a persistent database.
⚫◗
```

--------------------------------

### Install and Load Lance Extension

Source: https://duckdb.org/docs/current/core_extensions/lance.html

Commands to install and load the extension into the current DuckDB session.

```sql
INSTALL lance;
LOAD lance;
```

--------------------------------

### Start a Quack server

Source: https://duckdb.org/docs/current/quack/overview.html

Initializes a server session on the local host to expose current session data.

```sql
CALL quack_serve('quack:localhost');
```

--------------------------------

### Configure Go Client Build Environment

Source: https://duckdb.org/docs/current/dev/building/windows.html

Set the necessary environment variables to point to the DuckDB library files before building the Go client.

```batch
set PATH=C:\duckdb-go\libs\;%PATH%
set CGO_CFLAGS=-IC:\duckdb-go\libs\
set CGO_LDFLAGS=-LC:\duckdb-go\libs\ -lduckdb
go build
```

--------------------------------

### Install and load the ICU extension

Source: https://duckdb.org/docs/current/core_extensions/icu.html

Manually install and load the ICU extension from the official repository.

```sql
INSTALL icu;
LOAD icu;
```

--------------------------------

### Configure create_table and column_types

Source: https://duckdb.org/docs/current/core_extensions/odbc/functions.html

Example of enabling table creation and overriding type mappings for the destination database.

```sql
create_table=TRUE,
column_types=MAP {
    'DUCKDB_TYPE_VARCHAR': 'VARCHAR2(10)',
    'DUCKDB_TYPE_DECIMAL': 'NUMBER({typmod1},{typmod2})'}
```

--------------------------------

### quack_serve(uri, token, allow_other_hostname, disable_ssl)

Source: https://duckdb.org/docs/current/quack/reference.html

Starts a server on the specified URI. Returns the listen URI, URL, and authentication token.

```APIDOC
## quack_serve(uri, token := 'token_value', allow_other_hostname := false, disable_ssl := false)

### Description
Starts a server on the provided URI. By default, it is restricted to localhost. If a token is not provided, one is automatically generated.

### Parameters
- **uri** (VARCHAR) - Required - The URI to start the server on.
- **token** (VARCHAR) - Optional - Authentication token (minimum 4 characters).
- **allow_other_hostname** (BOOLEAN) - Optional - Whether to allow connections from other hostnames.
- **disable_ssl** (BOOLEAN) - Optional - Whether to disable SSL.
```

--------------------------------

### Install DuckDB Package

Source: https://duckdb.org/docs/current/clients/tertiary_clients/julia.html

Methods for installing the DuckDB package using the Julia package manager.

```julia
using Pkg
Pkg.add("DuckDB")
```

```julia
pkg> add DuckDB
```

--------------------------------

### Initialize Connection and Execute Queries in Rust

Source: https://duckdb.org/docs/current/clients/rust/overview.html

Demonstrates opening an in-memory database, creating a table, inserting data, and querying results using the DuckDB Rust API.

```rust
use duckdb::{params, Connection, Result};

#[derive(Debug)]
struct Person {
    id: i32,
    name: String,
    data: Option<Vec<u8>>,
}

fn main() -> Result<()> {
    let conn = Connection::open_in_memory()?;

    conn.execute_batch(
        r"CREATE SEQUENCE seq;
          CREATE TABLE person (
              id   INTEGER PRIMARY KEY DEFAULT NEXTVAL('seq'),
              name TEXT NOT NULL,
              data BLOB
          );",
    )?;

    let me = Person {
        id: 0,
        name: "Steven".to_string(),
        data: None,
    };
    conn.execute(
        "INSERT INTO person (name, data) VALUES (?, ?)",
        params![me.name, me.data],
    )?;

    let mut stmt = conn.prepare("SELECT id, name, data FROM person")?;
    let person_iter = stmt.query_map([], |row| {
        Ok(Person {
            id: row.get(0)?,
            name: row.get(1)?,
            data: row.get(2)?,
        })
    })?;

    for person in person_iter {
        println!("Found person {:?}", person.unwrap());
    }
    Ok(())
}
```

--------------------------------

### Install DuckDB from R-universe

Source: https://duckdb.org/docs/current/clients/r

Alternative installation method to bypass certain environment-specific dependency issues.

```r
install.packages("duckdb", repos = c("https://duckdb.r-universe.dev", "https://cloud.r-project.org"))
```

--------------------------------

### List Available Benchmarks

Source: https://duckdb.org/docs/current/dev/benchmark

Display all benchmarks currently available in the build.

```bash
build/release/benchmark/benchmark_runner --list
```

--------------------------------

### Install unixODBC on Linux

Source: https://duckdb.org/docs/current/clients/odbc/linux.html

Commands to install the unixODBC driver manager on various Linux distributions.

```bash
sudo apt-get install unixodbc odbcinst
```

```bash
sudo yum install unixODBC
```

--------------------------------

### Run All Benchmarks

Source: https://duckdb.org/docs/current/dev/benchmark

Execute every available benchmark in the suite.

```bash
build/release/benchmark/benchmark_runner
```

--------------------------------

### Point to a Prebuilt DuckDB Library

Source: https://duckdb.org/docs/current/clients/rust/troubleshoot.html

Configure environment variables to link against a manually downloaded DuckDB library instead of using the bundled version.

```bash
wget https://github.com/duckdb/duckdb/releases/download/v1.5.5/libduckdb-osx-universal.zip
unzip libduckdb-osx-universal.zip -d libduckdb

export DUCKDB_LIB_DIR=$PWD/libduckdb
export DUCKDB_INCLUDE_DIR=$DUCKDB_LIB_DIR
export DYLD_FALLBACK_LIBRARY_PATH=$DUCKDB_LIB_DIR   # LD_LIBRARY_PATH on Linux
cargo build
```

--------------------------------

### Install Specific DuckDB Version

Source: https://duckdb.org/docs/current/operations_manual/installing_duckdb/install_script

Installs a specific version of DuckDB by setting the DUCKDB_VERSION environment variable.

```bash
curl https://install.duckdb.org | DUCKDB_VERSION=1.2.2 bash
```

--------------------------------

### Install x86_64 unixODBC on macOS

Source: https://duckdb.org/docs/current/core_extensions/odbc/overview.html

Install the x86_64 version of Homebrew and unixODBC for Rosetta translation support.

```bash
arch -x86_64 /bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"
/usr/local/bin/brew install unixodbc
```

--------------------------------

### Download CSV File

Source: https://duckdb.org/docs/current/clients/tertiary_clients/swift.html

Use wget to fetch the exoplanet dataset locally.

```bash
wget https://exoplanetarchive.ipac.caltech.edu/TAP/sync?query=select+pl_name+,+disc_year+from+pscomppars&format=csv -O downloaded_exoplanets.csv
```

--------------------------------

### Install Termux Build Dependencies

Source: https://duckdb.org/docs/current/dev/building/android.html

Install required packages for building DuckDB within the Termux environment.

```bash
pkg install -y git ninja clang cmake python3
```

--------------------------------

### Executing Read Queries with mysql_query

Source: https://duckdb.org/docs/current/core_extensions/mysql.html

Example of attaching a MySQL database and executing a read query.

```sql
ATTACH 'host=localhost database=mysql' AS mysqldb (TYPE mysql);
SELECT * FROM mysql_query('mysqldb', 'SELECT * FROM cars LIMIT 3');
```

--------------------------------

### Install libduckdb to system directory on Linux

Source: https://duckdb.org/docs/current/clients/adbc.html

Copy the shared library to a system directory and update the linker cache.

```bash
sudo cp libduckdb.so /usr/local/lib/
sudo ldconfig
```

--------------------------------

### Start DuckDB UI from Command Line

Source: https://duckdb.org/docs/current/core_extensions/ui.html

Launches the DuckDB UI directly from the system terminal.

```bash
duckdb -ui
```

--------------------------------

### Hexdump output example

Source: https://duckdb.org/docs/current/internals/storage.html

Example output showing the magic bytes and version information in a DuckDB file.

```text
00000000  01 d0 e2 63 9c 13 39 3e  44 55 43 4b 2b 00 00 00  |...c..9>DUCK+...|
00000010  00 00 00 00                                       |....|
00000014
```

--------------------------------

### Use Version Hint File

Source: https://duckdb.org/docs/current/core_extensions/iceberg/overview.html

Provide a text file path to the version parameter to use its content as the metadata version.

```sql
SELECT *
FROM iceberg_snapshots(
    'data/iceberg/lineitem_iceberg',
    version = 'version-hint.txt'
);
```

--------------------------------

### Install build dependencies for Raspberry Pi

Source: https://duckdb.org/docs/current/dev/building/raspberry_pi.html

Install the necessary packages for building DuckDB on Raspberry Pi OS.

```bash
sudo apt-get update
sudo apt-get install -y git g++ cmake ninja-build
```

--------------------------------

### Verify DuckDB installation

Source: https://duckdb.org/docs/current/dev/building/python.html

Run a simple SQL query using the installed DuckDB package to verify the environment.

```bash
uv run python -c "import duckdb; print(duckdb.sql('SELECT 42').fetchall())"

```

--------------------------------

### Install DuckDB Wasm next build

Source: https://duckdb.org/docs/current/clients/wasm/overview.html

Install the latest unreleased build from the main branch for testing purposes.

```bash
npm install @duckdb/duckdb-wasm@next
```

--------------------------------

### Install and Load ICU Extension

Source: https://duckdb.org/docs/current/clients/rust/troubleshoot.html

Restore collation and time-zone support by installing and loading the ICU extension at runtime.

```rust
conn.execute_batch("INSTALL icu; LOAD icu;")?;
```

--------------------------------

### Install unixODBC via Homebrew

Source: https://duckdb.org/docs/current/clients/odbc/macos.html

Installs the unixODBC driver manager required for managing ODBC connections on macOS.

```bash
brew install unixodbc
```

--------------------------------

### Open and Connect Functions

Source: https://duckdb.org/docs/current/clients/c/api.html

Functions for managing database instances, connections, and client contexts.

```c
duckdb_instance_cache duckdb_create_instance_cache();
duckdb_state duckdb_get_or_create_from_cache(duckdb_instance_cache instance_cache, const char *path, duckdb_database *out_database, duckdb_config config, char **out_error);
void duckdb_destroy_instance_cache(duckdb_instance_cache *instance_cache);
duckdb_state duckdb_open(const char *path, duckdb_database *out_database);
duckdb_state duckdb_open_ext(const char *path, duckdb_database *out_database, duckdb_config config, char **out_error);
void duckdb_close(duckdb_database *database);
duckdb_state duckdb_connect(duckdb_database database, duckdb_connection *out_connection);
void duckdb_interrupt(duckdb_connection connection);
duckdb_query_progress_type duckdb_query_progress(duckdb_connection connection);
void duckdb_disconnect(duckdb_connection *connection);
void duckdb_connection_get_client_context(duckdb_connection connection, duckdb_client_context *out_context);
void duckdb_connection_get_arrow_options(duckdb_connection connection, duckdb_arrow_options *out_arrow_options);
idx_t duckdb_client_context_get_connection_id(duckdb_client_context context);
void duckdb_destroy_client_context(duckdb_client_context *context);
void duckdb_destroy_arrow_options(duckdb_arrow_options *arrow_options);
const char *duckdb_library_version();
duckdb_value duckdb_get_table_names(duckdb_connection connection, const char *query, bool qualified);
```

--------------------------------

### Azure SDK User-Agent Examples

Source: https://duckdb.org/docs/current/operations_manual/user_agents

Example user-agent strings generated by the Azure SDK for identity and storage operations.

```text
azsdk-cpp-identity/1.11.0 (Darwin 25.2.0 arm64 Darwin Kernel Version 25.2.0: Tue Nov 18 21:07:05 PST 2025; root:xnu-12377.61.12~1/RELEASE_ARM64_T6020 Cpp/201402)
```

```text
azsdk-cpp-storage-blobs/12.15.0 (Darwin 25.2.0 arm64 Darwin Kernel Version 25.2.0: Tue Nov 18 21:07:05 PST 2025; root:xnu-12377.61.12~1/RELEASE_ARM64_T6020 Cpp/201402)
```

--------------------------------

### Autocomplete File Name Suggestion

Source: https://duckdb.org/docs/current/clients/cli/autocomplete.html

Example showing the shell suggesting a specific file name.

```sql
SELECT student_id FROM 'data/
```

```sql
'data/grades.csv
```

--------------------------------

### Install DuckDB Python package from source

Source: https://duckdb.org/docs/current/dev/building/unofficial_and_unsupported_platforms.html

Command to build and install the Python package on riscv64 without using pre-built binaries.

```bash
pip install duckdb --no-binary duckdb
```

--------------------------------

### Install Xcode command line tools on macOS

Source: https://duckdb.org/docs/current/dev/building/python.html

Install the necessary Xcode command line tools required for building on macOS.

```bash
# Xcode command line tools
xcode-select --install

```

--------------------------------

### SQL Initialization File with Marker

Source: https://duckdb.org/docs/current/clients/java/connecting.html

A SQL file structure using the DUCKDB_CONNECTION_INIT_BELOW_MARKER comment to separate database-level and connection-level initialization.

```sql
-- Runs once, when the database instance is created.
SET memory_limit = '4GB';
CREATE OR REPLACE VIEW recent_events AS
    SELECT *
    FROM events
    WHERE ts > now() - INTERVAL 7 DAYS;

/* DUCKDB_CONNECTION_INIT_BELOW_MARKER */

-- Runs for every connection.
SET search_path = 'analytics';
```

--------------------------------

### Install DuckDB Wasm via npm

Source: https://duckdb.org/docs/current/clients/wasm/overview.html

Use the package manager to install the latest stable version of the DuckDB Wasm library.

```bash
npm install @duckdb/duckdb-wasm
```

--------------------------------

### Launch DuckDB UI

Source: https://duckdb.org/docs/current/operations_manual/duckdb_docker

Command to start the DuckDB UI once the container is running with host networking.

```sql
CALL start_ui();
```

--------------------------------

### Build DuckDB CLI and Python Client on Alpine Linux

Source: https://duckdb.org/docs/current/dev/building/linux.html

Build the CLI from source or install the Python client after installing required build dependencies.

```bash
apk add g++ git make cmake ninja
git clone https://github.com/duckdb/duckdb
cd duckdb
GEN=ninja make
```

```bash
apk add g++ py3-pip python3-dev
pip install duckdb
```

--------------------------------

### duckdb.install_extension

Source: https://duckdb.org/docs/current/clients/python/reference

Installs a DuckDB extension.

```APIDOC
## duckdb.install_extension(extension, *, force_install=False, repository=None, repository_url=None, version=None, connection=None)

### Description
Install an extension by name, with an optional version and/or repository to get the extension from.

### Parameters
- **extension** (str) - Required - Name of the extension.
- **force_install** (bool) - Optional - Force installation.
- **repository** (object) - Optional - Repository name.
- **repository_url** (object) - Optional - Repository URL.
- **version** (object) - Optional - Extension version.
- **connection** (duckdb.DuckDBPyConnection) - Optional - The connection object.
```

--------------------------------

### Query with Prepared Statements

Source: https://duckdb.org/docs/current/clients/python/dbapi.html

Demonstrates querying the database using '?' placeholders and retrieving the results.

```python
con.execute("SELECT item FROM items WHERE value > ?", [400])
print(con.fetchall())
```

```python
[('laptop',), ('chainsaw',)]
```

--------------------------------

### Open persistent database

Source: https://duckdb.org/docs/current/clients/cli/overview

Launches the CLI and opens or creates a persistent database file.

```bash
duckdb my_database.duckdb
```
Tokens:
Raw