mirror of
https://github.com/ClickHouse/ClickHouse.git
synced 2024-11-21 15:12:02 +00:00
Merge pull request #64606 from rschu1ze/map-stuff
Double-checking #59318 and docs for `Map`
This commit is contained in:
Robert Schulze
GitHub
commit
ec3b82ba63
@ -1,7 +1,7 @@
|
||||
---
|
||||
slug: /en/sql-reference/data-types/boolean
|
||||
sidebar_position: 22
|
||||
sidebar_label: Boolean
|
||||
sidebar_label: Bool
|
||||
---
|
||||
|
||||
# Bool
|
||||
|
||||
@ -6,101 +6,106 @@ sidebar_label: Map(K, V)
|
||||
|
||||
# Map(K, V)
|
||||
|
||||
`Map(K, V)` data type stores `key:value` pairs.
|
||||
The Map datatype is implemented as `Array(Tuple(key T1, value T2))`, which means that the order of keys in each map does not change, i.e., this data type maintains insertion order.
|
||||
Data type `Map(K, V)` stores key-value pairs.
|
||||
|
||||
Unlike other databases, maps are not unique in ClickHouse, i.e. a map can contain two elements with the same key.
|
||||
(The reason for that is that maps are internally implemented as `Array(Tuple(K, V))`.)
|
||||
|
||||
You can use use syntax `m[k]` to obtain the value for key `k` in map `m`.
|
||||
Also, `m[k]` scans the map, i.e. the runtime of the operation is linear in the size of the map.
|
||||
|
||||
**Parameters**
|
||||
|
||||
- `key` — The key part of the pair. Arbitrary type, except [Nullable](../../sql-reference/data-types/nullable.md) and [LowCardinality](../../sql-reference/data-types/lowcardinality.md) nested with [Nullable](../../sql-reference/data-types/nullable.md) types.
|
||||
- `value` — The value part of the pair. Arbitrary type, including [Map](../../sql-reference/data-types/map.md) and [Array](../../sql-reference/data-types/array.md).
|
||||
|
||||
To get the value from an `a Map('key', 'value')` column, use `a['key']` syntax. This lookup works now with a linear complexity.
|
||||
- `K` — The type of the Map keys. Arbitrary type except [Nullable](../../sql-reference/data-types/nullable.md) and [LowCardinality](../../sql-reference/data-types/lowcardinality.md) nested with [Nullable](../../sql-reference/data-types/nullable.md) types.
|
||||
- `V` — The type of the Map values. Arbitrary type.
|
||||
|
||||
**Examples**
|
||||
|
||||
Consider the table:
|
||||
Create a table with a column of type map:
|
||||
|
||||
``` sql
|
||||
CREATE TABLE table_map (a Map(String, UInt64)) ENGINE=Memory;
|
||||
INSERT INTO table_map VALUES ({'key1':1, 'key2':10}), ({'key1':2,'key2':20}), ({'key1':3,'key2':30});
|
||||
CREATE TABLE tab (m Map(String, UInt64)) ENGINE=Memory;
|
||||
INSERT INTO tab VALUES ({'key1':1, 'key2':10}), ({'key1':2,'key2':20}), ({'key1':3,'key2':30});
|
||||
```
|
||||
|
||||
Select all `key2` values:
|
||||
To select `key2` values:
|
||||
|
||||
```sql
|
||||
SELECT a['key2'] FROM table_map;
|
||||
SELECT m['key2'] FROM tab;
|
||||
```
|
||||
|
||||
Result:
|
||||
|
||||
```text
|
||||
┌─arrayElement(a, 'key2')─┐
|
||||
┌─arrayElement(m, 'key2')─┐
|
||||
│ 10 │
|
||||
│ 20 │
|
||||
│ 30 │
|
||||
└─────────────────────────┘
|
||||
```
|
||||
|
||||
If there's no such `key` in the `Map()` column, the query returns zeros for numerical values, empty strings or empty arrays.
|
||||
If the requested key `k` is not contained in the map, `m[k]` returns the value type's default value, e.g. `0` for integer types and `''` for string types.
|
||||
To check whether a key exists in a map, you can use function [mapContains](../../sql-reference/functions/tuple-map-functions#mapcontains).
|
||||
|
||||
```sql
|
||||
INSERT INTO table_map VALUES ({'key3':100}), ({});
|
||||
SELECT a['key3'] FROM table_map;
|
||||
CREATE TABLE tab (m Map(String, UInt64)) ENGINE=Memory;
|
||||
INSERT INTO tab VALUES ({'key1':100}), ({});
|
||||
SELECT m['key1'] FROM tab;
|
||||
```
|
||||
|
||||
Result:
|
||||
|
||||
```text
|
||||
┌─arrayElement(a, 'key3')─┐
|
||||
┌─arrayElement(m, 'key1')─┐
|
||||
│ 100 │
|
||||
│ 0 │
|
||||
└─────────────────────────┘
|
||||
┌─arrayElement(a, 'key3')─┐
|
||||
│ 0 │
|
||||
│ 0 │
|
||||
│ 0 │
|
||||
└─────────────────────────┘
|
||||
```
|
||||
|
||||
## Convert Tuple to Map Type
|
||||
## Converting Tuple to Map
|
||||
|
||||
You can cast `Tuple()` as `Map()` using [CAST](../../sql-reference/functions/type-conversion-functions.md#type_conversion_function-cast) function:
|
||||
Values of type `Tuple()` can be casted to values of type `Map()` using function [CAST](../../sql-reference/functions/type-conversion-functions.md#type_conversion_function-cast):
|
||||
|
||||
**Example**
|
||||
|
||||
Query:
|
||||
|
||||
``` sql
|
||||
SELECT CAST(([1, 2, 3], ['Ready', 'Steady', 'Go']), 'Map(UInt8, String)') AS map;
|
||||
```
|
||||
|
||||
Result:
|
||||
|
||||
``` text
|
||||
┌─map───────────────────────────┐
|
||||
│ {1:'Ready',2:'Steady',3:'Go'} │
|
||||
└───────────────────────────────┘
|
||||
```
|
||||
|
||||
## Map.keys and Map.values Subcolumns
|
||||
## Reading subcolumns of Map
|
||||
|
||||
To optimize `Map` column processing, in some cases you can use the `keys` and `values` subcolumns instead of reading the whole column.
|
||||
To avoid reading the entire map, you can use subcolumns `keys` and `values` in some cases.
|
||||
|
||||
**Example**
|
||||
|
||||
Query:
|
||||
|
||||
``` sql
|
||||
CREATE TABLE t_map (`a` Map(String, UInt64)) ENGINE = Memory;
|
||||
CREATE TABLE tab (m Map(String, UInt64)) ENGINE = Memory;
|
||||
INSERT INTO tab VALUES (map('key1', 1, 'key2', 2, 'key3', 3));
|
||||
|
||||
INSERT INTO t_map VALUES (map('key1', 1, 'key2', 2, 'key3', 3));
|
||||
|
||||
SELECT a.keys FROM t_map;
|
||||
|
||||
SELECT a.values FROM t_map;
|
||||
SELECT m.keys FROM tab; -- same as mapKeys(m)
|
||||
SELECT m.values FROM tab; -- same as mapValues(m)
|
||||
```
|
||||
|
||||
Result:
|
||||
|
||||
``` text
|
||||
┌─a.keys─────────────────┐
|
||||
┌─m.keys─────────────────┐
|
||||
│ ['key1','key2','key3'] │
|
||||
└────────────────────────┘
|
||||
|
||||
┌─a.values─┐
|
||||
┌─m.values─┐
|
||||
│ [1,2,3] │
|
||||
└──────────┘
|
||||
```
|
||||
|
||||
@ -6,7 +6,7 @@ sidebar_label: Maps
|
||||
|
||||
## map
|
||||
|
||||
Arranges `key:value` pairs into [Map(key, value)](../data-types/map.md) data type.
|
||||
Creates a value of type [Map(key, value)](../data-types/map.md) from key-value pairs.
|
||||
|
||||
**Syntax**
|
||||
|
||||
@ -16,12 +16,12 @@ map(key1, value1[, key2, value2, ...])
|
||||
|
||||
**Arguments**
|
||||
|
||||
- `key` — The key part of the pair. Arbitrary type, except [Nullable](../data-types/nullable.md) and [LowCardinality](../data-types/lowcardinality.md) nested with [Nullable](../data-types/nullable.md).
|
||||
- `value` — The value part of the pair. Arbitrary type, including [Map](../data-types/map.md) and [Array](../data-types/array.md).
|
||||
- `key_n` — The keys of the map entries. Any type supported as key type of [Map](../data-types/map.md).
|
||||
- `value_n` — The values of the map entries. Any type supported as value type of [Map](../data-types/map.md).
|
||||
|
||||
**Returned value**
|
||||
|
||||
- Data structure as `key:value` pairs. [Map(key, value)](../data-types/map.md).
|
||||
- A map containing `key:value` pairs. [Map(key, value)](../data-types/map.md).
|
||||
|
||||
**Examples**
|
||||
|
||||
@ -41,35 +41,16 @@ Result:
|
||||
└──────────────────────────────────────────────────┘
|
||||
```
|
||||
|
||||
Query:
|
||||
|
||||
```sql
|
||||
CREATE TABLE table_map (a Map(String, UInt64)) ENGINE = MergeTree() ORDER BY a;
|
||||
INSERT INTO table_map SELECT map('key1', number, 'key2', number * 2) FROM numbers(3);
|
||||
SELECT a['key2'] FROM table_map;
|
||||
```
|
||||
|
||||
Result:
|
||||
|
||||
```text
|
||||
┌─arrayElement(a, 'key2')─┐
|
||||
│ 0 │
|
||||
│ 2 │
|
||||
│ 4 │
|
||||
└─────────────────────────┘
|
||||
```
|
||||
|
||||
**See Also**
|
||||
|
||||
- [Map(key, value)](../data-types/map.md) data type
|
||||
|
||||
## mapFromArrays
|
||||
|
||||
Merges an [Array](../data-types/array.md) of keys and an [Array](../data-types/array.md) of values into a [Map(key, value)](../data-types/map.md). Notice that the second argument could also be a [Map](../data-types/map.md), thus it is casted to an Array when executing.
|
||||
Creates a map from an array of keys and an array of values.
|
||||
|
||||
The function is a convenient alternative to syntax `CAST([...], 'Map(key_type, value_type)')`.
|
||||
For example, instead of writing
|
||||
- `CAST((['aa', 'bb'], [4, 5]), 'Map(String, UInt32)')`, or
|
||||
- `CAST([('aa',4), ('bb',5)], 'Map(String, UInt32)')`
|
||||
|
||||
The function is a more convenient alternative to `CAST((key_array, value_array_or_map), 'Map(key_type, value_type)')`. For example, instead of writing `CAST((['aa', 'bb'], [4, 5]), 'Map(String, UInt32)')`, you can write `mapFromArrays(['aa', 'bb'], [4, 5])`.
|
||||
|
||||
you can write `mapFromArrays(['aa', 'bb'], [4, 5])`.
|
||||
|
||||
**Syntax**
|
||||
|
||||
@ -81,12 +62,12 @@ Alias: `MAP_FROM_ARRAYS(keys, values)`
|
||||
|
||||
**Arguments**
|
||||
|
||||
- `keys` — Given key array to create a map from. The nested type of array must be: [String](../data-types/string.md), [Integer](../data-types/int-uint.md), [LowCardinality](../data-types/lowcardinality.md), [FixedString](../data-types/fixedstring.md), [UUID](../data-types/uuid.md), [Date](../data-types/date.md), [DateTime](../data-types/datetime.md), [Date32](../data-types/date32.md), [Enum](../data-types/enum.md)
|
||||
- `values` - Given value array or map to create a map from.
|
||||
- `keys` — Array of keys to create the map from. [Array(T)](../data-types/array.md) where `T` can be any type supported by [Map](../data-types/map.md) as key type.
|
||||
- `values` - Array or map of values to create the map from. [Array](../data-types/array.md) or [Map](../data-types/map.md).
|
||||
|
||||
**Returned value**
|
||||
|
||||
- A map whose keys and values are constructed from the key array and value array/map.
|
||||
- A map with keys and values constructed from the key array and value array/map.
|
||||
|
||||
**Example**
|
||||
|
||||
@ -94,14 +75,25 @@ Query:
|
||||
|
||||
```sql
|
||||
select mapFromArrays(['a', 'b', 'c'], [1, 2, 3])
|
||||
```
|
||||
|
||||
Result:
|
||||
|
||||
```
|
||||
┌─mapFromArrays(['a', 'b', 'c'], [1, 2, 3])─┐
|
||||
│ {'a':1,'b':2,'c':3} │
|
||||
└───────────────────────────────────────────┘
|
||||
```
|
||||
|
||||
`mapFromArrays` also accepts arguments of type [Map](../data-types/map.md). These are casted to array of tuples during execution.
|
||||
|
||||
```sql
|
||||
SELECT mapFromArrays([1, 2, 3], map('a', 1, 'b', 2, 'c', 3))
|
||||
```
|
||||
|
||||
Result:
|
||||
|
||||
```
|
||||
┌─mapFromArrays([1, 2, 3], map('a', 1, 'b', 2, 'c', 3))─┐
|
||||
│ {1:('a',1),2:('b',2),3:('c',3)} │
|
||||
└───────────────────────────────────────────────────────┘
|
||||
@ -109,9 +101,11 @@ SELECT mapFromArrays([1, 2, 3], map('a', 1, 'b', 2, 'c', 3))
|
||||
|
||||
## extractKeyValuePairs
|
||||
|
||||
Extracts key-value pairs, i.e. a [Map(String, String)](../data-types/map.md), from a string. Parsing is robust towards noise (e.g. log files).
|
||||
|
||||
A key-value pair consists of a key, followed by a `key_value_delimiter` and a value. Key value pairs must be separated by `pair_delimiter`. Quoted keys and values are also supported.
|
||||
Converts a string of key-value pairs to a [Map(String, String)](../data-types/map.md).
|
||||
Parsing is tolerant towards noise (e.g. log files).
|
||||
Key-value pairs in the input string consist of a key, followed by a key-value delimiter, and a value.
|
||||
Key value pairs are separated by a pair delimiter.
|
||||
Keys and values can be quoted.
|
||||
|
||||
**Syntax**
|
||||
|
||||
@ -126,17 +120,17 @@ Alias:
|
||||
**Arguments**
|
||||
|
||||
- `data` - String to extract key-value pairs from. [String](../data-types/string.md) or [FixedString](../data-types/fixedstring.md).
|
||||
- `key_value_delimiter` - Character to be used as delimiter between the key and the value. Defaults to `:`. [String](../data-types/string.md) or [FixedString](../data-types/fixedstring.md).
|
||||
- `pair_delimiters` - Set of character to be used as delimiters between pairs. Defaults to ` `, `,` and `;`. [String](../data-types/string.md) or [FixedString](../data-types/fixedstring.md).
|
||||
- `quoting_character` - Character to be used as quoting character. Defaults to `"`. [String](../data-types/string.md) or [FixedString](../data-types/fixedstring.md).
|
||||
- `key_value_delimiter` - Single character delimiting keys and values. Defaults to `:`. [String](../data-types/string.md) or [FixedString](../data-types/fixedstring.md).
|
||||
- `pair_delimiters` - Set of character delimiting pairs. Defaults to ` `, `,` and `;`. [String](../data-types/string.md) or [FixedString](../data-types/fixedstring.md).
|
||||
- `quoting_character` - Single character used as quoting character. Defaults to `"`. [String](../data-types/string.md) or [FixedString](../data-types/fixedstring.md).
|
||||
|
||||
**Returned values**
|
||||
|
||||
- A [Map(String, String)](../data-types/map.md) of key-value pairs.
|
||||
- A of key-value pairs. Type: [Map(String, String)](../data-types/map.md)
|
||||
|
||||
**Examples**
|
||||
|
||||
Simple case:
|
||||
Query
|
||||
|
||||
``` sql
|
||||
SELECT extractKeyValuePairs('name:neymar, age:31 team:psg,nationality:brazil') as kv
|
||||
@ -150,7 +144,7 @@ Result:
|
||||
└─────────────────────────────────────────────────────────────────────────┘
|
||||
```
|
||||
|
||||
Single quote as quoting character:
|
||||
With a single quote `'` as quoting character:
|
||||
|
||||
``` sql
|
||||
SELECT extractKeyValuePairs('name:\'neymar\';\'age\':31;team:psg;nationality:brazil,last_key:last_value', ':', ';,', '\'') as kv
|
||||
@ -178,9 +172,29 @@ Result:
|
||||
└────────────────────────┘
|
||||
```
|
||||
|
||||
To restore a map string key-value pairs serialized with `toString`:
|
||||
|
||||
```sql
|
||||
SELECT
|
||||
map('John', '33', 'Paula', '31') AS m,
|
||||
toString(m) as map_serialized,
|
||||
extractKeyValuePairs(map_serialized, ':', ',', '\'') AS map_restored
|
||||
FORMAT Vertical;
|
||||
```
|
||||
|
||||
Result:
|
||||
|
||||
```
|
||||
Row 1:
|
||||
──────
|
||||
m: {'John':'33','Paula':'31'}
|
||||
map_serialized: {'John':'33','Paula':'31'}
|
||||
map_restored: {'John':'33','Paula':'31'}
|
||||
```
|
||||
|
||||
## extractKeyValuePairsWithEscaping
|
||||
|
||||
Same as `extractKeyValuePairs` but with escaping support.
|
||||
Same as `extractKeyValuePairs` but supports escaping.
|
||||
|
||||
Supported escape sequences: `\x`, `\N`, `\a`, `\b`, `\e`, `\f`, `\n`, `\r`, `\t`, `\v` and `\0`.
|
||||
Non standard escape sequences are returned as it is (including the backslash) unless they are one of the following:
|
||||
@ -229,20 +243,6 @@ Arguments are [maps](../data-types/map.md) or [tuples](../data-types/tuple.md#tu
|
||||
|
||||
**Example**
|
||||
|
||||
Query with a tuple:
|
||||
|
||||
```sql
|
||||
SELECT mapAdd(([toUInt8(1), 2], [1, 1]), ([toUInt8(1), 2], [1, 1])) as res, toTypeName(res) as type;
|
||||
```
|
||||
|
||||
Result:
|
||||
|
||||
```text
|
||||
┌─res───────────┬─type───────────────────────────────┐
|
||||
│ ([1,2],[2,2]) │ Tuple(Array(UInt8), Array(UInt64)) │
|
||||
└───────────────┴────────────────────────────────────┘
|
||||
```
|
||||
|
||||
Query with `Map` type:
|
||||
|
||||
```sql
|
||||
@ -257,6 +257,20 @@ Result:
|
||||
└──────────────────────────────┘
|
||||
```
|
||||
|
||||
Query with a tuple:
|
||||
|
||||
```sql
|
||||
SELECT mapAdd(([toUInt8(1), 2], [1, 1]), ([toUInt8(1), 2], [1, 1])) as res, toTypeName(res) as type;
|
||||
```
|
||||
|
||||
Result:
|
||||
|
||||
```text
|
||||
┌─res───────────┬─type───────────────────────────────┐
|
||||
│ ([1,2],[2,2]) │ Tuple(Array(UInt8), Array(UInt64)) │
|
||||
└───────────────┴────────────────────────────────────┘
|
||||
```
|
||||
|
||||
## mapSubtract
|
||||
|
||||
Collect all the keys and subtract corresponding values.
|
||||
@ -277,20 +291,6 @@ Arguments are [maps](../data-types/map.md) or [tuples](../data-types/tuple.md#tu
|
||||
|
||||
**Example**
|
||||
|
||||
Query with a tuple map:
|
||||
|
||||
```sql
|
||||
SELECT mapSubtract(([toUInt8(1), 2], [toInt32(1), 1]), ([toUInt8(1), 2], [toInt32(2), 1])) as res, toTypeName(res) as type;
|
||||
```
|
||||
|
||||
Result:
|
||||
|
||||
```text
|
||||
┌─res────────────┬─type──────────────────────────────┐
|
||||
│ ([1,2],[-1,0]) │ Tuple(Array(UInt8), Array(Int64)) │
|
||||
└────────────────┴───────────────────────────────────┘
|
||||
```
|
||||
|
||||
Query with `Map` type:
|
||||
|
||||
```sql
|
||||
@ -305,55 +305,57 @@ Result:
|
||||
└───────────────────────────────────┘
|
||||
```
|
||||
|
||||
## mapPopulateSeries
|
||||
|
||||
Fills missing keys in the maps (key and value array pair), where keys are integers. Also, it supports specifying the max key, which is used to extend the keys array.
|
||||
|
||||
**Syntax**
|
||||
Query with a tuple map:
|
||||
|
||||
```sql
|
||||
mapPopulateSeries(keys, values[, max])
|
||||
mapPopulateSeries(map[, max])
|
||||
```
|
||||
|
||||
Generates a map (a tuple with two arrays or a value of `Map` type, depending on the arguments), where keys are a series of numbers, from minimum to maximum keys (or `max` argument if it specified) taken from the map with a step size of one, and corresponding values. If the value is not specified for the key, then it uses the default value in the resulting map. For repeated keys, only the first value (in order of appearing) gets associated with the key.
|
||||
|
||||
For array arguments the number of elements in `keys` and `values` must be the same for each row.
|
||||
|
||||
**Arguments**
|
||||
|
||||
Arguments are [maps](../data-types/map.md) or two [arrays](../data-types/array.md#data-type-array), where the first array represent keys, and the second array contains values for the each key.
|
||||
|
||||
Mapped arrays:
|
||||
|
||||
- `keys` — Array of keys. [Array](../data-types/array.md#data-type-array)([Int](../data-types/int-uint.md#uint-ranges)).
|
||||
- `values` — Array of values. [Array](../data-types/array.md#data-type-array)([Int](../data-types/int-uint.md#uint-ranges)).
|
||||
- `max` — Maximum key value. Optional. [Int8, Int16, Int32, Int64, Int128, Int256](../data-types/int-uint.md#int-ranges).
|
||||
|
||||
or
|
||||
|
||||
- `map` — Map with integer keys. [Map](../data-types/map.md).
|
||||
|
||||
**Returned value**
|
||||
|
||||
- Depending on the arguments returns a [map](../data-types/map.md) or a [tuple](../data-types/tuple.md#tuplet1-t2) of two [arrays](../data-types/array.md#data-type-array): keys in sorted order, and values the corresponding keys.
|
||||
|
||||
**Example**
|
||||
|
||||
Query with mapped arrays:
|
||||
|
||||
```sql
|
||||
SELECT mapPopulateSeries([1,2,4], [11,22,44], 5) AS res, toTypeName(res) AS type;
|
||||
SELECT mapSubtract(([toUInt8(1), 2], [toInt32(1), 1]), ([toUInt8(1), 2], [toInt32(2), 1])) as res, toTypeName(res) as type;
|
||||
```
|
||||
|
||||
Result:
|
||||
|
||||
```text
|
||||
┌─res──────────────────────────┬─type──────────────────────────────┐
|
||||
│ ([1,2,3,4,5],[11,22,0,44,0]) │ Tuple(Array(UInt8), Array(UInt8)) │
|
||||
└──────────────────────────────┴───────────────────────────────────┘
|
||||
┌─res────────────┬─type──────────────────────────────┐
|
||||
│ ([1,2],[-1,0]) │ Tuple(Array(UInt8), Array(Int64)) │
|
||||
└────────────────┴───────────────────────────────────┘
|
||||
```
|
||||
|
||||
## mapPopulateSeries
|
||||
|
||||
Fills missing key-value pairs in a map with integer keys.
|
||||
To support extending the keys beyond the largest value, a maximum key can be specified.
|
||||
More specifically, the function returns a map in which the the keys form a series from the smallest to the largest key (or `max` argument if it specified) with step size of 1, and corresponding values.
|
||||
If no value is specified for a key, a default value is used as value.
|
||||
In case keys repeat, only the first value (in order of appearance) is associated with the key.
|
||||
|
||||
**Syntax**
|
||||
|
||||
```sql
|
||||
mapPopulateSeries(map[, max])
|
||||
mapPopulateSeries(keys, values[, max])
|
||||
```
|
||||
|
||||
For array arguments the number of elements in `keys` and `values` must be the same for each row.
|
||||
|
||||
**Arguments**
|
||||
|
||||
Arguments are [Maps](../data-types/map.md) or two [Arrays](../data-types/array.md#data-type-array), where the first and second array contains keys and values for the each key.
|
||||
|
||||
Mapped arrays:
|
||||
|
||||
- `map` — Map with integer keys. [Map](../data-types/map.md).
|
||||
|
||||
or
|
||||
|
||||
- `keys` — Array of keys. [Array](../data-types/array.md#data-type-array)([Int](../data-types/int-uint.md#uint-ranges)).
|
||||
- `values` — Array of values. [Array](../data-types/array.md#data-type-array)([Int](../data-types/int-uint.md#uint-ranges)).
|
||||
- `max` — Maximum key value. Optional. [Int8, Int16, Int32, Int64, Int128, Int256](../data-types/int-uint.md#int-ranges).
|
||||
|
||||
**Returned value**
|
||||
|
||||
- Depending on the arguments a [Map](../data-types/map.md) or a [Tuple](../data-types/tuple.md#tuplet1-t2) of two [Arrays](../data-types/array.md#data-type-array): keys in sorted order, and values the corresponding keys.
|
||||
|
||||
**Example**
|
||||
|
||||
Query with `Map` type:
|
||||
|
||||
```sql
|
||||
@ -368,9 +370,23 @@ Result:
|
||||
└─────────────────────────────────────────┘
|
||||
```
|
||||
|
||||
Query with mapped arrays:
|
||||
|
||||
```sql
|
||||
SELECT mapPopulateSeries([1,2,4], [11,22,44], 5) AS res, toTypeName(res) AS type;
|
||||
```
|
||||
|
||||
Result:
|
||||
|
||||
```text
|
||||
┌─res──────────────────────────┬─type──────────────────────────────┐
|
||||
│ ([1,2,3,4,5],[11,22,0,44,0]) │ Tuple(Array(UInt8), Array(UInt8)) │
|
||||
└──────────────────────────────┴───────────────────────────────────┘
|
||||
```
|
||||
|
||||
## mapContains
|
||||
|
||||
Determines whether the `map` contains the `key` parameter.
|
||||
Returns if a given key is contained in a given map.
|
||||
|
||||
**Syntax**
|
||||
|
||||
@ -381,7 +397,7 @@ mapContains(map, key)
|
||||
**Arguments**
|
||||
|
||||
- `map` — Map. [Map](../data-types/map.md).
|
||||
- `key` — Key. Type matches the type of keys of `map` parameter.
|
||||
- `key` — Key. Type must match the key type of `map`.
|
||||
|
||||
**Returned value**
|
||||
|
||||
@ -392,11 +408,11 @@ mapContains(map, key)
|
||||
Query:
|
||||
|
||||
```sql
|
||||
CREATE TABLE test (a Map(String,String)) ENGINE = Memory;
|
||||
CREATE TABLE tab (a Map(String, String)) ENGINE = Memory;
|
||||
|
||||
INSERT INTO test VALUES ({'name':'eleven','age':'11'}), ({'number':'twelve','position':'6.0'});
|
||||
INSERT INTO tab VALUES ({'name':'eleven','age':'11'}), ({'number':'twelve','position':'6.0'});
|
||||
|
||||
SELECT mapContains(a, 'name') FROM test;
|
||||
SELECT mapContains(a, 'name') FROM tab;
|
||||
|
||||
```
|
||||
|
||||
@ -411,9 +427,11 @@ Result:
|
||||
|
||||
## mapKeys
|
||||
|
||||
Returns all keys from the `map` parameter.
|
||||
Returns the keys of a given map.
|
||||
|
||||
Can be optimized by enabling the [optimize_functions_to_subcolumns](../../operations/settings/settings.md#optimize-functions-to-subcolumns) setting. With `optimize_functions_to_subcolumns = 1` the function reads only [keys](../data-types/map.md#map-subcolumns) subcolumn instead of reading and processing the whole column data. The query `SELECT mapKeys(m) FROM table` transforms to `SELECT m.keys FROM table`.
|
||||
This function can be optimized by enabling setting [optimize_functions_to_subcolumns](../../operations/settings/settings.md#optimize-functions-to-subcolumns).
|
||||
With enabled setting, the function only reads the [keys](../data-types/map.md#map-subcolumns) subcolumn instead the whole map.
|
||||
The query `SELECT mapKeys(m) FROM table` is transformed to `SELECT m.keys FROM table`.
|
||||
|
||||
**Syntax**
|
||||
|
||||
@ -434,11 +452,11 @@ mapKeys(map)
|
||||
Query:
|
||||
|
||||
```sql
|
||||
CREATE TABLE test (a Map(String,String)) ENGINE = Memory;
|
||||
CREATE TABLE tab (a Map(String, String)) ENGINE = Memory;
|
||||
|
||||
INSERT INTO test VALUES ({'name':'eleven','age':'11'}), ({'number':'twelve','position':'6.0'});
|
||||
INSERT INTO tab VALUES ({'name':'eleven','age':'11'}), ({'number':'twelve','position':'6.0'});
|
||||
|
||||
SELECT mapKeys(a) FROM test;
|
||||
SELECT mapKeys(a) FROM tab;
|
||||
```
|
||||
|
||||
Result:
|
||||
@ -452,9 +470,11 @@ Result:
|
||||
|
||||
## mapValues
|
||||
|
||||
Returns all values from the `map` parameter.
|
||||
Returns the values of a given map.
|
||||
|
||||
Can be optimized by enabling the [optimize_functions_to_subcolumns](../../operations/settings/settings.md#optimize-functions-to-subcolumns) setting. With `optimize_functions_to_subcolumns = 1` the function reads only [values](../data-types/map.md#map-subcolumns) subcolumn instead of reading and processing the whole column data. The query `SELECT mapValues(m) FROM table` transforms to `SELECT m.values FROM table`.
|
||||
This function can be optimized by enabling setting [optimize_functions_to_subcolumns](../../operations/settings/settings.md#optimize-functions-to-subcolumns).
|
||||
With enabled setting, the function only reads the [values](../data-types/map.md#map-subcolumns) subcolumn instead the whole map.
|
||||
The query `SELECT mapValues(m) FROM table` is transformed to `SELECT m.values FROM table`.
|
||||
|
||||
**Syntax**
|
||||
|
||||
@ -475,11 +495,11 @@ mapValues(map)
|
||||
Query:
|
||||
|
||||
```sql
|
||||
CREATE TABLE test (a Map(String,String)) ENGINE = Memory;
|
||||
CREATE TABLE tab (a Map(String, String)) ENGINE = Memory;
|
||||
|
||||
INSERT INTO test VALUES ({'name':'eleven','age':'11'}), ({'number':'twelve','position':'6.0'});
|
||||
INSERT INTO tab VALUES ({'name':'eleven','age':'11'}), ({'number':'twelve','position':'6.0'});
|
||||
|
||||
SELECT mapValues(a) FROM test;
|
||||
SELECT mapValues(a) FROM tab;
|
||||
```
|
||||
|
||||
Result:
|
||||
@ -512,11 +532,11 @@ mapContainsKeyLike(map, pattern)
|
||||
Query:
|
||||
|
||||
```sql
|
||||
CREATE TABLE test (a Map(String,String)) ENGINE = Memory;
|
||||
CREATE TABLE tab (a Map(String, String)) ENGINE = Memory;
|
||||
|
||||
INSERT INTO test VALUES ({'abc':'abc','def':'def'}), ({'hij':'hij','klm':'klm'});
|
||||
INSERT INTO tab VALUES ({'abc':'abc','def':'def'}), ({'hij':'hij','klm':'klm'});
|
||||
|
||||
SELECT mapContainsKeyLike(a, 'a%') FROM test;
|
||||
SELECT mapContainsKeyLike(a, 'a%') FROM tab;
|
||||
```
|
||||
|
||||
Result:
|
||||
@ -530,6 +550,8 @@ Result:
|
||||
|
||||
## mapExtractKeyLike
|
||||
|
||||
Give a map with string keys and a LIKE pattern, this function returns a map with elements where the key matches the pattern.
|
||||
|
||||
**Syntax**
|
||||
|
||||
```sql
|
||||
@ -543,18 +565,18 @@ mapExtractKeyLike(map, pattern)
|
||||
|
||||
**Returned value**
|
||||
|
||||
- A map contained elements the key of which matches the specified pattern. If there are no elements matched the pattern, it will return an empty map.
|
||||
- A map containing elements the key matching the specified pattern. If no elements match the pattern, an empty map is returned.
|
||||
|
||||
**Example**
|
||||
|
||||
Query:
|
||||
|
||||
```sql
|
||||
CREATE TABLE test (a Map(String,String)) ENGINE = Memory;
|
||||
CREATE TABLE tab (a Map(String, String)) ENGINE = Memory;
|
||||
|
||||
INSERT INTO test VALUES ({'abc':'abc','def':'def'}), ({'hij':'hij','klm':'klm'});
|
||||
INSERT INTO tab VALUES ({'abc':'abc','def':'def'}), ({'hij':'hij','klm':'klm'});
|
||||
|
||||
SELECT mapExtractKeyLike(a, 'a%') FROM test;
|
||||
SELECT mapExtractKeyLike(a, 'a%') FROM tab;
|
||||
```
|
||||
|
||||
Result:
|
||||
@ -568,6 +590,8 @@ Result:
|
||||
|
||||
## mapApply
|
||||
|
||||
Applies a function to each element of a map.
|
||||
|
||||
**Syntax**
|
||||
|
||||
```sql
|
||||
@ -608,6 +632,8 @@ Result:
|
||||
|
||||
## mapFilter
|
||||
|
||||
Filters a map by applying a function to each map element.
|
||||
|
||||
**Syntax**
|
||||
|
||||
```sql
|
||||
@ -623,7 +649,6 @@ mapFilter(func, map)
|
||||
|
||||
- Returns a map containing only the elements in `map` for which `func(map1[i], ..., mapN[i])` returns something other than 0.
|
||||
|
||||
|
||||
**Example**
|
||||
|
||||
Query:
|
||||
@ -647,7 +672,6 @@ Result:
|
||||
└─────────────────────┘
|
||||
```
|
||||
|
||||
|
||||
## mapUpdate
|
||||
|
||||
**Syntax**
|
||||
@ -683,6 +707,9 @@ Result:
|
||||
|
||||
## mapConcat
|
||||
|
||||
Concatenates multiple maps based on the equality of their keys.
|
||||
If elements with the same key exist in more than one input map, all elements are added to the result map, but only the first one is accessible via operator `[]`
|
||||
|
||||
**Syntax**
|
||||
|
||||
```sql
|
||||
@ -691,11 +718,11 @@ mapConcat(maps)
|
||||
|
||||
**Arguments**
|
||||
|
||||
- `maps` – Arbitrary number of arguments of [Map](../data-types/map.md) type.
|
||||
- `maps` – Arbitrarily many [Maps](../data-types/map.md).
|
||||
|
||||
**Returned value**
|
||||
|
||||
- Returns a map with concatenated maps passed as arguments. If there are same keys in two or more maps, all of them are added to the result map, but only the first one is accessible via operator `[]`
|
||||
- Returns a map with concatenated maps passed as arguments.
|
||||
|
||||
**Examples**
|
||||
|
||||
@ -729,9 +756,12 @@ Result:
|
||||
|
||||
## mapExists(\[func,\], map)
|
||||
|
||||
Returns 1 if there is at least one key-value pair in `map` for which `func(key, value)` returns something other than 0. Otherwise, it returns 0.
|
||||
Returns 1 if at least one key-value pair in `map` exists for which `func(key, value)` returns something other than 0. Otherwise, it returns 0.
|
||||
|
||||
Note that the `mapExists` is a [higher-order function](../../sql-reference/functions/index.md#higher-order-functions). You can pass a lambda function to it as the first argument.
|
||||
:::note
|
||||
`mapExists` is a [higher-order function](../../sql-reference/functions/index.md#higher-order-functions).
|
||||
You can pass a lambda function to it as the first argument.
|
||||
:::
|
||||
|
||||
**Example**
|
||||
|
||||
@ -743,7 +773,7 @@ SELECT mapExists((k, v) -> (v = 1), map('k1', 1, 'k2', 2)) AS res
|
||||
|
||||
Result:
|
||||
|
||||
```text
|
||||
```
|
||||
┌─res─┐
|
||||
│ 1 │
|
||||
└─────┘
|
||||
@ -753,7 +783,10 @@ Result:
|
||||
|
||||
Returns 1 if `func(key, value)` returns something other than 0 for all key-value pairs in `map`. Otherwise, it returns 0.
|
||||
|
||||
Note that the `mapAll` is a [higher-order function](../../sql-reference/functions/index.md#higher-order-functions). You can pass a lambda function to it as the first argument.
|
||||
:::note
|
||||
Note that the `mapAll` is a [higher-order function](../../sql-reference/functions/index.md#higher-order-functions).
|
||||
You can pass a lambda function to it as the first argument.
|
||||
:::
|
||||
|
||||
**Example**
|
||||
|
||||
@ -765,7 +798,7 @@ SELECT mapAll((k, v) -> (v = 1), map('k1', 1, 'k2', 2)) AS res
|
||||
|
||||
Result:
|
||||
|
||||
```text
|
||||
```
|
||||
┌─res─┐
|
||||
│ 0 │
|
||||
└─────┘
|
||||
@ -773,7 +806,8 @@ Result:
|
||||
|
||||
## mapSort(\[func,\], map)
|
||||
|
||||
Sorts the elements of the `map` in ascending order. If the `func` function is specified, sorting order is determined by the result of the `func` function applied to the keys and values of the map.
|
||||
Sorts the elements of a map in ascending order.
|
||||
If the `func` function is specified, the sorting order is determined by the result of the `func` function applied to the keys and values of the map.
|
||||
|
||||
**Examples**
|
||||
|
||||
@ -801,8 +835,8 @@ For more details see the [reference](../../sql-reference/functions/array-functio
|
||||
|
||||
## mapReverseSort(\[func,\], map)
|
||||
|
||||
Sorts the elements of the `map` in descending order. If the `func` function is specified, sorting order is determined by the result of the `func` function applied to the keys and values of the map.
|
||||
|
||||
Sorts the elements of a map in descending order.
|
||||
If the `func` function is specified, the sorting order is determined by the result of the `func` function applied to the keys and values of the map.
|
||||
|
||||
**Examples**
|
||||
|
||||
@ -826,4 +860,4 @@ SELECT mapReverseSort((k, v) -> v, map('key2', 2, 'key3', 1, 'key1', 3)) AS map;
|
||||
└──────────────────────────────┘
|
||||
```
|
||||
|
||||
For more details see the [reference](../../sql-reference/functions/array-functions.md#array_functions-reverse-sort) for `arrayReverseSort` function.
|
||||
For more details see function [arrayReverseSort](../../sql-reference/functions/array-functions.md#array_functions-reverse-sort).
|
||||
|
||||
@ -598,7 +598,7 @@ DataTypePtr QueryFuzzer::fuzzDataType(DataTypePtr type)
|
||||
{
|
||||
auto key_type = fuzzDataType(type_map->getKeyType());
|
||||
auto value_type = fuzzDataType(type_map->getValueType());
|
||||
if (!DataTypeMap::checkKeyType(key_type))
|
||||
if (!DataTypeMap::isValidKeyType(key_type))
|
||||
key_type = type_map->getKeyType();
|
||||
|
||||
return std::make_shared<DataTypeMap>(key_type, value_type);
|
||||
|
||||
@ -66,11 +66,8 @@ DataTypeMap::DataTypeMap(const DataTypePtr & key_type_, const DataTypePtr & valu
|
||||
|
||||
void DataTypeMap::assertKeyType() const
|
||||
{
|
||||
if (!checkKeyType(key_type))
|
||||
throw Exception(ErrorCodes::BAD_ARGUMENTS,
|
||||
"Type of Map key must be a type, that can be represented by integer "
|
||||
"or String or FixedString (possibly LowCardinality) or UUID or IPv6,"
|
||||
" but {} given", key_type->getName());
|
||||
if (!isValidKeyType(key_type))
|
||||
throw Exception(ErrorCodes::BAD_ARGUMENTS, "Map cannot have a key of type {}", key_type->getName());
|
||||
}
|
||||
|
||||
|
||||
@ -116,7 +113,7 @@ bool DataTypeMap::equals(const IDataType & rhs) const
|
||||
return nested->equals(*rhs_map.nested);
|
||||
}
|
||||
|
||||
bool DataTypeMap::checkKeyType(DataTypePtr key_type)
|
||||
bool DataTypeMap::isValidKeyType(DataTypePtr key_type)
|
||||
{
|
||||
return !isNullableOrLowCardinalityNullable(key_type);
|
||||
}
|
||||
|
||||
@ -52,7 +52,7 @@ public:
|
||||
|
||||
SerializationPtr doGetDefaultSerialization() const override;
|
||||
|
||||
static bool checkKeyType(DataTypePtr key_type);
|
||||
static bool isValidKeyType(DataTypePtr key_type);
|
||||
|
||||
void forEachChild(const ChildCallback & callback) const override;
|
||||
|
||||
|
||||
@ -1222,7 +1222,7 @@ namespace
|
||||
return nullptr;
|
||||
|
||||
auto key_type = removeNullable(key_types.back());
|
||||
if (!DataTypeMap::checkKeyType(key_type))
|
||||
if (!DataTypeMap::isValidKeyType(key_type))
|
||||
return nullptr;
|
||||
|
||||
return std::make_shared<DataTypeMap>(key_type, value_types.back());
|
||||
|
||||
@ -10,8 +10,6 @@ set -eo pipefail
|
||||
|
||||
# Run the client.
|
||||
$CLICKHOUSE_CLIENT --multiquery <<EOF
|
||||
SET allow_experimental_map_type = 1;
|
||||
|
||||
DROP TABLE IF EXISTS map_protobuf_00825;
|
||||
|
||||
CREATE TABLE map_protobuf_00825
|
||||
|
||||
@ -59,7 +59,6 @@ for NAME in $(find "$DATA_DIR"/*.parquet -print0 | xargs -0 -n 1 basename | LC_A
|
||||
|
||||
${CLICKHOUSE_CLIENT} --query="DROP TABLE IF EXISTS parquet_load"
|
||||
$CLICKHOUSE_CLIENT --multiquery <<EOF
|
||||
SET allow_experimental_map_type = 1;
|
||||
CREATE TABLE parquet_load ($COLUMNS) ENGINE = Memory;
|
||||
EOF
|
||||
|
||||
|
||||
@ -7,7 +7,6 @@ CUR_DIR=$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)
|
||||
|
||||
${CLICKHOUSE_CLIENT} --query="DROP TABLE IF EXISTS maps"
|
||||
${CLICKHOUSE_CLIENT} --multiquery <<EOF
|
||||
SET allow_experimental_map_type = 1;
|
||||
CREATE TABLE maps (m1 Map(UInt32, UInt32), m2 Map(String, String), m3 Map(UInt32, Tuple(UInt32, UInt32)), m4 Map(UInt32, Array(UInt32)), m5 Array(Map(UInt32, UInt32)), m6 Tuple(Map(UInt32, UInt32), Map(String, String)), m7 Array(Map(UInt32, Array(Tuple(Map(UInt32, UInt32), Tuple(UInt32)))))) ENGINE=Memory();
|
||||
EOF
|
||||
|
||||
|
||||
@ -1,18 +1,18 @@
|
||||
drop table if exists map_test;
|
||||
create table map_test engine=TinyLog() as (select ([1, number], [toInt32(2),2]) as map from numbers(1, 10));
|
||||
drop table if exists tab;
|
||||
create table tab engine=Memory() as (select ([1, number], [toInt32(2),2]) as map from numbers(1, 10));
|
||||
|
||||
-- mapAdd
|
||||
select mapAdd([1], [1]); -- { serverError ILLEGAL_TYPE_OF_ARGUMENT }
|
||||
select mapAdd(([1], [1])); -- { serverError NUMBER_OF_ARGUMENTS_DOESNT_MATCH }
|
||||
select mapAdd(([1], [1]), map) from map_test; -- { serverError ILLEGAL_TYPE_OF_ARGUMENT }
|
||||
select mapAdd(([toUInt64(1)], [1]), map) from map_test; -- { serverError ILLEGAL_TYPE_OF_ARGUMENT }
|
||||
select mapAdd(([toUInt64(1), 2], [toInt32(1)]), map) from map_test; -- {serverError NUMBER_OF_ARGUMENTS_DOESNT_MATCH }
|
||||
select mapAdd(([1], [1]), map) from tab; -- { serverError ILLEGAL_TYPE_OF_ARGUMENT }
|
||||
select mapAdd(([toUInt64(1)], [1]), map) from tab; -- { serverError ILLEGAL_TYPE_OF_ARGUMENT }
|
||||
select mapAdd(([toUInt64(1), 2], [toInt32(1)]), map) from tab; -- {serverError NUMBER_OF_ARGUMENTS_DOESNT_MATCH }
|
||||
|
||||
select mapAdd(([toUInt64(1)], [toInt32(1)]), map) from map_test;
|
||||
select mapAdd(cast(map, 'Tuple(Array(UInt8), Array(UInt8))'), ([1], [1]), ([2],[2]) ) from map_test;
|
||||
select mapAdd(([toUInt64(1)], [toInt32(1)]), map) from tab;
|
||||
select mapAdd(cast(map, 'Tuple(Array(UInt8), Array(UInt8))'), ([1], [1]), ([2],[2]) ) from tab;
|
||||
|
||||
-- cleanup
|
||||
drop table map_test;
|
||||
drop table tab;
|
||||
|
||||
-- check types
|
||||
select mapAdd(([toUInt8(1), 2], [1, 1]), ([toUInt8(1), 2], [1, 1])) as res, toTypeName(res);
|
||||
|
||||
@ -31,6 +31,7 @@
|
||||
{1:2,2:2} Map(Int128, Int128)
|
||||
{1:2,2:2} Map(Int256, Int256)
|
||||
{1:3.300000023841858,2:2} Map(UInt8, Float64)
|
||||
{'ab':3.300000023841858,'cd':2} Map(String, Float64)
|
||||
{1:3.3000000000000003,2:2} Map(UInt8, Float64)
|
||||
{'a':1,'b':2}
|
||||
{'a':1,'b':1,'c':1}
|
||||
|
||||
@ -1,16 +1,15 @@
|
||||
drop table if exists mapop_test;
|
||||
set allow_experimental_map_type = 1;
|
||||
create table mapop_test engine=TinyLog() as (select map(1, toInt32(2), number, 2) as m from numbers(1, 10));
|
||||
drop table if exists tab;
|
||||
create table tab engine=Memory() as (select map(1, toInt32(2), number, 2) as m from numbers(1, 10));
|
||||
|
||||
-- mapAdd
|
||||
select mapAdd(map(1, 1)); -- { serverError NUMBER_OF_ARGUMENTS_DOESNT_MATCH }
|
||||
select mapAdd(map(1, 1), m) from mapop_test; -- { serverError ILLEGAL_TYPE_OF_ARGUMENT }
|
||||
select mapAdd(map(1, 1), m) from tab; -- { serverError ILLEGAL_TYPE_OF_ARGUMENT }
|
||||
|
||||
select mapAdd(map(toUInt64(1), toInt32(1)), m) from mapop_test;
|
||||
select mapAdd(cast(m, 'Map(UInt8, UInt8)'), map(1, 1), map(2,2)) from mapop_test;
|
||||
select mapAdd(map(toUInt64(1), toInt32(1)), m) from tab;
|
||||
select mapAdd(cast(m, 'Map(UInt8, UInt8)'), map(1, 1), map(2,2)) from tab;
|
||||
|
||||
-- cleanup
|
||||
drop table mapop_test;
|
||||
drop table tab;
|
||||
|
||||
-- check types
|
||||
select mapAdd(map(toUInt8(1), 1, 2, 1), map(toUInt8(1), 1, 2, 1)) as res, toTypeName(res);
|
||||
@ -28,6 +27,8 @@ select mapAdd(map(toInt128(1), toInt128(1), 2, 1), map(toInt128(1), toInt128(1),
|
||||
select mapAdd(map(toInt256(1), toInt256(1), 2, 1), map(toInt256(1), toInt256(1), 2, 1)) as res, toTypeName(res);
|
||||
|
||||
select mapAdd(map(1, toFloat32(1.1), 2, 1), map(1, 2.2, 2, 1)) as res, toTypeName(res);
|
||||
select mapAdd(map(1.0, toFloat32(1.1), 2.0, 1), map(1.0, 2.2, 2.0, 1)) as res, toTypeName(res); -- { serverError ILLEGAL_TYPE_OF_ARGUMENT }
|
||||
select mapAdd(map(toLowCardinality('ab'), toFloat32(1.1), toLowCardinality('cd'), 1), map(toLowCardinality('ab'), 2.2, toLowCardinality('cd'), 1)) as res, toTypeName(res);
|
||||
select mapAdd(map(1, toFloat64(1.1), 2, 1), map(1, 2.2, 2, 1)) as res, toTypeName(res);
|
||||
select mapAdd(map(1, toFloat64(1.1), 2, 1), map(1, 1, 2, 1)) as res, toTypeName(res); -- { serverError ILLEGAL_TYPE_OF_ARGUMENT }
|
||||
select mapAdd(map('a', 1, 'b', 1), map(key, 1)) from values('key String', ('b'), ('c'), ('d'));
|
||||
|
||||
@ -48,7 +48,6 @@ WHERE (type = 'QueryFinish') AND (lower(query) LIKE lower('SELECT n.null FROM %t
|
||||
AND current_database = currentDatabase();
|
||||
|
||||
SELECT '====map====';
|
||||
SET allow_experimental_map_type = 1;
|
||||
DROP TABLE IF EXISTS t_map;
|
||||
CREATE TABLE t_map (m Map(String, UInt32)) ENGINE = MergeTree ORDER BY tuple() SETTINGS min_bytes_for_wide_part = 0;
|
||||
INSERT INTO t_map VALUES (map('a', 1, 'b', 2)) (map('a', 3, 'c', 4)), (map('b', 5, 'c', 6));
|
||||
|
||||
@ -19,7 +19,6 @@ DROP TABLE null_subcolumns;
|
||||
DROP TABLE IF EXISTS map_subcolumns;
|
||||
|
||||
SELECT 'Map';
|
||||
SET allow_experimental_map_type = 1;
|
||||
CREATE TABLE map_subcolumns (id UInt32, m Map(String, UInt32)) ENGINE = MergeTree ORDER BY id;
|
||||
INSERT INTO map_subcolumns VALUES (1, map('a', 1, 'b', 2)) (2, map('a', 3, 'c', 4)), (3, map('b', 5, 'c', 6, 'd', 7));
|
||||
|
||||
|
||||
@ -18,7 +18,7 @@ declare -a ENGINES=("Log" "TinyLog" "Memory" \
|
||||
for engine in "${ENGINES[@]}"; do
|
||||
echo $engine
|
||||
$CLICKHOUSE_CLIENT --query "DROP TABLE IF EXISTS subcolumns"
|
||||
$CLICKHOUSE_CLIENT --query "$create_query ENGINE = $engine" --allow_experimental_map_type 1
|
||||
$CLICKHOUSE_CLIENT --query "$create_query ENGINE = $engine"
|
||||
$CLICKHOUSE_CLIENT --query "INSERT INTO subcolumns VALUES (100, [1, 2, 3], [[[1, 2], [], [4]], [[5, 6], [7, 8]], [[]]], [1, NULL, 2], ('foo', 200), map('foo', 1, 'bar', 42))"
|
||||
$CLICKHOUSE_CLIENT --query "SELECT * FROM subcolumns"
|
||||
$CLICKHOUSE_CLIENT --query "SELECT n, n.null, a1, a1.size0, a2, a2.size0, a2.size1, a2.size2, a3, a3.size0, a3.null, t, t.s, t.v, m, m.keys, m.values FROM subcolumns"
|
||||
|
||||
@ -1,5 +1,3 @@
|
||||
set allow_experimental_map_type = 1;
|
||||
|
||||
-- String type
|
||||
drop table if exists table_map;
|
||||
create table table_map (a Map(String, String)) engine = Memory;
|
||||
|
||||
@ -1,4 +1,3 @@
|
||||
SET allow_experimental_map_type = 1;
|
||||
SET output_format_write_statistics = 0;
|
||||
|
||||
DROP TABLE IF EXISTS map_formats;
|
||||
|
||||
@ -5,7 +5,7 @@ CURDIR=$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)
|
||||
. "$CURDIR"/../shell_config.sh
|
||||
|
||||
$CLICKHOUSE_CLIENT -q "DROP TABLE IF EXISTS map_formats_input"
|
||||
$CLICKHOUSE_CLIENT -q "CREATE TABLE map_formats_input (m Map(String, UInt32), m1 Map(String, Date), m2 Map(String, Array(UInt32))) ENGINE = Log;" --allow_experimental_map_type 1
|
||||
$CLICKHOUSE_CLIENT -q "CREATE TABLE map_formats_input (m Map(String, UInt32), m1 Map(String, Date), m2 Map(String, Array(UInt32))) ENGINE = Log;"
|
||||
|
||||
$CLICKHOUSE_CLIENT -q "INSERT INTO map_formats_input FORMAT JSONEachRow" <<< '{"m":{"k1":1,"k2":2,"k3":3},"m1":{"k1":"2020-05-05"},"m2":{"k1":[],"k2":[7,8]}}'
|
||||
$CLICKHOUSE_CLIENT -q "SELECT * FROM map_formats_input"
|
||||
|
||||
@ -1,5 +1,3 @@
|
||||
set allow_experimental_map_type = 1;
|
||||
|
||||
select length(map(1,2,3,4));
|
||||
select length(map());
|
||||
select empty(map(1,2,3,4));
|
||||
|
||||
@ -26,8 +26,8 @@
|
||||
{'aa':4,'bb':5} 1 0
|
||||
{0.1:4,0.2:5} [0.1,0.2] [4,5]
|
||||
{0.1:4,0.2:5} 1 0
|
||||
{0.1:4,0.2:5} [0.1,0.2] [4,5]
|
||||
{0.1:4,0.2:5} 1 0
|
||||
{1:4,2:5} [1,2] [4,5]
|
||||
{1:4,2:5} 1 0 1 0
|
||||
{[1,2]:4,[3,4]:5} [[1,2],[3,4]] [4,5]
|
||||
{[1,2]:4,[3,4]:5} 1 0
|
||||
{{1:2}:4,{3:4}:5} [{1:2},{3:4}] [4,5]
|
||||
@ -39,6 +39,9 @@
|
||||
{'aa':4,'bb':5}
|
||||
{'aa':4,'bb':5}
|
||||
{'aa':4,'bb':5}
|
||||
{1:4,2:5}
|
||||
{1:4,2:5}
|
||||
{1:4,2:5}
|
||||
{'aa':4,'bb':5}
|
||||
{'aa':4,'bb':5}
|
||||
{'aa':4,'bb':5}
|
||||
@ -46,3 +49,6 @@
|
||||
{'aa':('a',4),'bb':('b',5)}
|
||||
{'aa':('a',4),'bb':('b',5)}
|
||||
{'aa':('a',4),'bb':('b',5)}
|
||||
{1:4,2:5}
|
||||
{1:4,2:5}
|
||||
{1:4,2:5}
|
||||
|
||||
@ -1,6 +1,4 @@
|
||||
set allow_experimental_map_type = 1;
|
||||
|
||||
-- String type
|
||||
-- Map(String, String)
|
||||
drop table if exists table_map;
|
||||
create table table_map (a Map(String, String), b String, c Array(String), d Array(String)) engine = Memory;
|
||||
insert into table_map values ({'name':'zhangsan', 'age':'10'}, 'name', ['name', 'age'], ['zhangsan', '10']), ({'name':'lisi', 'gender':'female'},'age',['name', 'gender'], ['lisi', 'female']);
|
||||
@ -11,9 +9,10 @@ select mapContains(a, b) from table_map;
|
||||
select mapContains(a, 10) from table_map; -- { serverError NO_COMMON_TYPE }
|
||||
select mapKeys(a) from table_map;
|
||||
select mapFromArrays(c, d) from table_map;
|
||||
drop table if exists table_map;
|
||||
drop table table_map;
|
||||
|
||||
CREATE TABLE table_map (a Map(UInt8, Int), b UInt8, c UInt32, d Array(String), e Array(String)) engine = MergeTree order by tuple();
|
||||
-- Map(UInt8, UInt8)
|
||||
create table table_map (a Map(UInt8, Int), b UInt8, c UInt32, d Array(String), e Array(String)) engine = MergeTree order by tuple();
|
||||
insert into table_map select map(number, number), number, number, [number, number, number], [number*2, number*3, number*4] from numbers(1000, 3);
|
||||
select mapContains(a, b), mapContains(a, c), mapContains(a, 233) from table_map;
|
||||
select mapContains(a, 'aaa') from table_map; -- { serverError NO_COMMON_TYPE }
|
||||
@ -21,37 +20,59 @@ select mapContains(b, 'aaa') from table_map; -- { serverError ILLEGAL_TYPE_OF_AR
|
||||
select mapKeys(a) from table_map;
|
||||
select mapValues(a) from table_map;
|
||||
select mapFromArrays(d, e) from table_map;
|
||||
drop table if exists table_map;
|
||||
drop table table_map;
|
||||
|
||||
|
||||
-- Const column
|
||||
select map( 'aa', 4, 'bb' , 5) as m, mapKeys(m), mapValues(m);
|
||||
select map( 'aa', 4, 'bb' , 5) as m, mapContains(m, 'aa'), mapContains(m, 'k');
|
||||
-- Map(String, UInt8)
|
||||
select map('aa', 4, 'bb' , 5) as m, mapKeys(m), mapValues(m);
|
||||
select map('aa', 4, 'bb' , 5) as m, mapContains(m, 'aa'), mapContains(m, 'k');
|
||||
|
||||
-- Map(Float32, UInt8)
|
||||
select map(0.1::Float32, 4, 0.2::Float32, 5) as m, mapKeys(m), mapValues(m);
|
||||
select map(0.1::Float32, 4, 0.2::Float32, 5) as m, mapContains(m, 0.1::Float32), mapContains(m, 0.3::Float32);
|
||||
select map(0.1::Float64, 4, 0.2::Float64, 5) as m, mapKeys(m), mapValues(m);
|
||||
select map(0.1::Float64, 4, 0.2::Float64, 5) as m, mapContains(m, 0.1::Float64), mapContains(m, 0.3::Float64);
|
||||
|
||||
-- Map(LowCardinality(UInt8), UInt8)
|
||||
set allow_suspicious_low_cardinality_types = 1;
|
||||
select map(1::LowCardinality(UInt8), 4, 2::LowCardinality(UInt8), 5) as m, mapKeys(m), mapValues(m);
|
||||
select map(1::LowCardinality(UInt8), 4, 2::LowCardinality(UInt8), 5) as m, mapContains(m, 1), mapContains (m, 3), mapContains(m, 1::LowCardinality(UInt8)), mapContains(m, 3::LowCardinality(UInt8));
|
||||
|
||||
-- Map(Array(UInt8), UInt8)
|
||||
select map(array(1,2), 4, array(3,4), 5) as m, mapKeys(m), mapValues(m);
|
||||
select map(array(1,2), 4, array(3,4), 5) as m, mapContains(m, array(1,2)), mapContains(m, array(1,3));
|
||||
|
||||
-- Map(Map(UInt8, UInt8), UInt8)
|
||||
select map(map(1,2), 4, map(3,4), 5) as m, mapKeys(m), mapValues(m);
|
||||
select map(map(1,2), 4, map(3,4), 5) as m, mapContains(m, map(1,2)), mapContains(m, map(1,3));
|
||||
|
||||
-- Map(Tuple(UInt8, UInt8), UInt8)
|
||||
select map(tuple(1,2), 4, tuple(3,4), 5) as m, mapKeys(m), mapValues(m);
|
||||
select map(tuple(1,2), 4, tuple(3,4), 5) as m, mapContains(m, tuple(1,2)), mapContains(m, tuple(1,3));
|
||||
|
||||
|
||||
select map(0, 0) as m, mapContains(m, number % 2) from numbers(2);
|
||||
|
||||
select mapFromArrays(['aa', 'bb'], [4, 5]);
|
||||
select mapFromArrays(['aa', 'bb'], materialize([4, 5])) from numbers(2);
|
||||
|
||||
select mapFromArrays([1.0, 2.0], [4, 5]);
|
||||
select mapFromArrays([1.0, 2.0], materialize([4, 5])) from numbers(2);
|
||||
|
||||
select mapFromArrays(materialize(['aa', 'bb']), [4, 5]) from numbers(2);
|
||||
select mapFromArrays(materialize(['aa', 'bb']), materialize([4, 5])) from numbers(2);
|
||||
|
||||
select mapFromArrays('aa', [4, 5]); -- { serverError ILLEGAL_TYPE_OF_ARGUMENT }
|
||||
select mapFromArrays(['aa', 'bb'], 5); -- { serverError ILLEGAL_TYPE_OF_ARGUMENT }
|
||||
select mapFromArrays(['aa', 'bb'], [4, 5], [6, 7]); -- { serverError NUMBER_OF_ARGUMENTS_DOESNT_MATCH }
|
||||
select mapFromArrays(['aa', 'bb'], [4, 5, 6]); -- { serverError SIZES_OF_ARRAYS_DONT_MATCH }
|
||||
select mapFromArrays([[1,2], [3,4]], [4, 5, 6]); -- { serverError SIZES_OF_ARRAYS_DONT_MATCH }
|
||||
select mapFromArrays(['a', 2], [4, 5]); -- { serverError NO_COMMON_TYPE}
|
||||
select mapFromArrays([1, 2], [4, 'a']); -- { serverError NO_COMMON_TYPE}
|
||||
|
||||
select mapFromArrays(['aa', 'bb'], map('a', 4, 'b', 5));
|
||||
select mapFromArrays(['aa', 'bb'], materialize(map('a', 4, 'b', 5))) from numbers(2);
|
||||
|
||||
select mapFromArrays(map('a', 4, 'b', 4), ['aa', 'bb']) from numbers(2); -- { serverError ILLEGAL_TYPE_OF_ARGUMENT }
|
||||
select mapFromArrays(['aa', 'bb'], map('a', 4)); -- { serverError SIZES_OF_ARRAYS_DONT_MATCH }
|
||||
|
||||
select mapFromArrays([toLowCardinality(1), toLowCardinality(2)], [4, 5]);
|
||||
select mapFromArrays([toLowCardinality(1), toLowCardinality(2)], materialize([4, 5])) from numbers(2);
|
||||
|
||||
@ -45,8 +45,6 @@ DROP TABLE test_tuple_nested_in_array_nested_in_tuple;
|
||||
|
||||
SELECT 'Tuple nested in Map';
|
||||
|
||||
SET allow_experimental_map_type = 1;
|
||||
|
||||
DROP TABLE IF EXISTS test_tuple_nested_in_map;
|
||||
CREATE TABLE test_tuple_nested_in_map (value Map(String, Tuple(UInt8, UInt8))) ENGINE=TinyLog;
|
||||
|
||||
|
||||
@ -1,5 +1,3 @@
|
||||
SET allow_experimental_map_type = 1;
|
||||
|
||||
DROP TABLE IF EXISTS table_map_with_key_integer;
|
||||
|
||||
CREATE TABLE table_map_with_key_integer (d DATE, m Map(Int8, Int8))
|
||||
|
||||
@ -1,5 +1,4 @@
|
||||
DROP TABLE IF EXISTS map_lc;
|
||||
SET allow_experimental_map_type = 1;
|
||||
CREATE TABLE map_lc
|
||||
(
|
||||
`kv` Map(LowCardinality(String), LowCardinality(String))
|
||||
|
||||
@ -1,7 +1,5 @@
|
||||
DROP TABLE IF EXISTS t_map_null;
|
||||
|
||||
SET allow_experimental_map_type = 1;
|
||||
|
||||
CREATE TABLE t_map_null (a Map(String, String), b String) engine = MergeTree() ORDER BY a;
|
||||
INSERT INTO t_map_null VALUES (map('a', 'b', 'c', 'd'), 'foo');
|
||||
SELECT count() FROM t_map_null WHERE a = map('name', NULL, '', NULL);
|
||||
|
||||
@ -1,5 +1,4 @@
|
||||
SET send_logs_level = 'fatal';
|
||||
SET allow_experimental_map_type = 1;
|
||||
|
||||
DROP TABLE IF EXISTS map_comb;
|
||||
CREATE TABLE map_comb(a int, statusMap Map(UInt16, UInt32)) ENGINE = Log;
|
||||
|
||||
@ -1,6 +1,5 @@
|
||||
DROP TABLE IF EXISTS t_func_to_subcolumns;
|
||||
|
||||
SET allow_experimental_map_type = 1;
|
||||
SET optimize_functions_to_subcolumns = 1;
|
||||
|
||||
CREATE TABLE t_func_to_subcolumns (id UInt64, arr Array(UInt64), n Nullable(String), m Map(String, UInt64))
|
||||
|
||||
@ -15,5 +15,4 @@ $$, 10, 5, 3) limit 2;
|
||||
|
||||
select * apply toJSONString from t;
|
||||
|
||||
set allow_experimental_map_type = 1;
|
||||
select toJSONString(map('1234', '5678'));
|
||||
|
||||
@ -1,6 +1,5 @@
|
||||
-- { echo }
|
||||
drop table if exists map_test;
|
||||
set allow_experimental_map_type = 1;
|
||||
create table map_test engine=TinyLog() as (select (number + 1) as n, map(1, 1, number,2) as m from numbers(1, 5));
|
||||
select mapPopulateSeries(m) from map_test;
|
||||
{1:1}
|
||||
|
||||
@ -1,6 +1,5 @@
|
||||
-- { echo }
|
||||
drop table if exists map_test;
|
||||
set allow_experimental_map_type = 1;
|
||||
create table map_test engine=TinyLog() as (select (number + 1) as n, map(1, 1, number,2) as m from numbers(1, 5));
|
||||
|
||||
select mapPopulateSeries(m) from map_test;
|
||||
|
||||
@ -1,5 +1,3 @@
|
||||
SET allow_experimental_map_type = 1;
|
||||
|
||||
DROP TABLE IF EXISTS t_map_int_key;
|
||||
CREATE TABLE t_map_int_key (m1 Map(UInt32, UInt32), m2 Map(Date, UInt32)) ENGINE = Memory;
|
||||
|
||||
|
||||
@ -9,6 +9,7 @@
|
||||
1
|
||||
1
|
||||
1
|
||||
1
|
||||
0
|
||||
{'aa':NULL}
|
||||
{}
|
||||
|
||||
@ -12,6 +12,7 @@ SELECT id, map FROM map_containsKeyLike_test WHERE mapContainsKeyLike(map, '3-%'
|
||||
DROP TABLE map_containsKeyLike_test;
|
||||
|
||||
SELECT mapContainsKeyLike(map('aa', 1, 'bb', 2), 'a%');
|
||||
SELECT mapContainsKeyLike(map(toLowCardinality('aa'), 1, toLowCardinality('b'), 2), 'a%');
|
||||
SELECT mapContainsKeyLike(map('aa', 1, 'bb', 2), materialize('a%'));
|
||||
SELECT mapContainsKeyLike(materialize(map('aa', 1, 'bb', 2)), 'a%');
|
||||
SELECT mapContainsKeyLike(materialize(map('aa', 1, 'bb', 2)), materialize('a%'));
|
||||
|
||||
@ -36,6 +36,11 @@
|
||||
1
|
||||
1
|
||||
1
|
||||
0
|
||||
0
|
||||
0
|
||||
0
|
||||
0
|
||||
{0.1:4,0.2:5}
|
||||
{0.1:4,0.2:5}
|
||||
{[1,2]:4,[3,4]:5}
|
||||
@ -76,6 +81,20 @@
|
||||
0
|
||||
0
|
||||
0
|
||||
0
|
||||
0
|
||||
0
|
||||
0
|
||||
0
|
||||
0
|
||||
0
|
||||
0
|
||||
0
|
||||
0
|
||||
0
|
||||
0
|
||||
0
|
||||
0
|
||||
{'key2':101,'key3':100,'key4':102}
|
||||
{'key2':102,'key3':101,'key4':103}
|
||||
{'key2':103,'key3':102,'key4':104}
|
||||
@ -102,6 +121,8 @@
|
||||
{1:2,2:3}
|
||||
{'x':'y','x':'y'}
|
||||
{'x':'y','x':'y'}
|
||||
{1:2,2:3}
|
||||
{1:2,2:3}
|
||||
{'k1':11,'k2':22}
|
||||
{'k1':11,'k2':22}
|
||||
{'k1':11,'k2':22}
|
||||
|
||||
@ -21,6 +21,12 @@ SELECT mapExists((k, v) -> k = array(1,2), map(array(1,2), 4, array(3,4), 5));
|
||||
SELECT mapExists((k, v) -> k = map(1,2), map(map(1,2), 4, map(3,4), 5));
|
||||
SELECT mapExists((k, v) -> k = tuple(1,2), map(tuple(1,2), 4, tuple(3,4), 5));
|
||||
|
||||
SELECT mapAll((k, v) -> k = 0.1::Float32, map(0.1::Float32, 4, 0.2::Float32, 5));
|
||||
SELECT mapAll((k, v) -> k = 0.1::Float64, map(0.1::Float64, 4, 0.2::Float64, 5));
|
||||
SELECT mapAll((k, v) -> k = array(1,2), map(array(1,2), 4, array(3,4), 5));
|
||||
SELECT mapAll((k, v) -> k = map(1,2), map(map(1,2), 4, map(3,4), 5));
|
||||
SELECT mapAll((k, v) -> k = tuple(1,2), map(tuple(1,2), 4, tuple(3,4), 5));
|
||||
|
||||
SELECT mapSort((k, v) -> k, map(0.1::Float32, 4, 0.2::Float32, 5));
|
||||
SELECT mapSort((k, v) -> k, map(0.1::Float64, 4, 0.2::Float64, 5));
|
||||
SELECT mapSort((k, v) -> k, map(array(1,2), 4, array(3,4), 5));
|
||||
@ -41,6 +47,9 @@ SELECT mapConcat(map(tuple(1,2), 4), map(tuple(3,4), 5));
|
||||
SELECT mapExists((k, v) -> k LIKE '%3', col) FROM table_map ORDER BY id;
|
||||
SELECT mapExists((k, v) -> k LIKE '%2' AND v < 1000, col) FROM table_map ORDER BY id;
|
||||
|
||||
SELECT mapAll((k, v) -> k LIKE '%3', col) FROM table_map ORDER BY id;
|
||||
SELECT mapAll((k, v) -> k LIKE '%2' AND v < 1000, col) FROM table_map ORDER BY id;
|
||||
|
||||
SELECT mapSort(col) FROM table_map ORDER BY id;
|
||||
SELECT mapSort((k, v) -> v, col) FROM table_map ORDER BY id;
|
||||
SELECT mapPartialSort((k, v) -> k, 2, col) FROM table_map ORDER BY id;
|
||||
@ -50,6 +59,8 @@ SELECT mapApply((x, y) -> (x, x + 1), map(1, 0, 2, 0));
|
||||
SELECT mapApply((x, y) -> (x, x + 1), materialize(map(1, 0, 2, 0)));
|
||||
SELECT mapApply((x, y) -> ('x', 'y'), map(1, 0, 2, 0));
|
||||
SELECT mapApply((x, y) -> ('x', 'y'), materialize(map(1, 0, 2, 0)));
|
||||
SELECT mapApply((x, y) -> (x, x + 1), map(1.0, 0, 2.0, 0));
|
||||
SELECT mapApply((x, y) -> (x, x + 1), materialize(map(1.0, 0, 2.0, 0)));
|
||||
|
||||
SELECT mapUpdate(map('k1', 1, 'k2', 2), map('k1', 11, 'k2', 22));
|
||||
SELECT mapUpdate(materialize(map('k1', 1, 'k2', 2)), map('k1', 11, 'k2', 22));
|
||||
|
||||
@ -9,6 +9,6 @@ ENGINE = Memory;
|
||||
INSERT INTO data_a_02187
|
||||
SELECT *
|
||||
FROM system.one
|
||||
SETTINGS max_block_size = '1', min_insert_block_size_rows = '65536', min_insert_block_size_bytes = '0', max_insert_threads = '0', max_threads = '3', receive_timeout = '10', receive_data_timeout_ms = '10000', connections_with_failover_max_tries = '0', extremes = '1', use_uncompressed_cache = '0', optimize_move_to_prewhere = '1', optimize_move_to_prewhere_if_final = '0', replication_alter_partitions_sync = '2', totals_mode = 'before_having', allow_suspicious_low_cardinality_types = '1', compile_expressions = '1', min_count_to_compile_expression = '0', group_by_two_level_threshold = '100', distributed_aggregation_memory_efficient = '0', distributed_group_by_no_merge = '1', optimize_distributed_group_by_sharding_key = '1', optimize_skip_unused_shards = '1', optimize_skip_unused_shards_rewrite_in = '1', force_optimize_skip_unused_shards = '2', optimize_skip_unused_shards_nesting = '1', force_optimize_skip_unused_shards_nesting = '2', merge_tree_min_rows_for_concurrent_read = '10000', force_primary_key = '1', network_compression_method = 'ZSTD', network_zstd_compression_level = '7', log_queries = '0', log_queries_min_type = 'QUERY_FINISH', distributed_product_mode = 'local', insert_quorum = '2', insert_quorum_timeout = '0', insert_quorum_parallel = '0', select_sequential_consistency = '1', join_use_nulls = '1', any_join_distinct_right_table_keys = '1', preferred_max_column_in_block_size_bytes = '32', distributed_foreground_insert = '1', insert_allow_materialized_columns = '1', use_index_for_in_with_subqueries = '1', joined_subquery_requires_alias = '0', empty_result_for_aggregation_by_empty_set = '1', allow_suspicious_codecs = '1', query_profiler_real_time_period_ns = '0', query_profiler_cpu_time_period_ns = '0', opentelemetry_start_trace_probability = '1', max_rows_to_read = '1000000', read_overflow_mode = 'break', max_rows_to_group_by = '10', group_by_overflow_mode = 'any', max_rows_to_sort = '100', sort_overflow_mode = 'break', max_result_rows = '10', max_execution_time = '3', max_execution_speed = '1', max_bytes_in_join = '100', join_algorithm = 'partial_merge', max_memory_usage = '1099511627776', log_query_threads = '1', send_logs_level = 'fatal', enable_optimize_predicate_expression = '1', prefer_localhost_replica = '1', optimize_read_in_order = '1', optimize_aggregation_in_order = '1', read_in_order_two_level_merge_threshold = '1', allow_introspection_functions = '1', check_query_single_value_result = '1', allow_experimental_live_view = '1', default_table_engine = 'Memory', mutations_sync = '2', convert_query_to_cnf = '0', optimize_arithmetic_operations_in_aggregate_functions = '1', optimize_duplicate_order_by_and_distinct = '0', optimize_multiif_to_if = '0', optimize_functions_to_subcolumns = '1', optimize_using_constraints = '1', optimize_substitute_columns = '1', optimize_append_index = '1', transform_null_in = '1', data_type_default_nullable = '1', cast_keep_nullable = '1', cast_ipv4_ipv6_default_on_conversion_error = '0', system_events_show_zero_values = '1', enable_global_with_statement = '1', optimize_on_insert = '0', optimize_rewrite_sum_if_to_count_if = '1', distributed_ddl_output_mode = 'throw', union_default_mode = 'ALL', optimize_aggregators_of_group_by_keys = '1', optimize_group_by_function_keys = '1', short_circuit_function_evaluation = 'enable', async_insert = '1', enable_filesystem_cache = '0', allow_deprecated_database_ordinary = '1', allow_deprecated_syntax_for_merge_tree = '1', allow_experimental_nlp_functions = '1', allow_experimental_object_type = '1', allow_experimental_map_type = '1', optimize_use_projections = '1', input_format_null_as_default = '1', input_format_ipv4_default_on_conversion_error = '0', input_format_ipv6_default_on_conversion_error = '0', output_format_json_named_tuples_as_objects = '1', output_format_write_statistics = '0', output_format_pretty_row_numbers = '1';
|
||||
SETTINGS max_block_size = '1', min_insert_block_size_rows = '65536', min_insert_block_size_bytes = '0', max_insert_threads = '0', max_threads = '3', receive_timeout = '10', receive_data_timeout_ms = '10000', connections_with_failover_max_tries = '0', extremes = '1', use_uncompressed_cache = '0', optimize_move_to_prewhere = '1', optimize_move_to_prewhere_if_final = '0', replication_alter_partitions_sync = '2', totals_mode = 'before_having', allow_suspicious_low_cardinality_types = '1', compile_expressions = '1', min_count_to_compile_expression = '0', group_by_two_level_threshold = '100', distributed_aggregation_memory_efficient = '0', distributed_group_by_no_merge = '1', optimize_distributed_group_by_sharding_key = '1', optimize_skip_unused_shards = '1', optimize_skip_unused_shards_rewrite_in = '1', force_optimize_skip_unused_shards = '2', optimize_skip_unused_shards_nesting = '1', force_optimize_skip_unused_shards_nesting = '2', merge_tree_min_rows_for_concurrent_read = '10000', force_primary_key = '1', network_compression_method = 'ZSTD', network_zstd_compression_level = '7', log_queries = '0', log_queries_min_type = 'QUERY_FINISH', distributed_product_mode = 'local', insert_quorum = '2', insert_quorum_timeout = '0', insert_quorum_parallel = '0', select_sequential_consistency = '1', join_use_nulls = '1', any_join_distinct_right_table_keys = '1', preferred_max_column_in_block_size_bytes = '32', distributed_foreground_insert = '1', insert_allow_materialized_columns = '1', use_index_for_in_with_subqueries = '1', joined_subquery_requires_alias = '0', empty_result_for_aggregation_by_empty_set = '1', allow_suspicious_codecs = '1', query_profiler_real_time_period_ns = '0', query_profiler_cpu_time_period_ns = '0', opentelemetry_start_trace_probability = '1', max_rows_to_read = '1000000', read_overflow_mode = 'break', max_rows_to_group_by = '10', group_by_overflow_mode = 'any', max_rows_to_sort = '100', sort_overflow_mode = 'break', max_result_rows = '10', max_execution_time = '3', max_execution_speed = '1', max_bytes_in_join = '100', join_algorithm = 'partial_merge', max_memory_usage = '1099511627776', log_query_threads = '1', send_logs_level = 'fatal', enable_optimize_predicate_expression = '1', prefer_localhost_replica = '1', optimize_read_in_order = '1', optimize_aggregation_in_order = '1', read_in_order_two_level_merge_threshold = '1', allow_introspection_functions = '1', check_query_single_value_result = '1', allow_experimental_live_view = '1', default_table_engine = 'Memory', mutations_sync = '2', convert_query_to_cnf = '0', optimize_arithmetic_operations_in_aggregate_functions = '1', optimize_duplicate_order_by_and_distinct = '0', optimize_multiif_to_if = '0', optimize_functions_to_subcolumns = '1', optimize_using_constraints = '1', optimize_substitute_columns = '1', optimize_append_index = '1', transform_null_in = '1', data_type_default_nullable = '1', cast_keep_nullable = '1', cast_ipv4_ipv6_default_on_conversion_error = '0', system_events_show_zero_values = '1', enable_global_with_statement = '1', optimize_on_insert = '0', optimize_rewrite_sum_if_to_count_if = '1', distributed_ddl_output_mode = 'throw', union_default_mode = 'ALL', optimize_aggregators_of_group_by_keys = '1', optimize_group_by_function_keys = '1', short_circuit_function_evaluation = 'enable', async_insert = '1', enable_filesystem_cache = '0', allow_deprecated_database_ordinary = '1', allow_deprecated_syntax_for_merge_tree = '1', allow_experimental_nlp_functions = '1', allow_experimental_object_type = '1', optimize_use_projections = '1', input_format_null_as_default = '1', input_format_ipv4_default_on_conversion_error = '0', input_format_ipv6_default_on_conversion_error = '0', output_format_json_named_tuples_as_objects = '1', output_format_write_statistics = '0', output_format_pretty_row_numbers = '1';
|
||||
|
||||
DROP TABLE data_a_02187;
|
||||
|
||||
@ -0,0 +1,8 @@
|
||||
Map(Nothing, ...) is non-comparable --> not usable as primary key
|
||||
But Map(Nothing, ...) can be a non-primary-key, it is quite useless though ...
|
||||
Map(Float32, ...) and Map(LC(String)) are okay as primary key
|
||||
{1:'a'} {'b':'b'}
|
||||
{2:'aa'} {'bb':'bb'}
|
||||
Map(Float32, ...) and Map(LC(String)) as non-primary-key
|
||||
{1:'a'} {'b':'b'}
|
||||
{3:'aaa'} {'bb':'bb'}
|
||||
@ -0,0 +1,33 @@
|
||||
-- Tests maps with "unusual" key types (Float32, Nothing, LowCardinality(String))
|
||||
|
||||
SET mutations_sync = 2;
|
||||
|
||||
DROP TABLE IF EXISTS tab;
|
||||
|
||||
SELECT 'Map(Nothing, ...) is non-comparable --> not usable as primary key';
|
||||
CREATE TABLE tab (m1 Map(Nothing, String)) ENGINE = MergeTree ORDER BY m1; -- { serverError DATA_TYPE_CANNOT_BE_USED_IN_KEY }
|
||||
|
||||
SELECT 'But Map(Nothing, ...) can be a non-primary-key, it is quite useless though ...';
|
||||
CREATE TABLE tab (m3 Map(Nothing, String)) ENGINE = MergeTree ORDER BY tuple();
|
||||
-- INSERT INTO tab VALUES (map('', 'd')); -- { serverError NOT_IMPLEMENTED } -- The client can't serialize the data and fails. The query
|
||||
-- doesn't reach the server and we can't check via 'serverError' :-/
|
||||
DROP TABLE tab;
|
||||
|
||||
SELECT 'Map(Float32, ...) and Map(LC(String)) are okay as primary key';
|
||||
CREATE TABLE tab (m1 Map(Float32, String), m2 Map(LowCardinality(String), String)) ENGINE = MergeTree ORDER BY (m1, m2);
|
||||
INSERT INTO tab VALUES (map(1.0, 'a'), map('b', 'b'));
|
||||
INSERT INTO tab VALUES (map(2.0, 'aa'), map('bb', 'bb'));
|
||||
|
||||
-- Test merge
|
||||
OPTIMIZE TABLE tab FINAL;
|
||||
SELECT * FROM tab ORDER BY m1, m2;
|
||||
|
||||
DROP TABLE tab;
|
||||
|
||||
SELECT 'Map(Float32, ...) and Map(LC(String)) as non-primary-key';
|
||||
CREATE TABLE tab (m1 Map(Float32, String), m2 Map(LowCardinality(String), String)) ENGINE = MergeTree ORDER BY tuple();
|
||||
INSERT INTO tab VALUES (map(1.0, 'a'), map('b', 'b')), (map(2.0, 'aa'), map('bb', 'bb'));
|
||||
ALTER TABLE tab UPDATE m1 = map(3.0, 'aaa') WHERE m1 = map(2.0, 'aa');
|
||||
SELECT * FROM tab ORDER BY m1, m2;
|
||||
|
||||
DROP TABLE tab;
|
||||
Loading…
Reference in New Issue
Block a user