Datasets:

duckdb-nsql-hub

/

duckdb-docs

like 4

Follow

DuckDB Text-2-SQL Bench 9

SQL

Query Syntax

Syntax

There are three syntaxes for denoting parameters in prepared statements: auto-incremented (` ?`), positional (` $1`), and named (` $param`). Note that not all clients support all of these syntaxes, e.g., the [JDBC client](#docs:api:java) only supports auto-incremented parameters in prepared statements. #### Example Data Set {#docs:sql:query_syntax:prepared_statements::example-data-set} In the following, we introduce the three different syntaxes and illustrate them with examples using the following table. ```sql CREATE TABLE person (name VARCHAR, age BIGINT); INSERT INTO person VALUES ('Alice', 37), ('Ana', 35), ('Bob', 41), ('Bea', 25); ``` In our example query, we'll look for people whose name starts with a `B` and are at least 40 years old. This will return a single row `<'Bob', 41>`. #### Auto-Incremented Parameters: `?` {#docs:sql:query_syntax:prepared_statements::auto-incremented-parameters-} DuckDB support using prepared statements with auto-incremented indexing, i.e., the position of the parameters in the query corresponds to their position in the execution statement. For example: ```sql PREPARE query_person AS SELECT * FROM person WHERE starts_with(name, ?) AND age >= ?; ``` Using the CLI client, the statement is executed as follows. ```sql EXECUTE query_person('B', 40); ``` #### Positional Parameters: `$1` {#docs:sql:query_syntax:prepared_statements::positional-parameters-1} Prepared statements can use positional parameters, where parameters are denoted with an integer (` $1`, `$2`). For example: ```sql PREPARE query_person AS SELECT * FROM person WHERE starts_with(name, $2) AND age >= $1; ``` Using the CLI client, the statement is executed as follows. Note that the first parameter corresponds to `$1`, the second to `$2`, and so on. ```sql EXECUTE query_person(40, 'B'); ``` #### Named Parameters: `$parameter` {#docs:sql:query_syntax:prepared_statements::named-parameters-parameter} DuckDB also supports names parameters where parameters are denoted with `$parameter_name`. For example: ```sql PREPARE query_person AS SELECT * FROM person WHERE starts_with(name, $name_start_letter) AND age >= $minimum_age; ``` Using the CLI client, the statement is executed as follows. ```sql EXECUTE query_person(name_start_letter := 'B', minimum_age := 40); ```

SQL

Query Syntax

Dropping Prepared Statements: `DEALLOCATE`

To drop a prepared statement, use the `DEALLOCATE` statement: ```sql DEALLOCATE query_person; ``` Alternatively, use: ```sql DEALLOCATE PREPARE query_person; ```

SQL

Data Types

General-Purpose Data Types

The table below shows all the built-in general-purpose data types. The alternatives listed in the aliases column can be used to refer to these types as well, however, note that the aliases are not part of the SQL standard and hence might not be accepted by other database engines. | Name | Aliases | Description | |:--|:--|:----| | `BIGINT` | `INT8`, `LONG` | signed eight-byte integer | | `BIT` | `BITSTRING` | string of 1s and 0s | | `BLOB` | `BYTEA`, `BINARY,` `VARBINARY` | variable-length binary data | | `BOOLEAN` | `BOOL`, `LOGICAL` | logical Boolean (true/false) | | `DATE` | | calendar date (year, month day) | | `DECIMAL(prec, scale)` | `NUMERIC(prec, scale)` | fixed-precision number with the given width (precision) and scale, defaults to `prec = 18` and `scale = 3` | | `DOUBLE` | `FLOAT8`, | double precision floating-point number (8 bytes) | | `FLOAT` | `FLOAT4`, `REAL` | single precision floating-point number (4 bytes)| | `HUGEINT` | | signed sixteen-byte integer| | `INTEGER` | `INT4`, `INT`, `SIGNED` | signed four-byte integer | | `INTERVAL` | | date / time delta | | `JSON` | | JSON object (via the [`json` extension](#docs:data:json:overview)) | | `SMALLINT` | `INT2`, `SHORT` | signed two-byte integer| | `TIME` | | time of day (no time zone) | | `TIMESTAMP WITH TIME ZONE` | `TIMESTAMPTZ` | combination of time and date that uses the current time zone | | `TIMESTAMP` | `DATETIME` | combination of time and date | | `TINYINT` | `INT1` | signed one-byte integer| | `UBIGINT` | | unsigned eight-byte integer | | `UHUGEINT` | | unsigned sixteen-byte integer | | `UINTEGER` | | unsigned four-byte integer | | `USMALLINT` | | unsigned two-byte integer | | `UTINYINT` | | unsigned one-byte integer | | `UUID` | | UUID data type | | `VARCHAR` | `CHAR`, `BPCHAR`, `TEXT`, `STRING` | variable-length character string | Implicit and explicit typecasting is possible between numerous types, see the [Typecasting](#docs:sql:data_types:typecasting) page for details.

SQL

Data Types

Nested / Composite Types

DuckDB supports five nested data types: `ARRAY`, `LIST`, `MAP`, `STRUCT`, and `UNION`. Each supports different use cases and has a different structure. | Name | Description | Rules when used in a column | Build from values | Define in DDL/CREATE | |:-|:---|:---|:--|:--| | [`ARRAY`](#docs:sql:data_types:array) | An ordered, fixed-length sequence of data values of the same type. | Each row must have the same data type within each instance of the `ARRAY` and the same number of elements. | `[1, 2, 3]` | `INTEGER[3]` | | [`LIST`](#docs:sql:data_types:list) | An ordered sequence of data values of the same type. | Each row must have the same data type within each instance of the `LIST`, but can have any number of elements. | `[1, 2, 3]` | `INTEGER[]` | | [`MAP`](#docs:sql:data_types:map) | A dictionary of multiple named values, each key having the same type and each value having the same type. Keys and values can be any type and can be different types from one another. | Rows may have different keys. | `map([1, 2], ['a', 'b'])` | `MAP(INTEGER, VARCHAR)` | | [`STRUCT`](#docs:sql:data_types:struct) | A dictionary of multiple named values, where each key is a string, but the value can be a different type for each key. | Each row must have the same keys. | `{'i': 42, 'j': 'a'}` | `STRUCT(i INTEGER, j VARCHAR)` | | [`UNION`](#docs:sql:data_types:union) | A union of multiple alternative data types, storing one of them in each value at a time. A union also contains a discriminator “tag” value to inspect and access the currently set member type. | Rows may be set to different member types of the union. | `union_value(num := 2)` | `UNION(num INTEGER, text VARCHAR)` | #### Updating Values of Nested Types {#docs:sql:data_types:overview::updating-values-of-nested-types} When performing _updates_ on values of nested types, DuckDB performs a _delete_ operation followed by an _insert_ operation. When used in a table with ART indexes (either via explicit indexes or primary keys/unique constraints), this can lead to [unexpected constraint violations](#docs:sql:indexes::over-eager-unique-constraint-checking). For example: ```sql CREATE TABLE students (id INTEGER PRIMARY KEY, name VARCHAR); INSERT INTO students VALUES (1, 'Student 1'); UPDATE tbl SET j = [2] WHERE i = 1; ``` ```console Constraint Error: Duplicate key "i: 1" violates primary key constraint. If this is an unexpected constraint violation please double check with the known index limitations section in our documentation (https://duckdb.org/docs/sql/indexes). ```

SQL

Data Types

Nesting

`ARRAY`, `LIST`, `MAP`, `STRUCT`, and `UNION` types can be arbitrarily nested to any depth, so long as the type rules are observed. Struct with `LIST`s: ```sql SELECT {'birds': ['duck', 'goose', 'heron'], 'aliens': NULL, 'amphibians': ['frog', 'toad']}; ``` Struct with list of `MAP`s: ```sql SELECT {'test': [MAP([1, 5], [42.1, 45]), MAP([1, 5], [42.1, 45])]}; ``` A list of `UNION`s: ```sql SELECT [union_value(num := 2), union_value(str := 'ABC')::UNION(str VARCHAR, num INTEGER)]; ```

SQL

Data Types

Performance Implications

The choice of data types can have a strong effect on performance. Please consult the [Performance Guide](#docs:guides:performance:schema) for details.

SQL

Data Types

Array Type

An `ARRAY` column stores fixed-sized arrays. All fields in the column must have the same length and the same underlying type. Arrays are typically used to store arrays of numbers, but can contain any uniform data type, including `ARRAY`, [`LIST`](#docs:sql:data_types:list) and [`STRUCT`](#docs:sql:data_types:struct) types. Arrays can be used to store vectors such as [word embeddings](https://en.wikipedia.org/wiki/Word_embedding) or image embeddings. To store variable-length lists, use the [`LIST` type](#docs:sql:data_types:list). See the [data types overview](#docs:sql:data_types:overview) for a comparison between nested data types. > The `ARRAY` type in PostgreSQL allows variable-length fields. DuckDB's `ARRAY` type is fixed-length.

SQL

Data Types

Creating Arrays

Arrays can be created using the [`array_value(expr, ...)` function](#docs:sql:functions:array::array_valueindex). Construct with the `array_value` function: ```sql SELECT array_value(1, 2, 3); ``` You can always implicitly cast an array to a list (and use list functions, like `list_extract`, `[i]`): ```sql SELECT array_value(1, 2, 3)[2]; ``` You can cast from a list to an array (the dimensions have to match): ```sql SELECT [3, 2, 1]::INTEGER[3]; ``` Arrays can be nested: ```sql SELECT array_value(array_value(1, 2), array_value(3, 4), array_value(5, 6)); ``` Arrays can store structs: ```sql SELECT array_value({'a': 1, 'b': 2}, {'a': 3, 'b': 4}); ```

SQL

Data Types

Defining an Array Field

Arrays can be created using the `⟨TYPE_NAME⟩[⟨LENGTH⟩]` syntax. For example, to create an array field for 3 integers, run: ```sql CREATE TABLE array_table (id INTEGER, arr INTEGER[3]); INSERT INTO array_table VALUES (10, [1, 2, 3]), (20, [4, 5, 6]); ```

SQL

Data Types

Retrieving Values from Arrays

Retrieving one or more values from an array can be accomplished using brackets and slicing notation, or through [list functions](#docs:sql:functions:list::list-functions) like `list_extract` and `array_extract`. Using the example in [Defining an Array Field](#::defining-an-array-field). The following queries for extracting the second element of an array are equivalent: ```sql SELECT id, arr[1] AS element FROM array_table; SELECT id, list_extract(arr, 1) AS element FROM array_table; SELECT id, array_extract(arr, 1) AS element FROM array_table; ``` | id | element | |---:|--------:| | 10 | 1 | | 20 | 4 | Using the slicing notation returns a `LIST`: ```sql SELECT id, arr[1:2] AS elements FROM array_table; ``` | id | elements | |---:|----------| | 10 | [1, 2] | | 20 | [4, 5] |

SQL

Data Types

Functions

All [`LIST` functions](#docs:sql:functions:list) work with the `ARRAY` type. Additionally, several `ARRAY`-native functions are also supported. See the [`ARRAY` functions](#docs:sql:functions:array::array-native-functions).

SQL

Data Types

Examples

Create sample data: ```sql CREATE TABLE x (i INTEGER, v FLOAT[3]); CREATE TABLE y (i INTEGER, v FLOAT[3]); INSERT INTO x VALUES (1, array_value(1.0::FLOAT, 2.0::FLOAT, 3.0::FLOAT)); INSERT INTO y VALUES (1, array_value(2.0::FLOAT, 3.0::FLOAT, 4.0::FLOAT)); ``` Compute cross product: ```sql SELECT array_cross_product(x.v, y.v) FROM x, y WHERE x.i = y.i; ``` Compute cosine similarity: ```sql SELECT array_cosine_similarity(x.v, y.v) FROM x, y WHERE x.i = y.i; ```

SQL

Data Types

Ordering

The ordering of `ARRAY` instances is defined using a lexicographical order. `NULL` values compare greater than all other values and are considered equal to each other.

SQL

Data Types

See Also

For more functions, see [List Functions](#docs:sql:functions:list).

SQL

Data Types

Bitstring Type

<div class="narrow_table"></div> | Name | Aliases | Description | |:---|:---|:---| | `BITSTRING` | `BIT` | variable-length strings of 1s and 0s | Bitstrings are strings of 1s and 0s. The bit type data is of variable length. A bitstring value requires 1 byte for each group of 8 bits, plus a fixed amount to store some metadata. By default bitstrings will not be padded with zeroes. Bitstrings can be very large, having the same size restrictions as `BLOB`s.

SQL

Data Types

Creating a Bitstring

A string encoding a bitstring can be cast to a `BITSTRING`: ```sql SELECT '101010'::BITSTRING AS b; ``` <div class="narrow_table monospace_table"></div> | b | |--------| | 101010 | Create a `BITSTRING` with predefined length is possible with the `bitstring` function. The resulting bitstring will be left-padded with zeroes. ```sql SELECT bitstring('0101011', 12) AS b; ``` | b | |--------------| | 000000101011 | Numeric values (integer and float values) can also be converted to a `BITSTRING` via casting. For example: ```sql SELECT 123::BITSTRING AS b; ``` <div class="narrow_table monospace_table"></div> | b | |----------------------------------| | 00000000000000000000000001111011 |

SQL

Data Types

Functions

See [Bitstring Functions](#docs:sql:functions:bitstring).

SQL

Data Types

Blob Type

<div class="narrow_table"></div> | Name | Aliases | Description | |:---|:---|:---| | `BLOB` | `BYTEA`, `BINARY`, `VARBINARY` | variable-length binary data | The blob (**B**inary **L**arge **OB**ject) type represents an arbitrary binary object stored in the database system. The blob type can contain any type of binary data with no restrictions. What the actual bytes represent is opaque to the database system. Create a `BLOB` value with a single byte (170): ```sql SELECT '\xAA'::BLOB; ``` Create a `BLOB` value with three bytes (170, 171, 172): ```sql SELECT '\xAA\xAB\xAC'::BLOB; ``` Create a `BLOB` value with two bytes (65, 66): ```sql SELECT 'AB'::BLOB; ``` Blobs are typically used to store non-textual objects that the database does not provide explicit support for, such as images. While blobs can hold objects up to 4 GB in size, typically it is not recommended to store very large objects within the database system. In many situations it is better to store the large file on the file system, and store the path to the file in the database system in a `VARCHAR` field.

SQL

Data Types

Functions

See [Blob Functions](#docs:sql:functions:blob).

SQL

Data Types

Boolean Type

<div class="narrow_table"></div> | Name | Aliases | Description | |:---|:---|:---| | `BOOLEAN` | `BOOL` | Logical Boolean (` true`/`false`) | The `BOOLEAN` type represents a statement of truth (“true” or “false”). In SQL, the `BOOLEAN` field can also have a third state “unknown” which is represented by the SQL `NULL` value. Select the three possible values of a `BOOLEAN` column: ```sql SELECT true, false, NULL::BOOLEAN; ``` Boolean values can be explicitly created using the literals `true` and `false`. However, they are most often created as a result of comparisons or conjunctions. For example, the comparison `i > 10` results in a Boolean value. Boolean values can be used in the `WHERE` and `HAVING` clauses of a SQL statement to filter out tuples from the result. In this case, tuples for which the predicate evaluates to `true` will pass the filter, and tuples for which the predicate evaluates to `false` or `NULL` will be filtered out. Consider the following example: Create a table with the values 5, 15 and `NULL`: ```sql CREATE TABLE integers (i INTEGER); INSERT INTO integers VALUES (5), (15), (NULL); ``` Select all entries where `i > 10`: ```sql SELECT * FROM integers WHERE i > 10; ``` In this case 5 and `NULL` are filtered out (` 5 > 10` is `false` and `NULL > 10` is `NULL`): | i | |---:| | 15 |

SQL

Data Types

Conjunctions

The `AND`/`OR` conjunctions can be used to combine Boolean values. Below is the truth table for the `AND` conjunction (i.e., `x AND y`). <div class="narrow_table"></div> | X | X AND true | X AND false | X AND NULL | |-------|-------|-------|-------| | true | true | false | NULL | | false | false | false | false | | NULL | NULL | false | NULL | Below is the truth table for the `OR` conjunction (i.e., `x OR y`). <div class="narrow_table"></div> | X | X OR true | X OR false | X OR NULL | |-------|------|-------|------| | true | true | true | true | | false | true | false | NULL | | NULL | true | NULL | NULL |

SQL

Data Types

Expressions

See [Logical Operators](#docs:sql:expressions:logical_operators) and [Comparison Operators](#docs:sql:expressions:comparison_operators).

SQL

Data Types

Date Types

<div class="narrow_table"></div> | Name | Aliases | Description | |:-------|:--------|:--------------------------------| | `DATE` | | calendar date (year, month day) | A date specifies a combination of year, month and day. DuckDB follows the SQL standard's lead by counting dates exclusively in the Gregorian calendar, even for years before that calendar was in use. Dates can be created using the `DATE` keyword, where the data must be formatted according to the ISO 8601 format (` YYYY-MM-DD`). ```sql SELECT DATE '1992-09-20'; ```

SQL

Data Types

Special Values

There are also three special date values that can be used on input: <div class="narrow_table"></div> | Input string | Description | |:-------------|:----------------------------------| | epoch | 1970-01-01 (Unix system day zero) | | infinity | later than all other dates | | -infinity | earlier than all other dates | The values `infinity` and `-infinity` are specially represented inside the system and will be displayed unchanged; but `epoch` is simply a notational shorthand that will be converted to the date value when read. ```sql SELECT '-infinity'::DATE AS negative, 'epoch'::DATE AS epoch, 'infinity'::DATE AS positive; ``` | negative | epoch | positive | |-----------|------------|----------| | -infinity | 1970-01-01 | infinity |

SQL

Data Types

Functions

See [Date Functions](#docs:sql:functions:date).

SQL

Data Types

Enum Data Type

<div class="narrow_table"></div> | Name | Description | |:--|:-----| | enum | Dictionary Encoding representing all possible string values of a column. | The enum type represents a dictionary data structure with all possible unique values of a column. For example, a column storing the days of the week can be an enum holding all possible days. Enums are particularly interesting for string columns with low cardinality (i.e., fewer distinct values). This is because the column only stores a numerical reference to the string in the enum dictionary, resulting in immense savings in disk storage and faster query performance.

SQL

Data Types

Enum Definition

Enum types are created from either a hardcoded set of values or from a select statement that returns a single column of `VARCHAR`s. The set of values in the select statement will be deduplicated, but if the enum is created from a hardcoded set there may not be any duplicates. Create enum using hardcoded values: ```sql CREATE TYPE ⟨enum_name⟩ AS ENUM ([⟨value_1⟩, ⟨value_2⟩,...]); ``` Create enum using a `SELECT` statement that returns a single column of `VARCHAR`s: ```sql CREATE TYPE ⟨enum_name⟩ AS ENUM (select_expression⟩); ``` For example: Creates new user defined type 'mood' as an enum: ```sql CREATE TYPE mood AS ENUM ('sad', 'ok', 'happy'); ``` This will fail since the `mood` type already exists: ```sql CREATE TYPE mood AS ENUM ('sad', 'ok', 'happy', 'anxious'); ``` This will fail since enums cannot hold `NULL` values: ```sql CREATE TYPE breed AS ENUM ('maltese', NULL); ``` This will fail since enum values must be unique: ```sql CREATE TYPE breed AS ENUM ('maltese', 'maltese'); ``` Create an enum from a select statement. First create an example table of values: ```sql CREATE TABLE my_inputs AS SELECT 'duck' AS my_varchar UNION ALL SELECT 'duck' AS my_varchar UNION ALL SELECT 'goose' AS my_varchar; ``` Create an enum using the unique string values in the `my_varchar` column: ```sql CREATE TYPE birds AS ENUM (SELECT my_varchar FROM my_inputs); ``` Show the available values in the `birds` enum using the `enum_range` function: ```sql SELECT enum_range(NULL::birds) AS my_enum_range; ``` <div class="narrow_table"></div> | my_enum_range | |-----------------| | `[duck, goose]` |

SQL

Data Types

Enum Usage

After an enum has been created, it can be used anywhere a standard built-in type is used. For example, we can create a table with a column that references the enum. Creates a table `person`, with attributes `name` (string type) and `current_mood` (mood type): ```sql CREATE TABLE person ( name TEXT, current_mood mood ); ``` Inserts tuples in the `person` table: ```sql INSERT INTO person VALUES ('Pedro', 'happy'), ('Mark', NULL), ('Pagliacci', 'sad'), ('Mr. Mackey', 'ok'); ``` The following query will fail since the mood type does not have `quackity-quack` value. ```sql INSERT INTO person VALUES ('Hannes', 'quackity-quack'); ``` The string `sad` is cast to the type `mood`, returning a numerical reference value. This makes the comparison a numerical comparison instead of a string comparison. ```sql SELECT * FROM person WHERE current_mood = 'sad'; ``` | name | current_mood | |-----------|--------------| | Pagliacci | sad | If you are importing data from a file, you can create an enum for a `VARCHAR` column before importing. Given this, the following subquery selects automatically selects only distinct values: ```sql CREATE TYPE mood AS ENUM (SELECT mood FROM 'path/to/file.csv'); ``` Then you can create a table with the enum type and import using any data import statement: ```sql CREATE TABLE person (name TEXT, current_mood mood); COPY person FROM 'path/to/file.csv'; ```

SQL

Data Types

Enums vs. Strings

DuckDB enums are automatically cast to `VARCHAR` types whenever necessary. This characteristic allows for enum columns to be used in any `VARCHAR` function. In addition, it also allows for comparisons between different enum columns, or an enum and a `VARCHAR` column. For example: Regexp_matches is a function that takes a VARCHAR, hence current_mood is cast to VARCHAR: ```sql SELECT regexp_matches(current_mood, '.*a.*') AS contains_a FROM person; ``` | contains_a | |:-----------| | true | | NULL | | true | | false | Create a new mood and table: ```sql CREATE TYPE new_mood AS ENUM ('happy', 'anxious'); CREATE TABLE person_2 ( name text, current_mood mood, future_mood new_mood, past_mood VARCHAR ); ``` Since the `current_mood` and `future_mood` columns are constructed on different enum types, DuckDB will cast both enums to strings and perform a string comparison: ```sql SELECT * FROM person_2 WHERE current_mood = future_mood; ``` When comparing the `past_mood` column (string), DuckDB will cast the `current_mood` enum to `VARCHAR` and perform a string comparison: ```sql SELECT * FROM person_2 WHERE current_mood = past_mood; ```

SQL

Data Types

Enum Removal

Enum types are stored in the catalog, and a catalog dependency is added to each table that uses them. It is possible to drop an enum from the catalog using the following command: ```sql DROP TYPE ⟨enum_name⟩; ``` Currently, it is possible to drop enums that are used in tables without affecting the tables. > **Warning. ** This behavior of the enum removal feature is subject to change. In future releases, it is expected that any dependent columns must be removed before dropping the enum, or the enum must be dropped with the additional `CASCADE` parameter.

SQL

Data Types

Comparison of Enums

Enum values are compared according to their order in the enum's definition. For example: ```sql CREATE TYPE mood AS ENUM ('sad', 'ok', 'happy'); ``` ```sql SELECT 'sad'::mood < 'ok'::mood AS comp; ``` | comp | |-----:| | true | ```sql SELECT unnest(['ok'::mood, 'happy'::mood, 'sad'::mood]) AS m ORDER BY m; ``` | m | |-------| | sad | | ok | | happy |

SQL

Data Types

Functions

See [Enum Functions](#docs:sql:functions:enum).

SQL

Data Types

Interval Type

`INTERVAL`s represent periods of time that can be added to or subtracted from `DATE`, `TIMESTAMP`, `TIMESTAMPTZ`, or `TIME` values. <div class="narrow_table"></div> | Name | Description | |:---|:---| | `INTERVAL` | Period of time | An `INTERVAL` can be constructed by providing amounts together with units. Units that aren't *months*, *days*, or *microseconds* are converted to equivalent amounts in the next smaller of these three basis units. ```sql SELECT INTERVAL 1 YEAR, -- single unit using YEAR keyword; stored as 12 months INTERVAL (random() * 10) YEAR, -- parentheses necessary for variable amounts; -- stored as integer number of months INTERVAL '1 month 1 day', -- string type necessary for multiple units; stored as (1 month, 1 day) '16 months'::INTERVAL, -- string cast supported; stored as 16 months '48:00:00'::INTERVAL, -- HH::MM::SS string supported; stored as (48 * 60 * 60 * 1e6 microseconds) ; ``` > **Warning. ** Decimal values can be used in strings but are rounded to integers. > ```sql > SELECT INTERVAL '1.5' YEARS; > -- Returns 12 months; equivalent to `to_years(CAST(trunc(1.5) AS INTEGER))` > ``` > For more precision, use a more granular unit; e.g., `18 MONTHS` instead of `'1.5' YEARS`. Three basis units are necessary because a month does not correspond to a fixed amount of days (February has fewer days than March) and a day doesn't correspond to a fixed amount of microseconds. The division into components makes the `INTERVAL` class suitable for adding or subtracting specific time units to a date. For example, we can generate a table with the first day of every month using the following SQL query: ```sql SELECT DATE '2000-01-01' + INTERVAL (i) MONTH FROM range(12) t(i); ``` When `INTERVAL`s are deconstructed via the `datepart` function, the *months* component is additionally split into years and months, and the *microseconds* component is split into hours, minutes, and microseconds. The *days* component is not split into additional units. To demonstrate this, the following query generates an `INTERVAL` called `period` by summing random amounts of the three basis units. It then extracts the aforementioned six parts from `period`, adds them back together, and confirms that the result is always equal to the original `period`. ```sql SELECT period = list_reduce( [INTERVAL (datepart(part, period) || part) FOR part IN ['year', 'month', 'day', 'hour', 'minute', 'microsecond'] ], (i1, i2) -> i1 + i2 ) -- always true FROM ( VALUES ( INTERVAL (random() * 123_456_789_123) MICROSECONDS + INTERVAL (random() * 12_345) DAYS + INTERVAL (random() * 12_345) MONTHS ) ) _(period); ``` > **Warning. ** The *microseconds* component is split only into hours, minutes, and microseconds, rather than hours, minutes, *seconds*, and microseconds. Additionally, the amounts of centuries, decades, quarters, seconds, and milliseconds in an `INTERVAL`, rounded down to the nearest integer, can be extracted via the `datepart` function. However, these components are not required to reassemble the original `INTERVAL`. In fact, if the previous query additionally extracted decades or seconds, then the sum of extracted parts would generally be larger than the original `period` since this would double count the months and microseconds components, respectively. > All units use 0-based indexing, except for quarters, which use 1-based indexing. For example: ```sql SELECT datepart('decade', INTERVAL 12 YEARS), -- returns 1 datepart('year', INTERVAL 12 YEARS), -- returns 12 datepart('second', INTERVAL 1_234 MILLISECONDS), -- returns 1 datepart('microsecond', INTERVAL 1_234 MILLISECONDS), -- returns 1_234_000 ```

SQL

Data Types

Arithmetic with Timestamps, Dates and Intervals

`INTERVAL`s can be added to and subtracted from `TIMESTAMP`s, `TIMESTAMPTZ`s, `DATE`s, and `TIME`s using the `+` and `-` operators. ```sql SELECT DATE '2000-01-01' + INTERVAL 1 YEAR, TIMESTAMP '2000-01-01 01:33:30' - INTERVAL '1 month 13 hours', TIME '02:00:00' - INTERVAL '3 days 23 hours', -- wraps; equals TIME '03:00:00' ; ``` Conversely, subtracting two `TIMESTAMP`s or two `TIMESTAMPTZ`s from one another creates an `INTERVAL` describing the difference between the timestamps with only the *days and microseconds* components. For example: ```sql SELECT TIMESTAMP '2000-02-06 12:00:00' - TIMESTAMP '2000-01-01 11:00:00', -- 36 days 1 hour TIMESTAMP '2000-02-01' + (TIMESTAMP '2000-02-01' - TIMESTAMP '2000-01-01'), -- '2000-03-03', NOT '2000-03-01' ; ``` Subtracting two `DATE`s from one another does not create an `INTERVAL` but rather returns the number of days between the given dates as integer value. > **Warning. ** Extracting a component of the `INTERVAL` difference between two `TIMESTAMP`s is not equivalent to computing the number of partition boundaries between the two `TIMESTAMP`s for the corresponding unit, as computed by the `datediff` function: > ```sql > SELECT > datediff('day', TIMESTAMP '2020-01-01 01:00:00', TIMESTAMP '2020-01-02 00:00:00'), -- 1 > datepart('day', TIMESTAMP '2020-01-02 00:00:00' - TIMESTAMP '2020-01-01 01:00:00'), -- 0 > ; > ```

SQL

Data Types

Equality and Comparison

For equality and ordering comparisons only, the total number of microseconds in an `INTERVAL` is computed by converting the days basis unit to `24 * 60 * 60 * 1e6` microseconds and the months basis unit to 30 days, or `30 * 24 * 60 * 60 * 1e6` microseconds. As a result, `INTERVAL`s can compare equal even when they are functionally different, and the ordering of `INTERVAL`s is not always preserved when they are added to dates or timestamps. For example: * `INTERVAL 30 DAYS = INTERVAL 1 MONTH` * but `DATE '2020-01-01' + INTERVAL 30 DAYS != DATE '2020-01-01' + INTERVAL 1 MONTH`. and * `INTERVAL '30 days 12 hours' > INTERVAL 1 MONTH` * but `DATE '2020-01-01' + INTERVAL '30 days 12 hours' < DATE '2020-01-01' + INTERVAL 1 MONTH`.

SQL

Data Types

Functions

See the [Date Part Functions page](#docs:sql:functions:datepart) for a list of available date parts for use with an `INTERVAL`. See the [Interval Operators page](#docs:sql:functions:interval) for functions that operate on intervals.

SQL

Data Types

List Type

A `LIST` column encodes lists of values. Fields in the column can have values with different lengths, but they must all have the same underlying type. `LIST`s are typically used to store arrays of numbers, but can contain any uniform data type, including other `LIST`s and `STRUCT`s. `LIST`s are similar to PostgreSQL's `ARRAY` type. DuckDB uses the `LIST` terminology, but some [`array_` functions](#docs:sql:functions:list) are provided for PostgreSQL compatibility. See the [data types overview](#docs:sql:data_types:overview) for a comparison between nested data types. > For storing fixed-length lists, DuckDB uses the [`ARRAY` type](#docs:sql:data_types:array).

SQL

Data Types

Creating Lists

Lists can be created using the [`list_value(expr, ...)`](#docs:sql:functions:list::list_valueany-) function or the equivalent bracket notation `[expr, ...]`. The expressions can be constants or arbitrary expressions. To create a list from a table column, use the [`list`](#docs:sql:functions:aggregates::general-aggregate-functions) aggregate function. List of integers: ```sql SELECT [1, 2, 3]; ``` List of strings with a `NULL` value: ```sql SELECT ['duck', 'goose', NULL, 'heron']; ``` List of lists with `NULL` values: ```sql SELECT [['duck', 'goose', 'heron'], NULL, ['frog', 'toad'], []]; ``` Create a list with the list_value function: ```sql SELECT list_value(1, 2, 3); ``` Create a table with an `INTEGER` list column and a `VARCHAR` list column: ```sql CREATE TABLE list_table (int_list INTEGER[], varchar_list VARCHAR[]); ```

SQL

Data Types

Retrieving from Lists

Retrieving one or more values from a list can be accomplished using brackets and slicing notation, or through [list functions](#docs:sql:functions:list) like `list_extract`. Multiple equivalent functions are provided as aliases for compatibility with systems that refer to lists as arrays. For example, the function `array_slice`. > We wrap the list creation in parenthesis so that it happens first. > This is only needed in our basic examples here, not when working with a list column. > For example, this can't be parsed: `SELECT ['a', 'b', 'c'][1]`. <div class="narrow_table monospace_table"></div> | Example | Result | |:-----------------------------------------|:-----------| | SELECT (['a', 'b', 'c'])[3] | 'c' | | SELECT (['a', 'b', 'c'])[-1] | 'c' | | SELECT (['a', 'b', 'c'])[2 + 1] | 'c' | | SELECT list_extract(['a', 'b', 'c'], 3) | 'c' | | SELECT (['a', 'b', 'c'])[1:2] | ['a', 'b'] | | SELECT (['a', 'b', 'c'])[:2] | ['a', 'b'] | | SELECT (['a', 'b', 'c'])[-2:] | ['b', 'c'] | | SELECT list_slice(['a', 'b', 'c'], 2, 3) | ['b', 'c'] |

SQL

Data Types

Comparison and Ordering

The `LIST` type can be compared using all the [comparison operators](#docs:sql:expressions:comparison_operators). These comparisons can be used in [logical expressions](#docs:sql:expressions:logical_operators) such as `WHERE` and `HAVING` clauses, and return [`BOOLEAN` values](#docs:sql:data_types:boolean). The `LIST` ordering is defined positionally using the following rules, where `min_len = min(len(l1), len(l2))`. * **Equality.** `l1` and `l2` are equal, if for each `i` in `[1, min_len]`: `l1[i] = l2[i]`. * **Less Than**. For the first index `i` in `[1, min_len]` where `l1[i] != l2[i]`: If `l1[i] < l2[i]`, `l1` is less than `l2`. `NULL` values are compared following PostgreSQL's semantics. Lower nesting levels are used for tie-breaking. Here are some queries returning `true` for the comparison. ```sql SELECT [1, 2] < [1, 3] AS result; ``` ```sql SELECT [[1], [2, 4, 5]] < [[2]] AS result; ``` ```sql SELECT [ ] < [1] AS result; ``` These queries return `false`. ```sql SELECT [ ] < [ ] AS result; ``` ```sql SELECT [1, 2] < [1] AS result; ``` These queries return `NULL`. ```sql SELECT [1, 2] < [1, NULL, 4] AS result; ```

SQL

Data Types

Updating Lists

Updates on lists are internally represented as an insert and a delete operation. Therefore, updating list values may lead to a duplicate key error on primary/unique keys. See the following example: ```sql CREATE TABLE tbl (id INTEGER PRIMARY KEY, lst INTEGER[], comment VARCHAR); INSERT INTO tbl VALUES (1, [12, 34], 'asd'); UPDATE tbl SET lst = [56, 78] WHERE id = 1; ``` ```console Constraint Error: Duplicate key "id: 1" violates primary key constraint. If this is an unexpected constraint violation please double check with the known index limitations section in our documentation (https://duckdb.org/docs/sql/indexes). ```

SQL

Data Types

Functions

See [List Functions](#docs:sql:functions:list).

SQL

Data Types

Literal Types

DuckDB has special literal types for representing `NULL`, integer and string literals in queries. These have their own binding and conversion rules. > Prior to DuckDB version 0.10.0, integer and string literals behaved identically to the `INTEGER` and `VARCHAR` types.

SQL

Data Types

Null Literals

The `NULL` literal is denoted with the keyword `NULL`. The `NULL` literal can be implicitly converted to any other type.

SQL

Data Types

Integer Literals

Integer literals are denoted as a sequence of one or more digits. At runtime, these result in values of the `INTEGER_LITERAL` type. `INTEGER_LITERAL` types can be implicitly converted to any [integer type](#docs:sql:data_types:numeric::integer-types) in which the value fits. For example, the integer literal `42` can be implicitly converted to a `TINYINT`, but the integer literal `1000` cannot be.

SQL

Data Types

Other Numeric Literals

Non-integer numeric literals can be denoted with decimal notation, using the period character (` .`) to separate the integer part and the decimal part of the number. Either the integer part or the decimal part may be omitted: ```sql SELECT 1.5; -- 1.5 SELECT .50; -- 0.5 SELECT 2.; -- 2.0 ``` Non-integer numeric literals can also be denoted using [_E notation_](https://en.wikipedia.org/wiki/Scientific_notation#E_notation). In E notation, an integer or decimal literal is followed by and exponential part, which is denoted by `e` or `E`, followed by a literal integer indicating the exponent. The exponential part indicates that the preceding value should be multiplied by 10 raised to the power of the exponent: ```sql SELECT 1e2; -- 100 SELECT 6.02214e23; -- Avogadro's constant SELECT 1e-10; -- 1 ångström ```

SQL

Data Types

Underscores in Numeric Literals

DuckDB's SQL dialect allows using the underscore character `_` in numeric literals as an optional separator. The rules for using underscores are as follows: * Underscores are allowed in integer, decimal, hexadecimal and binary notation. * Underscores can not be the first or last character in a literal. * Underscores have to have an integer/numeric part on either side of them, i.e., there can not be multiple underscores in a row and not immediately before/after a decimal or exponent. Examples: ```sql SELECT 100_000_000; -- 100000000 SELECT '0xFF_FF'::INTEGER; -- 65535 SELECT 1_2.1_2E0_1; -- 121.2 SELECT '0b0_1_0_1'::INTEGER; -- 5 ```

SQL

Data Types

String Literals

String literals are delimited using single quotes (` '`, apostrophe) and result in `STRING_LITERAL` values. Note that double quotes (` "`) cannot be used as string delimiter character: instead, double quotes are used to delimit [quoted identifiers](#docs:sql:dialect:keywords_and_identifiers::identifiers). #### Implicit String Literal Concatenation {#docs:sql:data_types:literal_types::implicit-string-literal-concatenation} Consecutive single-quoted string literals separated only by whitespace that contains at least one newline are implicitly concatenated: ```sql SELECT 'Hello' ' ' 'World' AS greeting; ``` is equivalent to: ```sql SELECT 'Hello' || ' ' || 'World' AS greeting; ``` They both return the following result: | greeting | |-------------| | Hello World | Note that implicit concatenation only works if there is at least one newline between the literals. Using adjacent string literals separated by whitespace without a newline results in a syntax error: ```sql SELECT 'Hello' ' ' 'World' AS greeting; ``` ```console Parser Error: syntax error at or near "' '" LINE 1: SELECT 'Hello' ' ' 'World' AS greeting; ^ ``` Also note that implicit concatenation only works with single-quoted string literals, and does not work with other kinds of string values. #### Implicit String Conversion {#docs:sql:data_types:literal_types::implicit-string-conversion} `STRING_LITERAL` instances can be implicitly converted to _any_ other type. For example, we can compare string literals with dates: ```sql SELECT d > '1992-01-01' AS result FROM (VALUES (DATE '1992-01-01')) t(d); ``` | result | |:-------| | false | However, we cannot compare `VARCHAR` values with dates. ```sql SELECT d > '1992-01-01'::VARCHAR FROM (VALUES (DATE '1992-01-01')) t(d); ``` ```console Binder Error: Cannot compare values of type DATE and type VARCHAR - an explicit cast is required ``` #### Escape String Literals {#docs:sql:data_types:literal_types::escape-string-literals} To escape a single quote (apostrophe) character in a string literal, use `''`. For example, `SELECT '''' AS s` returns `'`. To include special characters such as newline, use `E` escape the string. Both the uppercase (` E'...'`) and lowercase variants (` e'...'`) work. ```sql SELECT E'Hello\nworld' AS msg; ``` Or: ```sql SELECT e'Hello\nworld' AS msg; ``` <!-- This output intentionally uses the duckbox formatter --> ```text ┌──────────────┐ │ msg │ │ varchar │ ├──────────────┤ │ Hello\nworld │ └──────────────┘ ``` The following backslash escape sequences are supported: | Escape sequence | Name | ASCII code | |:--|:--|--:| | `\b` | backspace | 8 | | `\f` | form feed | 12 | | `\n` | newline | 10 | | `\r` | carriage return | 13 | | `\t` | tab | 9 | #### Dollar-Quoted String Literals {#docs:sql:data_types:literal_types::dollar-quoted-string-literals} DuckDB supports dollar-quoted string literals, which are surrounded by double-dollar symbols (` $$`): ```sql SELECT $$Hello world$$ AS msg; ``` <!-- This output intentionally uses the duckbox formatter --> ```text ┌──────────────┐ │ msg │ │ varchar │ ├──────────────┤ │ Hello\nworld │ └──────────────┘ ``` ```sql SELECT $$The price is $9.95$$ AS msg; ``` | msg | |--------------------| | The price is $9.95 | [Implicit concatenation](#::implicit-string-literal-concatenation) only works for single-quoted string literals, not with dollar-quoted ones.

SQL

Data Types

Map Type

`MAP`s are similar to `STRUCT`s in that they are an ordered list of “entries” where a key maps to a value. However, `MAP`s do not need to have the same keys present for each row, and thus are suitable for other use cases. `MAP`s are useful when the schema is unknown beforehand or when the schema varies per row; their flexibility is a key differentiator. `MAP`s must have a single type for all keys, and a single type for all values. Keys and values can be any type, and the type of the keys does not need to match the type of the values (e.g., a `MAP` of `VARCHAR` to `INT` is valid). `MAP`s may not have duplicate keys. `MAP`s return an empty list if a key is not found rather than throwing an error as structs do. In contrast, `STRUCT`s must have string keys, but each key may have a value of a different type. See the [data types overview](#docs:sql:data_types:overview) for a comparison between nested data types. To construct a `MAP`, use the bracket syntax preceded by the `MAP` keyword.

SQL

Data Types

Creating Maps

A map with `VARCHAR` keys and `INTEGER` values. This returns `{key1=10, key2=20, key3=30}`: ```sql SELECT MAP {'key1': 10, 'key2': 20, 'key3': 30}; ``` Alternatively use the map_from_entries function. This returns `{key1=10, key2=20, key3=30}`: ```sql SELECT map_from_entries([('key1', 10), ('key2', 20), ('key3', 30)]); ``` A map can be also created using two lists: keys and values. This returns `{key1=10, key2=20, key3=30}`: ```sql SELECT MAP(['key1', 'key2', 'key3'], [10, 20, 30]); ``` A map can also use INTEGER keys and NUMERIC values. This returns `{1=42.001, 5=-32.100}`: ```sql SELECT MAP {1: 42.001, 5: -32.1}; ``` Keys and/or values can also be nested types. This returns `{[a, b]=[1.1, 2.2], [c, d]=[3.3, 4.4]}`: ```sql SELECT MAP {['a', 'b']: [1.1, 2.2], ['c', 'd']: [3.3, 4.4]}; ``` Create a table with a map column that has INTEGER keys and DOUBLE values: ```sql CREATE TABLE tbl (col MAP(INTEGER, DOUBLE)); ```

SQL

Data Types

Retrieving from Maps

`MAP`s use bracket notation for retrieving values. Selecting from a `MAP` returns a `LIST` rather than an individual value, with an empty `LIST` meaning that the key was not found. Use bracket notation to retrieve a list containing the value at a key's location. This returns `[5]`. Note that the expression in bracket notation must match the type of the map's key: ```sql SELECT MAP {'key1': 5, 'key2': 43}['key1']; ``` To retrieve the underlying value, use list selection syntax to grab the first element. This returns `5`: ```sql SELECT MAP {'key1': 5, 'key2': 43}['key1'][1]; ``` If the element is not in the map, an empty list will be returned. This returns `[]`. Note that the expression in bracket notation must match the type of the map's key else an error is returned: ```sql SELECT MAP {'key1': 5, 'key2': 43}['key3']; ``` The element_at function can also be used to retrieve a map value. This returns `[5]`: ```sql SELECT element_at(MAP {'key1': 5, 'key2': 43}, 'key1'); ```

SQL

Data Types

Comparison Operators

Nested types can be compared using all the [comparison operators](#docs:sql:expressions:comparison_operators). These comparisons can be used in [logical expressions](#docs:sql:expressions:logical_operators) for both `WHERE` and `HAVING` clauses, as well as for creating [Boolean values](#docs:sql:data_types:boolean). The ordering is defined positionally in the same way that words can be ordered in a dictionary. `NULL` values compare greater than all other values and are considered equal to each other. At the top level, `NULL` nested values obey standard SQL `NULL` comparison rules: comparing a `NULL` nested value to a non-`NULL` nested value produces a `NULL` result. Comparing nested value _members_, however, uses the internal nested value rules for `NULL`s, and a `NULL` nested value member will compare above a non-`NULL` nested value member.

SQL

Data Types

Functions

See [Map Functions](#docs:sql:functions:map).

SQL

Data Types

NULL Values

`NULL` values are special values that are used to represent missing data in SQL. Columns of any type can contain `NULL` values. Logically, a `NULL` value can be seen as “the value of this field is unknown”. A `NULL` value can be inserted to any field that does not have the `NOT NULL` qualifier: ```sql CREATE TABLE integers (i INTEGER); INSERT INTO integers VALUES (NULL); ``` `NULL` values have special semantics in many parts of the query as well as in many functions: > Any comparison with a `NULL` value returns `NULL`, including `NULL = NULL`. You can use `IS NOT DISTINCT FROM` to perform an equality comparison where `NULL` values compare equal to each other. Use `IS (NOT) NULL` to check if a value is `NULL`. ```sql SELECT NULL = NULL; ``` ```text NULL ``` ```sql SELECT NULL IS NOT DISTINCT FROM NULL; ``` ```text true ``` ```sql SELECT NULL IS NULL; ``` ```text true ```

SQL

Data Types

NULL and Functions

A function that has input argument as `NULL` **usually** returns `NULL`. ```sql SELECT cos(NULL); ``` ```text NULL ``` The `coalesce` function is an exception to this: it takes any number of arguments, and returns for each row the first argument that is not `NULL`. If all arguments are `NULL`, `coalesce` also returns `NULL`. ```sql SELECT coalesce(NULL, NULL, 1); ``` ```text 1 ``` ```sql SELECT coalesce(10, 20); ``` ```text 10 ``` ```sql SELECT coalesce(NULL, NULL); ``` ```text NULL ``` The `ifnull` function is a two-argument version of `coalesce`. ```sql SELECT ifnull(NULL, 'default_string'); ``` ```text default_string ``` ```sql SELECT ifnull(1, 'default_string'); ``` ```text 1 ```

SQL

Data Types

`NULL` and Conjunctions

`NULL` values have special semantics in `AND`/`OR` conjunctions. For the ternary logic truth tables, see the [Boolean Type documentation](#docs:sql:data_types:boolean).

SQL

Data Types

`NULL` and Aggregate Functions

`NULL` values are ignored in most aggregate functions. Aggregate functions that do not ignore `NULL` values include: `first`, `last`, `list`, and `array_agg`. To exclude `NULL` values from those aggregate functions, the [`FILTER` clause](#docs:sql:query_syntax:filter) can be used. ```sql CREATE TABLE integers (i INTEGER); INSERT INTO integers VALUES (1), (10), (NULL); ``` ```sql SELECT min(i) FROM integers; ``` ```text 1 ``` ```sql SELECT max(i) FROM integers; ``` ```text 10 ```

SQL

Data Types

Integer Types

The types `TINYINT`, `SMALLINT`, `INTEGER`, `BIGINT` and `HUGEINT` store whole numbers, that is, numbers without fractional components, of various ranges. Attempts to store values outside of the allowed range will result in an error. The types `UTINYINT`, `USMALLINT`, `UINTEGER`, `UBIGINT` and `UHUGEINT` store whole unsigned numbers. Attempts to store negative numbers or values outside of the allowed range will result in an error. | Name | Aliases | Min | Max | |:--|:--|----:|----:| | `TINYINT` | `INT1` | -128 | 127 | | `SMALLINT` | `INT2`, `INT16` `SHORT` | -32768 | 32767 | | `INTEGER` | `INT4`, `INT32`, `INT`, `SIGNED` | -2147483648 | 2147483647 | | `BIGINT` | `INT8`, `INT64` `LONG` | -9223372036854775808 | 9223372036854775807 | | `HUGEINT` | `INT128` | -170141183460469231731687303715884105728 | $2^{127}-1$ | | `UTINYINT` | - | 0 | 255 | | `USMALLINT` | -| 0 | 65535 | | `UINTEGER` | - | 0 | 4294967295 | | `UBIGINT` | - | 0 | 18446744073709551615 | | `UHUGEINT` | - | 0 | 340282366920938463463374607431768211455 | The type integer is the common choice, as it offers the best balance between range, storage size, and performance. The `SMALLINT` type is generally only used if disk space is at a premium. The `BIGINT` and `HUGEINT` types are designed to be used when the range of the integer type is insufficient.

SQL

Data Types

Fixed-Point Decimals

The data type `DECIMAL(WIDTH, SCALE)` (also available under the alias `NUMERIC(WIDTH, SCALE)`) represents an exact fixed-point decimal value. When creating a value of type `DECIMAL`, the `WIDTH` and `SCALE` can be specified to define which size of decimal values can be held in the field. The `WIDTH` field determines how many digits can be held, and the `scale` determines the amount of digits after the decimal point. For example, the type `DECIMAL(3, 2)` can fit the value `1.23`, but cannot fit the value `12.3` or the value `1.234`. The default `WIDTH` and `SCALE` is `DECIMAL(18, 3)`, if none are specified. Internally, decimals are represented as integers depending on their specified `WIDTH`. <div class="narrow_table"></div> | Width | Internal | Size (bytes) | |:---|:---|---:| | 1-4 | `INT16` | 2 | | 5-9 | `INT32` | 4 | | 10-18 | `INT64` | 8 | | 19-38 | `INT128` | 16 | Performance can be impacted by using too large decimals when not required. In particular decimal values with a width above 19 are slow, as arithmetic involving the `INT128` type is much more expensive than operations involving the `INT32` or `INT64` types. It is therefore recommended to stick with a `WIDTH` of `18` or below, unless there is a good reason for why this is insufficient.

SQL

Data Types

Floating-Point Types

The data types `FLOAT` and `DOUBLE` precision are variable-precision numeric types. In practice, these types are usually implementations of IEEE Standard 754 for Binary Floating-Point Arithmetic (single and double precision, respectively), to the extent that the underlying processor, operating system, and compiler support it. <div class="narrow_table"></div> | Name | Aliases | Description | |:--|:--|:--------| | `FLOAT` | `FLOAT4`, `REAL` | single precision floating-point number (4 bytes) | | `DOUBLE` | `FLOAT8` | double precision floating-point number (8 bytes) | Like for fixed-point data types, conversion from literals or casts from other datatypes to floating-point types stores inputs that cannot be represented exactly as approximations. However, it can be harder to predict what inputs are affected by this. For example, it is not surprising that `1.3::DECIMAL(1, 0) - 0.7::DECIMAL(1, 0) != 0.6::DECIMAL(1, 0)` but it may he surprising that `1.3::FLOAT - 0.7::FLOAT != 0.6::FLOAT`. Additionally, whereas multiplication, addition, and subtraction of fixed-point decimal data types is exact, these operations are only approximate on floating-point binary data types. For more complex mathematical operations, however, floating-point arithmetic is used internally and more precise results can be obtained if intermediate steps are _not_ cast to fixed point formats of the same width as in- and outputs. For example, `(10::FLOAT / 3::FLOAT)::FLOAT * 3 = 10` whereas `(10::DECIMAL(18, 3) / 3::DECIMAL(18, 3))::DECIMAL(18, 3) * 3 = 9.999`. In general, we advise that: * If you require exact storage of numbers with a known number of decimal digits and require exact additions, subtractions, and multiplications (such as for monetary amounts), use the [`DECIMAL` data type](#::fixed-point-decimals) or its `NUMERIC` alias instead. * If you want to do fast or complicated calculations, the floating-point data types may be more appropriate. However, if you use the results for anything important, you should evaluate your implementation carefully for corner cases (ranges, infinities, underflows, invalid operations) that may be handled differently from what you expect and you should familiarize yourself with common floating-point pitfalls. The article [“What Every Computer Scientist Should Know About Floating-Point Arithmetic” by David Goldberg](https://docs.oracle.com/cd/E19957-01/806-3568/ncg_goldberg.html) and [the floating point series on Bruce Dawson's blog](https://randomascii.wordpress.com/2017/06/19/sometimes-floating-point-math-is-perfect/) provide excellent starting points. On most platforms, the `FLOAT` type has a range of at least 1E-37 to 1E+37 with a precision of at least 6 decimal digits. The `DOUBLE` type typically has a range of around 1E-307 to 1E+308 with a precision of at least 15 digits. Positive numbers outside of these ranges (and negative numbers ourside the mirrored ranges) may cause errors on some platforms but will usually be converted to zero or infinity, respectively. In addition to ordinary numeric values, the floating-point types have several special values representing IEEE 754 special values: * `Infinity`: infinity * `-Infinity`: negative infinity * `NaN`: not a number > On a machine whose floating-point arithmetic does not follow IEEE 754, these values will probably not work as expected. When writing these values as constants in a SQL command, you must put quotes around them, for example: ```sql UPDATE table SET x = '-Infinity'; ``` On input, these strings are recognized in a case-insensitive manner.

SQL

Data Types

Universally Unique Identifiers (` UUID`s)

DuckDB supports universally unique identifiers (UUIDs) through the `UUID` type. These use 128 bits and are represented internally as `HUGEINT` values. When printed, they are shown with lowercase hexadecimal characters, separated by dashes as follows: `⟨8 characters⟩-⟨4 characters⟩-⟨4 characters⟩-⟨4 characters⟩-⟨12 characters⟩` (using 36 characters in total including the dashes). For example, `4ac7a9e9-607c-4c8a-84f3-843f0191e3fd` is a valid UUID. To generate a new UUID, use the [`uuid()` utility function](#docs:sql:functions:utility::utility-functions).

SQL

Data Types

Functions

See [Numeric Functions and Operators](#docs:sql:functions:numeric).

SQL

Data Types

Struct Data Type

Conceptually, a `STRUCT` column contains an ordered list of columns called “entries”. The entries are referenced by name using strings. This document refers to those entry names as keys. Each row in the `STRUCT` column must have the same keys. The names of the struct entries are part of the *schema*. Each row in a `STRUCT` column must have the same layout. The names of the struct entries are case-insensitive. `STRUCT`s are typically used to nest multiple columns into a single column, and the nested column can be of any type, including other `STRUCT`s and `LIST`s. `STRUCT`s are similar to PostgreSQL's `ROW` type. The key difference is that DuckDB `STRUCT`s require the same keys in each row of a `STRUCT` column. This allows DuckDB to provide significantly improved performance by fully utilizing its vectorized execution engine, and also enforces type consistency for improved correctness. DuckDB includes a `row` function as a special way to produce a `STRUCT`, but does not have a `ROW` data type. See an example below and the [`STRUCT` functions documentation](#docs:sql:functions:struct) for details. `STRUCT`s have a fixed schema. It is not possible to change the schema of a `STRUCT` using `UPDATE` operations. See the [data types overview](#docs:sql:data_types:overview) for a comparison between nested data types. #### Creating Structs {#docs:sql:data_types:struct::creating-structs} Structs can be created using the [`struct_pack(name := expr, ...)`](#docs:sql:functions:struct) function, the equivalent array notation `{'name': expr, ...}`, using a row variable, or using the `row` function. Create a struct using the `struct_pack` function. Note the lack of single quotes around the keys and the use of the `:=` operator: ```sql SELECT struct_pack(key1 := 'value1', key2 := 42) AS s; ``` Create a struct using the array notation: ```sql SELECT {'key1': 'value1', 'key2': 42} AS s; ``` Create a struct using a row variable: ```sql SELECT d AS s FROM (SELECT 'value1' AS key1, 42 AS key2) d; ``` Create a struct of integers: ```sql SELECT {'x': 1, 'y': 2, 'z': 3} AS s; ``` Create a struct of strings with a `NULL` value: ```sql SELECT {'yes': 'duck', 'maybe': 'goose', 'huh': NULL, 'no': 'heron'} AS s; ``` Create a struct with a different type for each key: ```sql SELECT {'key1': 'string', 'key2': 1, 'key3': 12.345} AS s; ``` Create a struct of structs with `NULL` values: ```sql SELECT { 'birds': {'yes': 'duck', 'maybe': 'goose', 'huh': NULL, 'no': 'heron'}, 'aliens': NULL, 'amphibians': {'yes': 'frog', 'maybe': 'salamander', 'huh': 'dragon', 'no': 'toad'} } AS s; ``` #### Adding Field(s)/Value(s) to Structs {#docs:sql:data_types:struct::adding-fieldsvalues-to-structs} Add to a struct of integers: ```sql SELECT struct_insert({'a': 1, 'b': 2, 'c': 3}, d := 4) AS s; ``` #### Retrieving from Structs {#docs:sql:data_types:struct::retrieving-from-structs} Retrieving a value from a struct can be accomplished using dot notation, bracket notation, or through [struct functions](#docs:sql:functions:struct) like `struct_extract`. Use dot notation to retrieve the value at a key's location. In the following query, the subquery generates a struct column `a`, which we then query with `a.x`. ```sql SELECT a.x FROM (SELECT {'x': 1, 'y': 2, 'z': 3} AS a); ``` If a key contains a space, simply wrap it in double quotes (` "`). ```sql SELECT a."x space" FROM (SELECT {'x space': 1, 'y': 2, 'z': 3} AS a); ``` Bracket notation may also be used. Note that this uses single quotes (` '`) since the goal is to specify a certain string key and only constant expressions may be used inside the brackets (no expressions): ```sql SELECT a['x space'] FROM (SELECT {'x space': 1, 'y': 2, 'z': 3} AS a); ``` The struct_extract function is also equivalent. This returns 1: ```sql SELECT struct_extract({'x space': 1, 'y': 2, 'z': 3}, 'x space'); ```

SQL

Data Types

Struct Data Type

`STRUCT.*`

Rather than retrieving a single key from a struct, star notation (` *`) can be used to retrieve all keys from a struct as separate columns. This is particularly useful when a prior operation creates a struct of unknown shape, or if a query must handle any potential struct keys. All keys within a struct can be returned as separate columns using `*`: ```sql SELECT a.* FROM (SELECT {'x': 1, 'y': 2, 'z': 3} AS a); ``` <div class="narrow_table"></div> | x | y | z | |:---|:---|:---| | 1 | 2 | 3 | #### Dot Notation Order of Operations {#docs:sql:data_types:struct::dot-notation-order-of-operations} Referring to structs with dot notation can be ambiguous with referring to schemas and tables. In general, DuckDB looks for columns first, then for struct keys within columns. DuckDB resolves references in these orders, using the first match to occur:

SQL

Data Types

Struct Data Type

No Dots

```sql SELECT part1 FROM tbl; ``` 1. `part1` is a column

SQL

Data Types

Struct Data Type

One Dot

```sql SELECT part1.part2 FROM tbl; ``` 1. `part1` is a table, `part2` is a column 2. `part1` is a column, `part2` is a property of that column

SQL

Data Types

Struct Data Type

Two (or More) Dots

```sql SELECT part1.part2.part3 FROM tbl; ``` 1. `part1` is a schema, `part2` is a table, `part3` is a column 2. `part1` is a table, `part2` is a column, `part3` is a property of that column 3. `part1` is a column, `part2` is a property of that column, `part3` is a property of that column Any extra parts (e.g., `.part4.part5`, etc.) are always treated as properties #### Creating Structs with the `row` Function {#docs:sql:data_types:struct::creating-structs-with-the-row-function} The `row` function can be used to automatically convert multiple columns to a single struct column. When using `row` the keys will be empty strings allowing for easy insertion into a table with a struct column. Columns, however, cannot be initialized with the `row` function, and must be explicitly named. For example, inserting values into a struct column using the `row` function: ```sql CREATE TABLE t1 (s STRUCT(v VARCHAR, i INTEGER)); INSERT INTO t1 VALUES (row('a', 42)); SELECT * FROM t1; ``` The table will contain a single entry: ```sql {'v': a, 'i': 42} ``` The following produces the same result as above: ```sql CREATE TABLE t1 AS ( SELECT row('a', 42)::STRUCT(v VARCHAR, i INTEGER) ); ``` Initializing a struct column with the `row` function will fail: ```sql CREATE TABLE t2 AS SELECT row('a'); ``` ```console Invalid Input Error: A table cannot be created from an unnamed struct ``` When casting structs, the names of fields have to match. Therefore, the following query will fail: ```sql SELECT a::STRUCT(y INTEGER) AS b FROM (SELECT {'x': 42} AS a); ``` ```console Mismatch Type Error: Type STRUCT(x INTEGER) does not match with STRUCT(y INTEGER). Cannot cast STRUCTs - element "x" in source struct was not found in target struct ``` A workaround for this is to use [`struct_pack`](#::creating-structs) instead: ```sql SELECT struct_pack(y := a.x) AS b FROM (SELECT {'x': 42} AS a); ``` The `row` function can be used to return unnamed structs. For example: ```sql SELECT row(x, x + 1, y) FROM (SELECT 1 AS x, 'a' AS y) AS s; ``` This produces `(1, 2, a)`. If using multiple expressions when creating a struct, the `row` function is optional. The following query returns the same result as the previous one: ```sql SELECT (x, x + 1, y) AS s FROM (SELECT 1 AS x, 'a' AS y); ```

SQL

Data Types

Comparison and Ordering

The `STRUCT` type can be compared using all the [comparison operators](#docs:sql:expressions:comparison_operators). These comparisons can be used in [logical expressions](#docs:sql:expressions:logical_operators) such as `WHERE` and `HAVING` clauses, and return [`BOOLEAN` values](#docs:sql:data_types:boolean). For comparisons, the keys of a `STRUCT` have a fixed positional order, from left to right. Comparisons behave the same as row comparisons, therefore, matching keys must be at identical positions. Specifically, for any `STRUCT` comparison, the following rules apply: * **Equality.** `s1` and `s2` are equal, if all respective values are equal. * **Less Than**. For the first index `i` where `s1.value[i] != s2.value[i]`: If `s1.value[i] < s2.value[i]`, `s1` is less than `s2`. `NULL` values are compared following PostgreSQL's semantics. Lower nesting levels are used for tie-breaking. Here are some queries returning `true` for the comparison. ```sql SELECT {'k1': 2, 'k2': 3} < {'k1': 2, 'k2': 4} AS result; ``` ```sql SELECT {'k1': 'hello'} < {'k1': 'world'} AS result; ``` These queries return `false`. ```sql SELECT {'k2': 4, 'k1': 3} < {'k2': 2, 'k1': 4} AS result; ``` ```sql SELECT {'k1': [4, 3]} < {'k1': [3, 6, 7]} AS result; ``` These queries return `NULL`. ```sql SELECT {'k1': 2, 'k2': 3} < {'k1': 2, 'k2': NULL} AS result; ``` This query returns a `Binder Error` because the keys do not match positionally. ```sql SELECT {'k1': 2, 'k2': 3} < {'k2': 2, 'k1': 4} AS result; ``` ```console Binder Error: Cannot compare values of type STRUCT(k1 INTEGER, k2 INTEGER) and type STRUCT(k2 INTEGER, k1 INTEGER) - an explicit cast is required ```

SQL

Data Types

Functions

See [Struct Functions](#docs:sql:functions:struct).

SQL

Data Types

Text Types

In DuckDB, strings can be stored in the `VARCHAR` field. The field allows storage of Unicode characters. Internally, the data is encoded as UTF-8. <div class="narrow_table"></div> | Name | Aliases | Description | |:---|:---|:---| | `VARCHAR` | `CHAR`, `BPCHAR`, `STRING`, `TEXT` | Variable-length character string. | | `VARCHAR(n)` | `CHAR(n)`, `BPCHAR(n)`, `STRING(n)`, `TEXT(n)` | Variable-length character string. The maximum length `n` has no effect and is only provided for compatibility. |

SQL

Data Types

Specifying a Length Limit

Specifying the length for the `VARCHAR`, `STRING`, and `TEXT` types is not required and has no effect on the system. Specifying the length will not improve performance or reduce storage space of the strings in the database. These variants variant is supported for compatibility reasons with other systems that do require a length to be specified for strings. If you wish to restrict the number of characters in a `VARCHAR` column for data integrity reasons the `CHECK` constraint should be used, for example: ```sql CREATE TABLE strings ( val VARCHAR CHECK (length(val) <= 10) -- val has a maximum length of 10 ); ``` The `VARCHAR` field allows storage of Unicode characters. Internally, the data is encoded as UTF-8.

SQL

Data Types

Text Type Values

Values of the text type are character strings, also known as string values or simply strings. At runtime, string values are constructed in one of the following ways: * referencing columns whose declared or implied type is the text data type * [string literals](#docs:sql:data_types:literal_types::string-literals) * [casting](#docs:sql:expressions:cast::explicit-casting) expressions to a text type * applying a [string operator](#docs:sql:functions:char::text-functions-and-operators), or invoking a function that returns a text type value

SQL

Data Types

Strings with Special Characters

To use special characters in string, use [escape string literals](#docs:sql:data_types:literal_types::escape-string-literals) or [dollar-quoted string literals](#docs:sql:data_types:literal_types::dollar-quoted-string-literals). Alternatively, you can use concatenation and the [`chr` character function](#docs:sql:functions:char): ```sql SELECT 'Hello' || chr(10) || 'world' AS msg; ``` <!-- This output intentionally uses the duckbox formatter --> ```text ┌──────────────┐ │ msg │ │ varchar │ ├──────────────┤ │ Hello\nworld │ └──────────────┘ ```

SQL

Data Types

Functions

See [Text Functions](#docs:sql:functions:char) and [Pattern Matching](#docs:sql:functions:pattern_matching).

SQL

Data Types

Time Types

The `TIME` and `TIMETZ` types specify the hour, minute, second, microsecond of a day. <div class="narrow_table"></div> | Name | Aliases | Description | | :------- | :----------------------- | :------------------------------ | | `TIME` | `TIME WITHOUT TIME ZONE` | time of day (ignores time zone) | | `TIMETZ` | `TIME WITH TIME ZONE` | time of day (uses time zone) | Instances can be created using the type names as a keyword, where the data must be formatted according to the ISO 8601 format (` hh:mm:ss[.zzzzzz][+-TT[:tt]]`). ```sql SELECT TIME '1992-09-20 11:30:00.123456'; ``` ```text 11:30:00.123456 ``` ```sql SELECT TIMETZ '1992-09-20 11:30:00.123456'; ``` ```text 11:30:00.123456+00 ``` ```sql SELECT TIMETZ '1992-09-20 11:30:00.123456-02:00'; ``` ```text 13:30:00.123456+00 ``` ```sql SELECT TIMETZ '1992-09-20 11:30:00.123456+05:30'; ``` ```text 06:00:00.123456+00 ``` > **Warning. ** The `TIME` type should only be used in rare cases, where the date part of the timestamp can be disregarded. > Most applications should use the [`TIMESTAMP` types](#docs:sql:data_types:timestamp) to represent their timestamps.

SQL

Data Types

Timestamp Types

Timestamps represent points in absolute time, usually called *instants*. DuckDB represents instants as the number of microseconds (µs) since `1970-01-01 00:00:00+00`.

SQL

Data Types

Timestamp Types

| Name | Aliases | Description | |:---|:---|:---| | `TIMESTAMP_NS` | | timestamp with nanosecond precision (ignores time zone) | | `TIMESTAMP` | `DATETIME` | timestamp with microsecond precision (ignores time zone) | | `TIMESTAMP_MS` | | timestamp with millisecond precision (ignores time zone) | | `TIMESTAMP_S` | | timestamp with second precision (ignores time zone) | | `TIMESTAMPTZ` | `TIMESTAMP WITH TIME ZONE` | timestamp (uses time zone) | A timestamp specifies a combination of [`DATE`](#docs:sql:data_types:date) (year, month, day) and a [`TIME`](#docs:sql:data_types:time) (hour, minute, second, microsecond). Timestamps can be created using the `TIMESTAMP` keyword, where the data must be formatted according to the ISO 8601 format (` YYYY-MM-DD hh:mm:ss[.zzzzzz][+-TT[:tt]]`). Decimal places beyond the targeted sub-second precision are ignored. > **Warning. ** When defining timestamps using a `TIMESTAMP_NS` literal, the decimal places beyond _microseconds_ are ignored. Note that the `TIMESTAMP_NS` type is able to hold nanoseconds when created e.g., via the ingestion of Parquet files. ```sql SELECT TIMESTAMP_NS '1992-09-20 11:30:00.123456789'; ``` ```text 1992-09-20 11:30:00.123456 ``` ```sql SELECT TIMESTAMP '1992-09-20 11:30:00.123456789'; ``` ```text 1992-09-20 11:30:00.123456 ``` ```sql SELECT DATETIME '1992-09-20 11:30:00.123456789'; ``` ```text 1992-09-20 11:30:00.123456 ``` ```sql SELECT TIMESTAMP_MS '1992-09-20 11:30:00.123456789'; ``` ```text 1992-09-20 11:30:00.123 ``` ```sql SELECT TIMESTAMP_S '1992-09-20 11:30:00.123456789'; ``` ```text 1992-09-20 11:30:00 ``` ```sql SELECT TIMESTAMPTZ '1992-09-20 11:30:00.123456789'; ``` ```text 1992-09-20 11:30:00.123456+00 ``` ```sql SELECT TIMESTAMP WITH TIME ZONE '1992-09-20 11:30:00.123456789'; ``` ```text 1992-09-20 11:30:00.123456+00 ```

SQL

Data Types

Special Values

There are also three special date values that can be used on input: <div class="narrow_table"></div> | Input string | Valid types | Description | |:-------------|:---------------------------|:-----------------------------------------------| | `epoch` | `TIMESTAMP`, `TIMESTAMPTZ` | 1970-01-01 00:00:00+00 (Unix system time zero) | | `infinity` | `TIMESTAMP`, `TIMESTAMPTZ` | later than all other time stamps | | `-infinity` | `TIMESTAMP`, `TIMESTAMPTZ` | earlier than all other time stamps | The values `infinity` and `-infinity` are specially represented inside the system and will be displayed unchanged; but `epoch` is simply a notational shorthand that will be converted to the time stamp value when read. ```sql SELECT '-infinity'::TIMESTAMP, 'epoch'::TIMESTAMP, 'infinity'::TIMESTAMP; ``` <div class="narrow_table"></div> | Negative | Epoch | Positive | |:----------|:--------------------|:---------| | -infinity | 1970-01-01 00:00:00 | infinity |

SQL

Data Types

Functions

See [Timestamp Functions](#docs:sql:functions:timestamp).

SQL

Data Types

Time Zones

The `TIMESTAMPTZ` type can be binned into calendar and clock bins using a suitable extension. The built-in [ICU extension](#docs:extensions:icu) implements all the binning and arithmetic functions using the [International Components for Unicode](https://icu.unicode.org) time zone and calendar functions. To set the time zone to use, first load the ICU extension. The ICU extension comes pre-bundled with several DuckDB clients (including Python, R, JDBC, and ODBC), so this step can be skipped in those cases. In other cases you might first need to install and load the ICU extension. ```sql INSTALL icu; LOAD icu; ``` Next, use the `SET TimeZone` command: ```sql SET TimeZone = 'America/Los_Angeles'; ``` Time binning operations for `TIMESTAMPTZ` will then be implemented using the given time zone. A list of available time zones can be pulled from the `pg_timezone_names()` table function: ```sql SELECT name, abbrev, utc_offset FROM pg_timezone_names() ORDER BY name; ``` You can also find a reference table of [available time zones](#docs:sql:data_types:timezones).

SQL

Data Types

Calendars

The [ICU extension](#docs:extensions:icu) also supports non-Gregorian calendars using the `SET Calendar` command. Note that the `INSTALL` and `LOAD` steps are only required if the DuckDB client does not bundle the ICU extension. ```sql INSTALL icu; LOAD icu; SET Calendar = 'japanese'; ``` Time binning operations for `TIMESTAMPTZ` will then be implemented using the given calendar. In this example, the `era` part will now report the Japanese imperial era number. A list of available calendars can be pulled from the `icu_calendar_names()` table function: ```sql SELECT name FROM icu_calendar_names() ORDER BY 1; ```

SQL

Data Types

Settings

The current value of the `TimeZone` and `Calendar` settings are determined by ICU when it starts up. They can be queried from in the `duckdb_settings()` table function: ```sql SELECT * FROM duckdb_settings() WHERE name = 'TimeZone'; ``` | name | value | description | input_type | |----------|------------------|-----------------------|------------| | TimeZone | Europe/Amsterdam | The current time zone | VARCHAR | ```sql SELECT * FROM duckdb_settings() WHERE name = 'Calendar'; ``` | name | value | description | input_type | |----------|-----------|----------------------|------------| | Calendar | gregorian | The current calendar | VARCHAR |

SQL

Data Types

Time Zone Reference List

An up-to-date version of this list can be pulled from the `pg_timezone_names()` table function: ```sql SELECT name, abbrev FROM pg_timezone_names() ORDER BY name; ``` <div class="narrow_table"></div> | name | abbrev | |----------------------------------|----------------------------------| | ACT | ACT | | AET | AET | | AGT | AGT | | ART | ART | | AST | AST | | Africa/Abidjan | Iceland | | Africa/Accra | Iceland | | Africa/Addis_Ababa | EAT | | Africa/Algiers | Africa/Algiers | | Africa/Asmara | EAT | | Africa/Asmera | EAT | | Africa/Bamako | Iceland | | Africa/Bangui | Africa/Bangui | | Africa/Banjul | Iceland | | Africa/Bissau | Africa/Bissau | | Africa/Blantyre | CAT | | Africa/Brazzaville | Africa/Brazzaville | | Africa/Bujumbura | CAT | | Africa/Cairo | ART | | Africa/Casablanca | Africa/Casablanca | | Africa/Ceuta | Africa/Ceuta | | Africa/Conakry | Iceland | | Africa/Dakar | Iceland | | Africa/Dar_es_Salaam | EAT | | Africa/Djibouti | EAT | | Africa/Douala | Africa/Douala | | Africa/El_Aaiun | Africa/El_Aaiun | | Africa/Freetown | Iceland | | Africa/Gaborone | CAT | | Africa/Harare | CAT | | Africa/Johannesburg | Africa/Johannesburg | | Africa/Juba | Africa/Juba | | Africa/Kampala | EAT | | Africa/Khartoum | Africa/Khartoum | | Africa/Kigali | CAT | | Africa/Kinshasa | Africa/Kinshasa | | Africa/Lagos | Africa/Lagos | | Africa/Libreville | Africa/Libreville | | Africa/Lome | Iceland | | Africa/Luanda | Africa/Luanda | | Africa/Lubumbashi | CAT | | Africa/Lusaka | CAT | | Africa/Malabo | Africa/Malabo | | Africa/Maputo | CAT | | Africa/Maseru | Africa/Maseru | | Africa/Mbabane | Africa/Mbabane | | Africa/Mogadishu | EAT | | Africa/Monrovia | Africa/Monrovia | | Africa/Nairobi | EAT | | Africa/Ndjamena | Africa/Ndjamena | | Africa/Niamey | Africa/Niamey | | Africa/Nouakchott | Iceland | | Africa/Ouagadougou | Iceland | | Africa/Porto-Novo | Africa/Porto-Novo | | Africa/Sao_Tome | Africa/Sao_Tome | | Africa/Timbuktu | Iceland | | Africa/Tripoli | Libya | | Africa/Tunis | Africa/Tunis | | Africa/Windhoek | Africa/Windhoek | | America/Adak | America/Adak | | America/Anchorage | AST | | America/Anguilla | PRT | | America/Antigua | PRT | | America/Araguaina | America/Araguaina | | America/Argentina/Buenos_Aires | AGT | | America/Argentina/Catamarca | America/Argentina/Catamarca | | America/Argentina/ComodRivadavia | America/Argentina/ComodRivadavia | | America/Argentina/Cordoba | America/Argentina/Cordoba | | America/Argentina/Jujuy | America/Argentina/Jujuy | | America/Argentina/La_Rioja | America/Argentina/La_Rioja | | America/Argentina/Mendoza | America/Argentina/Mendoza | | America/Argentina/Rio_Gallegos | America/Argentina/Rio_Gallegos | | America/Argentina/Salta | America/Argentina/Salta | | America/Argentina/San_Juan | America/Argentina/San_Juan | | America/Argentina/San_Luis | America/Argentina/San_Luis | | America/Argentina/Tucuman | America/Argentina/Tucuman | | America/Argentina/Ushuaia | America/Argentina/Ushuaia | | America/Aruba | PRT | | America/Asuncion | America/Asuncion | | America/Atikokan | America/Atikokan | | America/Atka | America/Atka | | America/Bahia | America/Bahia | | America/Bahia_Banderas | America/Bahia_Banderas | | America/Barbados | America/Barbados | | America/Belem | America/Belem | | America/Belize | America/Belize | | America/Blanc-Sablon | PRT | | America/Boa_Vista | America/Boa_Vista | | America/Bogota | America/Bogota | | America/Boise | America/Boise | | America/Buenos_Aires | AGT | | America/Cambridge_Bay | America/Cambridge_Bay | | America/Campo_Grande | America/Campo_Grande | | America/Cancun | America/Cancun | | America/Caracas | America/Caracas | | America/Catamarca | America/Catamarca | | America/Cayenne | America/Cayenne | | America/Cayman | America/Cayman | | America/Chicago | CST | | America/Chihuahua | America/Chihuahua | | America/Ciudad_Juarez | America/Ciudad_Juarez | | America/Coral_Harbour | America/Coral_Harbour | | America/Cordoba | America/Cordoba | | America/Costa_Rica | America/Costa_Rica | | America/Creston | PNT | | America/Cuiaba | America/Cuiaba | | America/Curacao | PRT | | America/Danmarkshavn | America/Danmarkshavn | | America/Dawson | America/Dawson | | America/Dawson_Creek | America/Dawson_Creek | | America/Denver | Navajo | | America/Detroit | America/Detroit | | America/Dominica | PRT | | America/Edmonton | America/Edmonton | | America/Eirunepe | America/Eirunepe | | America/El_Salvador | America/El_Salvador | | America/Ensenada | America/Ensenada | | America/Fort_Nelson | America/Fort_Nelson | | America/Fort_Wayne | IET | | America/Fortaleza | America/Fortaleza | | America/Glace_Bay | America/Glace_Bay | | America/Godthab | America/Godthab | | America/Goose_Bay | America/Goose_Bay | | America/Grand_Turk | America/Grand_Turk | | America/Grenada | PRT | | America/Guadeloupe | PRT | | America/Guatemala | America/Guatemala | | America/Guayaquil | America/Guayaquil | | America/Guyana | America/Guyana | | America/Halifax | America/Halifax | | America/Havana | Cuba | | America/Hermosillo | America/Hermosillo | | America/Indiana/Indianapolis | IET | | America/Indiana/Knox | America/Indiana/Knox | | America/Indiana/Marengo | America/Indiana/Marengo | | America/Indiana/Petersburg | America/Indiana/Petersburg | | America/Indiana/Tell_City | America/Indiana/Tell_City | | America/Indiana/Vevay | America/Indiana/Vevay | | America/Indiana/Vincennes | America/Indiana/Vincennes | | America/Indiana/Winamac | America/Indiana/Winamac | | America/Indianapolis | IET | | America/Inuvik | America/Inuvik | | America/Iqaluit | America/Iqaluit | | America/Jamaica | Jamaica | | America/Jujuy | America/Jujuy | | America/Juneau | America/Juneau | | America/Kentucky/Louisville | America/Kentucky/Louisville | | America/Kentucky/Monticello | America/Kentucky/Monticello | | America/Knox_IN | America/Knox_IN | | America/Kralendijk | PRT | | America/La_Paz | America/La_Paz | | America/Lima | America/Lima | | America/Los_Angeles | PST | | America/Louisville | America/Louisville | | America/Lower_Princes | PRT | | America/Maceio | America/Maceio | | America/Managua | America/Managua | | America/Manaus | America/Manaus | | America/Marigot | PRT | | America/Martinique | America/Martinique | | America/Matamoros | America/Matamoros | | America/Mazatlan | America/Mazatlan | | America/Mendoza | America/Mendoza | | America/Menominee | America/Menominee | | America/Merida | America/Merida | | America/Metlakatla | America/Metlakatla | | America/Mexico_City | America/Mexico_City | | America/Miquelon | America/Miquelon | | America/Moncton | America/Moncton | | America/Monterrey | America/Monterrey | | America/Montevideo | America/Montevideo | | America/Montreal | America/Montreal | | America/Montserrat | PRT | | America/Nassau | America/Nassau | | America/New_York | America/New_York | | America/Nipigon | America/Nipigon | | America/Nome | America/Nome | | America/Noronha | America/Noronha | | America/North_Dakota/Beulah | America/North_Dakota/Beulah | | America/North_Dakota/Center | America/North_Dakota/Center | | America/North_Dakota/New_Salem | America/North_Dakota/New_Salem | | America/Nuuk | America/Nuuk | | America/Ojinaga | America/Ojinaga | | America/Panama | America/Panama | | America/Pangnirtung | America/Pangnirtung | | America/Paramaribo | America/Paramaribo | | America/Phoenix | PNT | | America/Port-au-Prince | America/Port-au-Prince | | America/Port_of_Spain | PRT | | America/Porto_Acre | America/Porto_Acre | | America/Porto_Velho | America/Porto_Velho | | America/Puerto_Rico | PRT | | America/Punta_Arenas | America/Punta_Arenas | | America/Rainy_River | America/Rainy_River | | America/Rankin_Inlet | America/Rankin_Inlet | | America/Recife | America/Recife | | America/Regina | America/Regina | | America/Resolute | America/Resolute | | America/Rio_Branco | America/Rio_Branco | | America/Rosario | America/Rosario | | America/Santa_Isabel | America/Santa_Isabel | | America/Santarem | America/Santarem | | America/Santiago | America/Santiago | | America/Santo_Domingo | America/Santo_Domingo | | America/Sao_Paulo | BET | | America/Scoresbysund | America/Scoresbysund | | America/Shiprock | Navajo | | America/Sitka | America/Sitka | | America/St_Barthelemy | PRT | | America/St_Johns | CNT | | America/St_Kitts | PRT | | America/St_Lucia | PRT | | America/St_Thomas | PRT | | America/St_Vincent | PRT | | America/Swift_Current | America/Swift_Current | | America/Tegucigalpa | America/Tegucigalpa | | America/Thule | America/Thule | | America/Thunder_Bay | America/Thunder_Bay | | America/Tijuana | America/Tijuana | | America/Toronto | America/Toronto | | America/Tortola | PRT | | America/Vancouver | America/Vancouver | | America/Virgin | PRT | | America/Whitehorse | America/Whitehorse | | America/Winnipeg | America/Winnipeg | | America/Yakutat | America/Yakutat | | America/Yellowknife | America/Yellowknife | | Antarctica/Casey | Antarctica/Casey | | Antarctica/Davis | Antarctica/Davis | | Antarctica/DumontDUrville | Antarctica/DumontDUrville | | Antarctica/Macquarie | Antarctica/Macquarie | | Antarctica/Mawson | Antarctica/Mawson | | Antarctica/McMurdo | NZ | | Antarctica/Palmer | Antarctica/Palmer | | Antarctica/Rothera | Antarctica/Rothera | | Antarctica/South_Pole | NZ | | Antarctica/Syowa | Antarctica/Syowa | | Antarctica/Troll | Antarctica/Troll | | Antarctica/Vostok | Antarctica/Vostok | | Arctic/Longyearbyen | Arctic/Longyearbyen | | Asia/Aden | Asia/Aden | | Asia/Almaty | Asia/Almaty | | Asia/Amman | Asia/Amman | | Asia/Anadyr | Asia/Anadyr | | Asia/Aqtau | Asia/Aqtau | | Asia/Aqtobe | Asia/Aqtobe | | Asia/Ashgabat | Asia/Ashgabat | | Asia/Ashkhabad | Asia/Ashkhabad | | Asia/Atyrau | Asia/Atyrau | | Asia/Baghdad | Asia/Baghdad | | Asia/Bahrain | Asia/Bahrain | | Asia/Baku | Asia/Baku | | Asia/Bangkok | Asia/Bangkok | | Asia/Barnaul | Asia/Barnaul | | Asia/Beirut | Asia/Beirut | | Asia/Bishkek | Asia/Bishkek | | Asia/Brunei | Asia/Brunei | | Asia/Calcutta | IST | | Asia/Chita | Asia/Chita | | Asia/Choibalsan | Asia/Choibalsan | | Asia/Chongqing | CTT | | Asia/Chungking | CTT | | Asia/Colombo | Asia/Colombo | | Asia/Dacca | BST | | Asia/Damascus | Asia/Damascus | | Asia/Dhaka | BST | | Asia/Dili | Asia/Dili | | Asia/Dubai | Asia/Dubai | | Asia/Dushanbe | Asia/Dushanbe | | Asia/Famagusta | Asia/Famagusta | | Asia/Gaza | Asia/Gaza | | Asia/Harbin | CTT | | Asia/Hebron | Asia/Hebron | | Asia/Ho_Chi_Minh | VST | | Asia/Hong_Kong | Hongkong | | Asia/Hovd | Asia/Hovd | | Asia/Irkutsk | Asia/Irkutsk | | Asia/Istanbul | Turkey | | Asia/Jakarta | Asia/Jakarta | | Asia/Jayapura | Asia/Jayapura | | Asia/Jerusalem | Israel | | Asia/Kabul | Asia/Kabul | | Asia/Kamchatka | Asia/Kamchatka | | Asia/Karachi | PLT | | Asia/Kashgar | Asia/Kashgar | | Asia/Kathmandu | Asia/Kathmandu | | Asia/Katmandu | Asia/Katmandu | | Asia/Khandyga | Asia/Khandyga | | Asia/Kolkata | IST | | Asia/Krasnoyarsk | Asia/Krasnoyarsk | | Asia/Kuala_Lumpur | Singapore | | Asia/Kuching | Asia/Kuching | | Asia/Kuwait | Asia/Kuwait | | Asia/Macao | Asia/Macao | | Asia/Macau | Asia/Macau | | Asia/Magadan | Asia/Magadan | | Asia/Makassar | Asia/Makassar | | Asia/Manila | Asia/Manila | | Asia/Muscat | Asia/Muscat | | Asia/Nicosia | Asia/Nicosia | | Asia/Novokuznetsk | Asia/Novokuznetsk | | Asia/Novosibirsk | Asia/Novosibirsk | | Asia/Omsk | Asia/Omsk | | Asia/Oral | Asia/Oral | | Asia/Phnom_Penh | Asia/Phnom_Penh | | Asia/Pontianak | Asia/Pontianak | | Asia/Pyongyang | Asia/Pyongyang | | Asia/Qatar | Asia/Qatar | | Asia/Qostanay | Asia/Qostanay | | Asia/Qyzylorda | Asia/Qyzylorda | | Asia/Rangoon | Asia/Rangoon | | Asia/Riyadh | Asia/Riyadh | | Asia/Saigon | VST | | Asia/Sakhalin | Asia/Sakhalin | | Asia/Samarkand | Asia/Samarkand | | Asia/Seoul | ROK | | Asia/Shanghai | CTT | | Asia/Singapore | Singapore | | Asia/Srednekolymsk | Asia/Srednekolymsk | | Asia/Taipei | ROC | | Asia/Tashkent | Asia/Tashkent | | Asia/Tbilisi | Asia/Tbilisi | | Asia/Tehran | Iran | | Asia/Tel_Aviv | Israel | | Asia/Thimbu | Asia/Thimbu | | Asia/Thimphu | Asia/Thimphu | | Asia/Tokyo | JST | | Asia/Tomsk | Asia/Tomsk | | Asia/Ujung_Pandang | Asia/Ujung_Pandang | | Asia/Ulaanbaatar | Asia/Ulaanbaatar | | Asia/Ulan_Bator | Asia/Ulan_Bator | | Asia/Urumqi | Asia/Urumqi | | Asia/Ust-Nera | Asia/Ust-Nera | | Asia/Vientiane | Asia/Vientiane | | Asia/Vladivostok | Asia/Vladivostok | | Asia/Yakutsk | Asia/Yakutsk | | Asia/Yangon | Asia/Yangon | | Asia/Yekaterinburg | Asia/Yekaterinburg | | Asia/Yerevan | NET | | Atlantic/Azores | Atlantic/Azores | | Atlantic/Bermuda | Atlantic/Bermuda | | Atlantic/Canary | Atlantic/Canary | | Atlantic/Cape_Verde | Atlantic/Cape_Verde | | Atlantic/Faeroe | Atlantic/Faeroe | | Atlantic/Faroe | Atlantic/Faroe | | Atlantic/Jan_Mayen | Atlantic/Jan_Mayen | | Atlantic/Madeira | Atlantic/Madeira | | Atlantic/Reykjavik | Iceland | | Atlantic/South_Georgia | Atlantic/South_Georgia | | Atlantic/St_Helena | Iceland | | Atlantic/Stanley | Atlantic/Stanley | | Australia/ACT | AET | | Australia/Adelaide | Australia/Adelaide | | Australia/Brisbane | Australia/Brisbane | | Australia/Broken_Hill | Australia/Broken_Hill | | Australia/Canberra | AET | | Australia/Currie | Australia/Currie | | Australia/Darwin | ACT | | Australia/Eucla | Australia/Eucla | | Australia/Hobart | Australia/Hobart | | Australia/LHI | Australia/LHI | | Australia/Lindeman | Australia/Lindeman | | Australia/Lord_Howe | Australia/Lord_Howe | | Australia/Melbourne | Australia/Melbourne | | Australia/NSW | AET | | Australia/North | ACT | | Australia/Perth | Australia/Perth | | Australia/Queensland | Australia/Queensland | | Australia/South | Australia/South | | Australia/Sydney | AET | | Australia/Tasmania | Australia/Tasmania | | Australia/Victoria | Australia/Victoria | | Australia/West | Australia/West | | Australia/Yancowinna | Australia/Yancowinna | | BET | BET | | BST | BST | | Brazil/Acre | Brazil/Acre | | Brazil/DeNoronha | Brazil/DeNoronha | | Brazil/East | BET | | Brazil/West | Brazil/West | | CAT | CAT | | CET | CET | | CNT | CNT | | CST | CST | | CST6CDT | CST6CDT | | CTT | CTT | | Canada/Atlantic | Canada/Atlantic | | Canada/Central | Canada/Central | | Canada/East-Saskatchewan | Canada/East-Saskatchewan | | Canada/Eastern | Canada/Eastern | | Canada/Mountain | Canada/Mountain | | Canada/Newfoundland | CNT | | Canada/Pacific | Canada/Pacific | | Canada/Saskatchewan | Canada/Saskatchewan | | Canada/Yukon | Canada/Yukon | | Chile/Continental | Chile/Continental | | Chile/EasterIsland | Chile/EasterIsland | | Cuba | Cuba | | EAT | EAT | | ECT | ECT | | EET | EET | | EST | EST | | EST5EDT | EST5EDT | | Egypt | ART | | Eire | Eire | | Etc/GMT | GMT | | Etc/GMT+0 | GMT | | Etc/GMT+1 | Etc/GMT+1 | | Etc/GMT+10 | Etc/GMT+10 | | Etc/GMT+11 | Etc/GMT+11 | | Etc/GMT+12 | Etc/GMT+12 | | Etc/GMT+2 | Etc/GMT+2 | | Etc/GMT+3 | Etc/GMT+3 | | Etc/GMT+4 | Etc/GMT+4 | | Etc/GMT+5 | Etc/GMT+5 | | Etc/GMT+6 | Etc/GMT+6 | | Etc/GMT+7 | Etc/GMT+7 | | Etc/GMT+8 | Etc/GMT+8 | | Etc/GMT+9 | Etc/GMT+9 | | Etc/GMT-0 | GMT | | Etc/GMT-1 | Etc/GMT-1 | | Etc/GMT-10 | Etc/GMT-10 | | Etc/GMT-11 | Etc/GMT-11 | | Etc/GMT-12 | Etc/GMT-12 | | Etc/GMT-13 | Etc/GMT-13 | | Etc/GMT-14 | Etc/GMT-14 | | Etc/GMT-2 | Etc/GMT-2 | | Etc/GMT-3 | Etc/GMT-3 | | Etc/GMT-4 | Etc/GMT-4 | | Etc/GMT-5 | Etc/GMT-5 | | Etc/GMT-6 | Etc/GMT-6 | | Etc/GMT-7 | Etc/GMT-7 | | Etc/GMT-8 | Etc/GMT-8 | | Etc/GMT-9 | Etc/GMT-9 | | Etc/GMT0 | GMT | | Etc/Greenwich | GMT | | Etc/UCT | UCT | | Etc/UTC | UCT | | Etc/Universal | UCT | | Etc/Zulu | UCT | | Europe/Amsterdam | Europe/Amsterdam | | Europe/Andorra | Europe/Andorra | | Europe/Astrakhan | Europe/Astrakhan | | Europe/Athens | Europe/Athens | | Europe/Belfast | GB | | Europe/Belgrade | Europe/Belgrade | | Europe/Berlin | Europe/Berlin | | Europe/Bratislava | Europe/Bratislava | | Europe/Brussels | Europe/Brussels | | Europe/Bucharest | Europe/Bucharest | | Europe/Budapest | Europe/Budapest | | Europe/Busingen | Europe/Busingen | | Europe/Chisinau | Europe/Chisinau | | Europe/Copenhagen | Europe/Copenhagen | | Europe/Dublin | Eire | | Europe/Gibraltar | Europe/Gibraltar | | Europe/Guernsey | GB | | Europe/Helsinki | Europe/Helsinki | | Europe/Isle_of_Man | GB | | Europe/Istanbul | Turkey | | Europe/Jersey | GB | | Europe/Kaliningrad | Europe/Kaliningrad | | Europe/Kiev | Europe/Kiev | | Europe/Kirov | Europe/Kirov | | Europe/Kyiv | Europe/Kyiv | | Europe/Lisbon | Portugal | | Europe/Ljubljana | Europe/Ljubljana | | Europe/London | GB | | Europe/Luxembourg | Europe/Luxembourg | | Europe/Madrid | Europe/Madrid | | Europe/Malta | Europe/Malta | | Europe/Mariehamn | Europe/Mariehamn | | Europe/Minsk | Europe/Minsk | | Europe/Monaco | ECT | | Europe/Moscow | W-SU | | Europe/Nicosia | Europe/Nicosia | | Europe/Oslo | Europe/Oslo | | Europe/Paris | ECT | | Europe/Podgorica | Europe/Podgorica | | Europe/Prague | Europe/Prague | | Europe/Riga | Europe/Riga | | Europe/Rome | Europe/Rome | | Europe/Samara | Europe/Samara | | Europe/San_Marino | Europe/San_Marino | | Europe/Sarajevo | Europe/Sarajevo | | Europe/Saratov | Europe/Saratov | | Europe/Simferopol | Europe/Simferopol | | Europe/Skopje | Europe/Skopje | | Europe/Sofia | Europe/Sofia | | Europe/Stockholm | Europe/Stockholm | | Europe/Tallinn | Europe/Tallinn | | Europe/Tirane | Europe/Tirane | | Europe/Tiraspol | Europe/Tiraspol | | Europe/Ulyanovsk | Europe/Ulyanovsk | | Europe/Uzhgorod | Europe/Uzhgorod | | Europe/Vaduz | Europe/Vaduz | | Europe/Vatican | Europe/Vatican | | Europe/Vienna | Europe/Vienna | | Europe/Vilnius | Europe/Vilnius | | Europe/Volgograd | Europe/Volgograd | | Europe/Warsaw | Poland | | Europe/Zagreb | Europe/Zagreb | | Europe/Zaporozhye | Europe/Zaporozhye | | Europe/Zurich | Europe/Zurich | | Factory | Factory | | GB | GB | | GB-Eire | GB | | GMT | GMT | | GMT+0 | GMT | | GMT-0 | GMT | | GMT0 | GMT | | Greenwich | GMT | | HST | HST | | Hongkong | Hongkong | | IET | IET | | IST | IST | | Iceland | Iceland | | Indian/Antananarivo | EAT | | Indian/Chagos | Indian/Chagos | | Indian/Christmas | Indian/Christmas | | Indian/Cocos | Indian/Cocos | | Indian/Comoro | EAT | | Indian/Kerguelen | Indian/Kerguelen | | Indian/Mahe | Indian/Mahe | | Indian/Maldives | Indian/Maldives | | Indian/Mauritius | Indian/Mauritius | | Indian/Mayotte | EAT | | Indian/Reunion | Indian/Reunion | | Iran | Iran | | Israel | Israel | | JST | JST | | Jamaica | Jamaica | | Japan | JST | | Kwajalein | Kwajalein | | Libya | Libya | | MET | MET | | MIT | MIT | | MST | MST | | MST7MDT | MST7MDT | | Mexico/BajaNorte | Mexico/BajaNorte | | Mexico/BajaSur | Mexico/BajaSur | | Mexico/General | Mexico/General | | NET | NET | | NST | NZ | | NZ | NZ | | NZ-CHAT | NZ-CHAT | | Navajo | Navajo | | PLT | PLT | | PNT | PNT | | PRC | CTT | | PRT | PRT | | PST | PST | | PST8PDT | PST8PDT | | Pacific/Apia | MIT | | Pacific/Auckland | NZ | | Pacific/Bougainville | Pacific/Bougainville | | Pacific/Chatham | NZ-CHAT | | Pacific/Chuuk | Pacific/Chuuk | | Pacific/Easter | Pacific/Easter | | Pacific/Efate | Pacific/Efate | | Pacific/Enderbury | Pacific/Enderbury | | Pacific/Fakaofo | Pacific/Fakaofo | | Pacific/Fiji | Pacific/Fiji | | Pacific/Funafuti | Pacific/Funafuti | | Pacific/Galapagos | Pacific/Galapagos | | Pacific/Gambier | Pacific/Gambier | | Pacific/Guadalcanal | SST | | Pacific/Guam | Pacific/Guam | | Pacific/Honolulu | Pacific/Honolulu | | Pacific/Johnston | Pacific/Johnston | | Pacific/Kanton | Pacific/Kanton | | Pacific/Kiritimati | Pacific/Kiritimati | | Pacific/Kosrae | Pacific/Kosrae | | Pacific/Kwajalein | Kwajalein | | Pacific/Majuro | Pacific/Majuro | | Pacific/Marquesas | Pacific/Marquesas | | Pacific/Midway | Pacific/Midway | | Pacific/Nauru | Pacific/Nauru | | Pacific/Niue | Pacific/Niue | | Pacific/Norfolk | Pacific/Norfolk | | Pacific/Noumea | Pacific/Noumea | | Pacific/Pago_Pago | Pacific/Pago_Pago | | Pacific/Palau | Pacific/Palau | | Pacific/Pitcairn | Pacific/Pitcairn | | Pacific/Pohnpei | SST | | Pacific/Ponape | SST | | Pacific/Port_Moresby | Pacific/Port_Moresby | | Pacific/Rarotonga | Pacific/Rarotonga | | Pacific/Saipan | Pacific/Saipan | | Pacific/Samoa | Pacific/Samoa | | Pacific/Tahiti | Pacific/Tahiti | | Pacific/Tarawa | Pacific/Tarawa | | Pacific/Tongatapu | Pacific/Tongatapu | | Pacific/Truk | Pacific/Truk | | Pacific/Wake | Pacific/Wake | | Pacific/Wallis | Pacific/Wallis | | Pacific/Yap | Pacific/Yap | | Poland | Poland | | Portugal | Portugal | | ROC | ROC | | ROK | ROK | | SST | SST | | Singapore | Singapore | | SystemV/AST4 | SystemV/AST4 | | SystemV/AST4ADT | SystemV/AST4ADT | | SystemV/CST6 | SystemV/CST6 | | SystemV/CST6CDT | SystemV/CST6CDT | | SystemV/EST5 | SystemV/EST5 | | SystemV/EST5EDT | SystemV/EST5EDT | | SystemV/HST10 | SystemV/HST10 | | SystemV/MST7 | SystemV/MST7 | | SystemV/MST7MDT | SystemV/MST7MDT | | SystemV/PST8 | SystemV/PST8 | | SystemV/PST8PDT | SystemV/PST8PDT | | SystemV/YST9 | SystemV/YST9 | | SystemV/YST9YDT | SystemV/YST9YDT | | Turkey | Turkey | | UCT | UCT | | US/Alaska | AST | | US/Aleutian | US/Aleutian | | US/Arizona | PNT | | US/Central | CST | | US/East-Indiana | IET | | US/Eastern | US/Eastern | | US/Hawaii | US/Hawaii | | US/Indiana-Starke | US/Indiana-Starke | | US/Michigan | US/Michigan | | US/Mountain | Navajo | | US/Pacific | PST | | US/Pacific-New | PST | | US/Samoa | US/Samoa | | UTC | UCT | | Universal | UCT | | VST | VST | | W-SU | W-SU | | WET | WET | | Zulu | UCT |

SQL

Data Types

Union Type

A `UNION` *type* (not to be confused with the SQL [`UNION` operator](#docs:sql:query_syntax:setops::union-all-by-name)) is a nested type capable of holding one of multiple “alternative” values, much like the `union` in C. The main difference being that these `UNION` types are *tagged unions* and thus always carry a discriminator “tag” which signals which alternative it is currently holding, even if the inner value itself is null. `UNION` types are thus more similar to C++17's `std::variant`, Rust's `Enum` or the “sum type” present in most functional languages. `UNION` types must always have at least one member, and while they can contain multiple members of the same type, the tag names must be unique. `UNION` types can have at most 256 members. Under the hood, `UNION` types are implemented on top of `STRUCT` types, and simply keep the “tag” as the first entry. `UNION` values can be created with the [`union_value(tag := expr)`](#docs:sql:functions:union) function or by [casting from a member type](#::casting-to-unions).

SQL

Data Types

Example

Create a table with a `UNION` column: ```sql CREATE TABLE tbl1 (u UNION(num INTEGER, str VARCHAR)); INSERT INTO tbl1 values (1), ('two'), (union_value(str := 'three')); ``` Any type can be implicitly cast to a `UNION` containing the type. Any `UNION` can also be implicitly cast to another `UNION` if the source `UNION` members are a subset of the target's (if the cast is unambiguous). `UNION` uses the member types' `VARCHAR` cast functions when casting to `VARCHAR`: ```sql SELECT u FROM tbl1; ``` | u | |-------| | 1 | | two | | three | Select all the `str` members: ```sql SELECT union_extract(u, 'str') AS str FROM tbl1; ``` | str | |-------| | NULL | | two | | three | Alternatively, you can use 'dot syntax' similarly to [`STRUCT`s](#docs:sql:data_types:struct). ```sql SELECT u.str FROM tbl1; ``` | str | |-------| | NULL | | two | | three | Select the currently active tag from the `UNION` as an `ENUM`. ```sql SELECT union_tag(u) AS t FROM tbl1; ``` | t | |-----| | num | | str | | str |

SQL

Data Types

Union Casts

Compared to other nested types, `UNION`s allow a set of implicit casts to facilitate unintrusive and natural usage when working with their members as “subtypes”. However, these casts have been designed with two principles in mind, to avoid ambiguity and to avoid casts that could lead to loss of information. This prevents `UNION`s from being completely “transparent”, while still allowing `UNION` types to have a “supertype” relationship with their members. Thus `UNION` types can't be implicitly cast to any of their member types in general, since the information in the other members not matching the target type would be “lost”. If you want to coerce a `UNION` into one of its members, you should use the `union_extract` function explicitly instead. The only exception to this is when casting a `UNION` to `VARCHAR`, in which case the members will all use their corresponding `VARCHAR` casts. Since everything can be cast to `VARCHAR`, this is “safe” in a sense. #### Casting to Unions {#docs:sql:data_types:union::casting-to-unions} A type can always be implicitly cast to a `UNION` if it can be implicitly cast to one of the `UNION` member types. * If there are multiple candidates, the built in implicit casting priority rules determine the target type. For example, a `FLOAT` → `UNION(i INTEGER, v VARCHAR)` cast will always cast the `FLOAT` to the `INTEGER` member before `VARCHAR`. * If the cast still is ambiguous, i.e., there are multiple candidates with the same implicit casting priority, an error is raised. This usually happens when the `UNION` contains multiple members of the same type, e.g., a `FLOAT` → `UNION(i INTEGER, num INTEGER)` is always ambiguous. So how do we disambiguate if we want to create a `UNION` with multiple members of the same type? By using the `union_value` function, which takes a keyword argument specifying the tag. For example, `union_value(num := 2::INTEGER)` will create a `UNION` with a single member of type `INTEGER` with the tag `num`. This can then be used to disambiguate in an explicit (or implicit, read on below!) `UNION` to `UNION` cast, like `CAST(union_value(b := 2) AS UNION(a INTEGER, b INTEGER))`. #### Casting between Unions {#docs:sql:data_types:union::casting-between-unions} `UNION` types can be cast between each other if the source type is a “subset” of the target type. In other words, all the tags in the source `UNION` must be present in the target `UNION`, and all the types of the matching tags must be implicitly castable between source and target. In essence, this means that `UNION` types are covariant with respect to their members. <div class="narrow_table"></div> | Ok | Source | Target | Comments | |----|------------------------|------------------------|----------------------------------------| | ✅ | `UNION(a A, b B)` | `UNION(a A, b B, c C)` | | | ✅ | `UNION(a A, b B)` | `UNION(a A, b C)` | if `B` can be implicitly cast to `C` | | ❌ | `UNION(a A, b B, c C)` | `UNION(a A, b B)` | | | ❌ | `UNION(a A, b B)` | `UNION(a A, b C)` | if `B` can't be implicitly cast to `C` | | ❌ | `UNION(A, B, D)` | `UNION(A, B, C)` | |

SQL

Data Types

Comparison and Sorting

Since `UNION` types are implemented on top of `STRUCT` types internally, they can be used with all the comparison operators as well as in both `WHERE` and `HAVING` clauses with [the same semantics as `STRUCT`s](#docs:sql:data_types:struct::comparison-operators). The “tag” is always stored as the first struct entry, which ensures that the `UNION` types are compared and ordered by “tag” first.

SQL

Data Types

Functions

See [Union Functions](#docs:sql:functions:union).

SQL

Data Types

Typecasting

Typecasting is an operation that converts a value in one particular data type to the closest corresponding value in another data type. Like other SQL engines, DuckDB supports both implicit and explicit typecasting.

SQL

Data Types

Explicit Casting

Explicit typecasting is performed by using a `CAST` expression. For example, `CAST(col AS VARCHAR)` or `col::VARCHAR` explicitly cast the column `col` to `VARCHAR`. See the [cast page](#docs:sql:expressions:cast) for more information.

SQL

Data Types

Implicit Casting

In many situations, the system will add casts by itself. This is called *implicit* casting. This happens for example when a function is called with an argument that does not match the type of the function, but can be casted to the desired type. Consider the function `sin(DOUBLE)`. This function takes as input argument a column of type `DOUBLE`, however, it can be called with an integer as well: `sin(1)`. The integer is converted into a double before being passed to the `sin` function. Implicit casts can only be added for a number of type combinations, and is generally only possible when the cast cannot fail. For example, an implicit cast can be added from `INTEGER` to `DOUBLE` – but not from `DOUBLE` to `INTEGER`.

SQL

Data Types

Casting Operations Matrix

Values of a particular data type cannot always be cast to any arbitrary target data type. The only exception is the `NULL` value – which can always be converted between types. The following matrix describes which conversions are supported. When implicit casting is allowed, it implies that explicit casting is also possible.  Even though a casting operation is supported based on the source and target data type, it does not necessarily mean the cast operation will succeed at runtime. > **Deprecated. ** Prior to version 0.10.0, DuckDB allowed any type to be implicitly cast to `VARCHAR` during function binding. > Version 0.10.0 introduced a [breaking change which no longer allows implicit casts to `VARCHAR`](https://duckdb.org/2024/02/13/announcing-duckdb-0100#breaking-sql-changes). > The [`old_implicit_casting` configuration option](#docs:configuration:pragmas::implicit-casting-to-varchar) setting can be used to revert to the old behavior. > However, please note that this flag will be deprecated in the future. #### Lossy Casts {#docs:sql:data_types:typecasting::lossy-casts} Casting operations that result in loss of precision are allowed. For example, it is possible to explicitly cast a numeric type with fractional digits like `DECIMAL`, `FLOAT` or `DOUBLE` to an integral type like `INTEGER`. The number will be rounded. ```sql SELECT CAST(3.5 AS INTEGER); ``` #### Overflows {#docs:sql:data_types:typecasting::overflows} Casting operations that would result in a value overflow throw an error. For example, the value `999` is too large to be represented by the `TINYINT` data type. Therefore, an attempt to cast that value to that type results in a runtime error: ```sql SELECT CAST(999 AS TINYINT); ``` ```console Conversion Error: Type INT32 with value 999 can't be cast because the value is out of range for the destination type INT8 ``` So even though the cast operation from `INTEGER` to `TINYINT` is supported, it is not possible for this particular value. [TRY_CAST](#docs:sql:expressions:cast) can be used to convert the value into `NULL` instead of throwing an error. #### Varchar {#docs:sql:data_types:typecasting::varchar} The [`VARCHAR`](#docs:sql:data_types:text) type acts as a univeral target: any arbitrary value of any arbitrary type can always be cast to the `VARCHAR` type. This type is also used for displaying values in the shell. ```sql SELECT CAST(42.5 AS VARCHAR); ``` Casting from `VARCHAR` to another data type is supported, but can raise an error at runtime if DuckDB cannot parse and convert the provided text to the target data type. ```sql SELECT CAST('NotANumber' AS INTEGER); ``` In general, casting to `VARCHAR` is a lossless operation and any type can be cast back to the original type after being converted into text. ```sql SELECT CAST(CAST([1, 2, 3] AS VARCHAR) AS INTEGER[]); ``` #### Literal Types {#docs:sql:data_types:typecasting::literal-types} Integer literals (such as `42`) and string literals (such as `'string'`) have special implicit casting rules. See the [literal types page](#docs:sql:data_types:literal_types) for more information. #### Lists / Arrays {#docs:sql:data_types:typecasting::lists--arrays} Lists can be explicitly cast to other lists using the same casting rules. The cast is applied to the children of the list. For example, if we convert a `INTEGER[]` list to a `VARCHAR[]` list, the child `INTEGER` elements are individually cast to `VARCHAR` and a new list is constructed. ```sql SELECT CAST([1, 2, 3] AS VARCHAR[]); ``` #### Arrays {#docs:sql:data_types:typecasting::arrays} Arrays follow the same casting rules as lists. In addition, arrays can be implicitly cast to lists of the same type. For example, an `INTEGER[3]` array can be implicitly cast to an `INTEGER[]` list. #### Structs {#docs:sql:data_types:typecasting::structs} Structs can be cast to other structs as long as the names of the child elements match. ```sql SELECT CAST({'a': 42} AS STRUCT(a VARCHAR)); ``` The names of the struct can also be in a different order. The fields of the struct will be reshuffled based on the names of the structs. ```sql SELECT CAST({'a': 42, 'b': 84} AS STRUCT(b VARCHAR, a VARCHAR)); ``` #### Unions {#docs:sql:data_types:typecasting::unions} Union casting rules can be found on the [`UNION type page`](#docs:sql:data_types:union::casting-to-unions).

SQL

Expressions

Expressions

An expression is a combination of values, operators and functions. Expressions are highly composable, and range from very simple to arbitrarily complex. They can be found in many different parts of SQL statements. In this section, we provide the different types of operators and functions that can be used within expressions.

SQL

Expressions

CASE Statement

<div id="rrdiagram"></div> The `CASE` statement performs a switch based on a condition. The basic form is identical to the ternary condition used in many programming languages (` CASE WHEN cond THEN a ELSE b END` is equivalent to `cond ? a : b`). With a single condition this can be expressed with `IF(cond, a, b)`. ```sql CREATE OR REPLACE TABLE integers AS SELECT unnest([1, 2, 3]) AS i; SELECT i, CASE WHEN i > 2 THEN 1 ELSE 0 END AS test FROM integers; ``` | i | test | |--:|-----:| | 1 | 0 | | 2 | 0 | | 3 | 1 | This is equivalent to: ```sql SELECT i, IF(i > 2, 1, 0) AS test FROM integers; ``` The `WHEN cond THEN expr` part of the `CASE` statement can be chained, whenever any of the conditions returns true for a single tuple, the corresponding expression is evaluated and returned. ```sql CREATE OR REPLACE TABLE integers AS SELECT unnest([1, 2, 3]) AS i; SELECT i, CASE WHEN i = 1 THEN 10 WHEN i = 2 THEN 20 ELSE 0 END AS test FROM integers; ``` | i | test | |--:|-----:| | 1 | 10 | | 2 | 20 | | 3 | 0 | The `ELSE` part of the `CASE` statement is optional. If no else statement is provided and none of the conditions match, the `CASE` statement will return `NULL`. ```sql CREATE OR REPLACE TABLE integers AS SELECT unnest([1, 2, 3]) AS i; SELECT i, CASE WHEN i = 1 THEN 10 END AS test FROM integers; ``` | i | test | |--:|-----:| | 1 | 10 | | 2 | NULL | | 3 | NULL | It is also possible to provide an individual expression after the `CASE` but before the `WHEN`. When this is done, the `CASE` statement is effectively transformed into a switch statement. ```sql CREATE OR REPLACE TABLE integers AS SELECT unnest([1, 2, 3]) AS i; SELECT i, CASE i WHEN 1 THEN 10 WHEN 2 THEN 20 WHEN 3 THEN 30 END AS test FROM integers; ``` | i | test | |--:|-----:| | 1 | 10 | | 2 | 20 | | 3 | 30 | This is equivalent to: ```sql SELECT i, CASE WHEN i = 1 THEN 10 WHEN i = 2 THEN 20 WHEN i = 3 THEN 30 END AS test FROM integers; ```

SQL

Expressions

Casting

<div id="rrdiagram"></div> Casting refers to the operation of converting a value in a particular data type to the corresponding value in another data type. Casting can occur either implicitly or explicitly. The syntax described here performs an explicit cast. More information on casting can be found on the [typecasting page](#docs:sql:data_types:typecasting).

SQL

Expressions

Explicit Casting

The standard SQL syntax for explicit casting is `CAST(expr AS TYPENAME)`, where `TYPENAME` is a name (or alias) of one of [DuckDB's data types](#docs:sql:data_types:overview). DuckDB also supports the shorthand `expr::TYPENAME`, which is also present in PostgreSQL. ```sql SELECT CAST(i AS VARCHAR) AS i FROM generate_series(1, 3) tbl(i); ``` | i | |---| | 1 | | 2 | | 3 | ```sql SELECT i::DOUBLE AS i FROM generate_series(1, 3) tbl(i); ``` | i | |----:| | 1.0 | | 2.0 | | 3.0 | #### Casting Rules {#docs:sql:expressions:cast::casting-rules} Not all casts are possible. For example, it is not possible to convert an `INTEGER` to a `DATE`. Casts may also throw errors when the cast could not be successfully performed. For example, trying to cast the string `'hello'` to an `INTEGER` will result in an error being thrown. ```sql SELECT CAST('hello' AS INTEGER); ``` ```console Conversion Error: Could not convert string 'hello' to INT32 ``` The exact behavior of the cast depends on the source and destination types. For example, when casting from `VARCHAR` to any other type, the string will be attempted to be converted. #### `TRY_CAST` {#docs:sql:expressions:cast::try_cast} `TRY_CAST` can be used when the preferred behavior is not to throw an error, but instead to return a `NULL` value. `TRY_CAST` will never throw an error, and will instead return `NULL` if a cast is not possible. ```sql SELECT TRY_CAST('hello' AS INTEGER) AS i; ``` | i | |------| | NULL |

SQL

Expressions

Collations

<div id="rrdiagram"></div> Collations provide rules for how text should be sorted or compared in the execution engine. Collations are useful for localization, as the rules for how text should be ordered are different for different languages or for different countries. These orderings are often incompatible with one another. For example, in English the letter `y` comes between `x` and `z`. However, in Lithuanian the letter `y` comes between the `i` and `j`. For that reason, different collations are supported. The user must choose which collation they want to use when performing sorting and comparison operations. By default, the `BINARY` collation is used. That means that strings are ordered and compared based only on their binary contents. This makes sense for standard ASCII characters (i.e., the letters A-Z and numbers 0-9), but generally does not make much sense for special unicode characters. It is, however, by far the fastest method of performing ordering and comparisons. Hence it is recommended to stick with the `BINARY` collation unless required otherwise. > **Warning. ** Collation support in DuckDB has [some known limitations](https://github.com/duckdb/duckdb/issues?q=is%3Aissue+is%3Aopen+collation+) and has [several planned improvements](https://github.com/duckdb/duckdb/issues/604).

SQL

Expressions

Using Collations

In the stand-alone installation of DuckDB three collations are included: `NOCASE`, `NOACCENT` and `NFC`. The `NOCASE` collation compares characters as equal regardless of their casing. The `NOACCENT` collation compares characters as equal regardless of their accents. The `NFC` collation performs NFC-normalized comparisons, see [Unicode normalization](https://en.wikipedia.org/wiki/Unicode_equivalence#Normalization) for more information. ```sql SELECT 'hello' = 'hElLO'; ``` ```text false ``` ```sql SELECT 'hello' COLLATE NOCASE = 'hElLO'; ``` ```text true ``` ```sql SELECT 'hello' = 'hëllo'; ``` ```text false ``` ```sql SELECT 'hello' COLLATE NOACCENT = 'hëllo'; ``` ```text true ``` Collations can be combined by chaining them using the dot operator. Note, however, that not all collations can be combined together. In general, the `NOCASE` collation can be combined with any other collator, but most other collations cannot be combined. ```sql SELECT 'hello' COLLATE NOCASE = 'hElLÖ'; ``` ```text false ``` ```sql SELECT 'hello' COLLATE NOACCENT = 'hElLÖ'; ``` ```text false ``` ```sql SELECT 'hello' COLLATE NOCASE.NOACCENT = 'hElLÖ'; ``` ```text true ```

SQL

Expressions

Default Collations

The collations we have seen so far have all been specified *per expression*. It is also possible to specify a default collator, either on the global database level or on a base table column. The `PRAGMA` `default_collation` can be used to specify the global default collator. This is the collator that will be used if no other one is specified. ```sql SET default_collation = NOCASE; SELECT 'hello' = 'HeLlo'; ``` ```text true ``` Collations can also be specified per-column when creating a table. When that column is then used in a comparison, the per-column collation is used to perform that comparison. ```sql CREATE TABLE names (name VARCHAR COLLATE NOACCENT); INSERT INTO names VALUES ('hännes'); ``` ```sql SELECT name FROM names WHERE name = 'hannes'; ``` ```text hännes ``` Be careful here, however, as different collations cannot be combined. This can be problematic when you want to compare columns that have a different collation specified. ```sql SELECT name FROM names WHERE name = 'hannes' COLLATE NOCASE; ``` ```console ERROR: Cannot combine types with different collation! ``` ```sql CREATE TABLE other_names (name VARCHAR COLLATE NOCASE); INSERT INTO other_names VALUES ('HÄNNES'); ``` ```sql SELECT names.name AS name, other_names.name AS other_name FROM names, other_names WHERE names.name = other_names.name; ``` ```console ERROR: Cannot combine types with different collation! ``` We need to manually overwrite the collation: ```sql SELECT names.name AS name, other_names.name AS other_name FROM names, other_names WHERE names.name COLLATE NOACCENT.NOCASE = other_names.name COLLATE NOACCENT.NOCASE; ``` | name | other_name | |--------|------------| | hännes | HÄNNES |

SQL

Expressions

ICU Collations

The collations we have seen so far are not region-dependent, and do not follow any specific regional rules. If you wish to follow the rules of a specific region or language, you will need to use one of the ICU collations. For that, you need to [load the ICU extension](#docs:extensions:icu::installing-and-loading). If you are using the C++ API, you may find the extension in the `extension/icu` folder of the DuckDB project. Using the C++ API, the extension can be loaded as follows: ```cpp DuckDB db; db.LoadExtension<ICUExtension>(); ``` Loading this extension will add a number of language and region specific collations to your database. These can be queried using `PRAGMA collations` command, or by querying the `pragma_collations` function. ```sql PRAGMA collations; SELECT * FROM pragma_collations(); ``` ```text [af, am, ar, as, az, be, bg, bn, bo, bs, bs, ca, ceb, chr, cs, cy, da, de, de_AT, dsb, dz, ee, el, en, en_US, en_US, eo, es, et, fa, fa_AF, fi, fil, fo, fr, fr_CA, ga, gl, gu, ha, haw, he, he_IL, hi, hr, hsb, hu, hy, id, id_ID, ig, is, it, ja, ka, kk, kl, km, kn, ko, kok, ku, ky, lb, lkt, ln, lo, lt, lv, mk, ml, mn, mr, ms, mt, my, nb, nb_NO, ne, nl, nn, om, or, pa, pa, pa_IN, pl, ps, pt, ro, ru, se, si, sk, sl, smn, sq, sr, sr, sr_BA, sr_ME, sr_RS, sr, sr_BA, sr_RS, sv, sw, ta, te, th, tk, to, tr, ug, uk, ur, uz, vi, wae, wo, xh, yi, yo, zh, zh, zh_CN, zh_SG, zh, zh_HK, zh_MO, zh_TW, zu] ``` These collations can then be used as the other collations would be used before. They can also be combined with the `NOCASE` collation. For example, to use the German collation rules you could use the following code snippet: ```sql CREATE TABLE strings (s VARCHAR COLLATE DE); INSERT INTO strings VALUES ('Gabel'), ('Göbel'), ('Goethe'), ('Goldmann'), ('Göthe'), ('Götz'); SELECT * FROM strings ORDER BY s; ``` ```text "Gabel", "Göbel", "Goethe", "Goldmann", "Göthe", "Götz" ```