Merge pull request ClickHouse#78171 from UnamedRus/mapContainsValuesLike

Add mapContainsValuesLike/mapContainsValues/mapExtractValuesLike functions

Author: vdimir

ci/jobs/scripts/check_style/aspell-ignore/en/aspell-dict.txt

@@ -2209,9 +2209,13 @@ mapAll
 mapApply
 mapConcat
 mapContains
+mapContainsKey
 mapContainsKeyLike
+mapContainsValue
+mapContainsValueLike
 mapExists
 mapExtractKeyLike
+mapExtractValueLike
 mapFilter
 mapFromArrays
 mapKeys

docs/en/sql-reference/functions/tuple-map-functions.md

@@ -398,6 +398,50 @@ Result:
 └──────────────────────────────┴───────────────────────────────────┘
 ```
 
+
+## mapKeys {#mapkeys}
+
+Returns the keys of a given map.
+
+This function can be optimized by enabling setting [optimize_functions_to_subcolumns](/operations/settings/settings#optimize_functions_to_subcolumns).
+With enabled setting, the function only reads the [keys](/sql-reference/data-types/map#reading-subcolumns-of-map) subcolumn instead the whole map.
+The query `SELECT mapKeys(m) FROM table` is transformed to `SELECT m.keys FROM table`.
+
+**Syntax**
+
+```sql
+mapKeys(map)
+```
+
+**Arguments**
+
+- `map` — Map. [Map](../data-types/map.md).
+
+**Returned value**
+
+- Array containing all keys from the `map`. [Array](../data-types/array.md).
+
+**Example**
+
+Query:
+
+```sql
+CREATE TABLE tab (a Map(String, String)) ENGINE = Memory;
+
+INSERT INTO tab VALUES ({'name':'eleven','age':'11'}), ({'number':'twelve','position':'6.0'});
+
+SELECT mapKeys(a) FROM tab;
+```
+
+Result:
+
+```text
+┌─mapKeys(a)────────────┐
+│ ['name','age']        │
+│ ['number','position'] │
+└───────────────────────┘
+```
+
 ## mapContains {#mapcontains}
 
 Returns if a given key is contained in a given map.
@@ -408,6 +452,8 @@ Returns if a given key is contained in a given map.
 mapContains(map, key)
 ```
 
+Alias: `mapContainsKey(map, key)`
+
 **Arguments**
 
 - `map` — Map. [Map](../data-types/map.md).
@@ -439,27 +485,62 @@ Result:
 └────────────────────────┘
 ```
 
-## mapKeys {#mapkeys}
 
-Returns the keys of a given map.
+## mapContainsKeyLike {#mapcontainskeylike}
 
-This function can be optimized by enabling setting [optimize_functions_to_subcolumns](/operations/settings/settings#optimize_functions_to_subcolumns).
-With enabled setting, the function only reads the [keys](/sql-reference/data-types/map#reading-subcolumns-of-map) subcolumn instead the whole map.
-The query `SELECT mapKeys(m) FROM table` is transformed to `SELECT m.keys FROM table`.
+**Syntax**
+
+```sql
+mapContainsKeyLike(map, pattern)
+```
+
+**Arguments**
+- `map` — Map. [Map](../data-types/map.md).
+- `pattern`  - String pattern to match.
+
+**Returned value**
+
+- `1` if `map` contains `key` like specified pattern, `0` if not.
+
+**Example**
+
+Query:
+
+```sql
+CREATE TABLE tab (a Map(String, String)) ENGINE = Memory;
+
+INSERT INTO tab VALUES ({'abc':'abc','def':'def'}), ({'hij':'hij','klm':'klm'});
+
+SELECT mapContainsKeyLike(a, 'a%') FROM tab;
+```
+
+Result:
+
+```text
+┌─mapContainsKeyLike(a, 'a%')─┐
+│                           1 │
+│                           0 │
+└─────────────────────────────┘
+```
+
+## mapExtractKeyLike {#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
-mapKeys(map)
+mapExtractKeyLike(map, pattern)
 ```
 
 **Arguments**
 
 - `map` — Map. [Map](../data-types/map.md).
+- `pattern`  - String pattern to match.
 
 **Returned value**
 
-- Array containing all keys from the `map`. [Array](../data-types/array.md).
+- A map containing elements the key matching the specified pattern. If no elements match the pattern, an empty map is returned.
 
 **Example**
 
@@ -468,20 +549,21 @@ Query:
 ```sql
 CREATE TABLE tab (a Map(String, String)) ENGINE = Memory;
 
-INSERT INTO tab VALUES ({'name':'eleven','age':'11'}), ({'number':'twelve','position':'6.0'});
+INSERT INTO tab VALUES ({'abc':'abc','def':'def'}), ({'hij':'hij','klm':'klm'});
 
-SELECT mapKeys(a) FROM tab;
+SELECT mapExtractKeyLike(a, 'a%') FROM tab;
 ```
 
 Result:
 
 ```text
-┌─mapKeys(a)────────────┐
-│ ['name','age']        │
-│ ['number','position'] │
-└───────────────────────┘
+┌─mapExtractKeyLike(a, 'a%')─┐
+│ {'abc':'abc'}              │
+│ {}                         │
+└────────────────────────────┘
 ```
 
+
 ## mapValues {#mapvalues}
 
 Returns the values of a given map.
@@ -525,12 +607,55 @@ Result:
 └──────────────────┘
 ```
 
-## mapContainsKeyLike {#mapcontainskeylike}
+## mapContainsValue {#mapcontainsvalue}
+
+Returns if a given key is contained in a given map.
 
 **Syntax**
 
 ```sql
-mapContainsKeyLike(map, pattern)
+mapContainsValue(map, value)
+```
+
+Alias: `mapContainsValue(map, value)`
+
+**Arguments**
+
+- `map` — Map. [Map](../data-types/map.md).
+- `value` — Value. Type must match the value type of `map`.
+
+**Returned value**
+
+- `1` if `map` contains `value`, `0` if not. [UInt8](../data-types/int-uint.md).
+
+**Example**
+
+Query:
+
+```sql
+CREATE TABLE tab (a Map(String, String)) ENGINE = Memory;
+
+INSERT INTO tab VALUES ({'name':'eleven','age':'11'}), ({'number':'twelve','position':'6.0'});
+
+SELECT mapContainsValue(a, '11') FROM tab;
+
+```
+
+Result:
+
+```text
+┌─mapContainsValue(a, '11')─┐
+│                         1 │
+│                         0 │
+└───────────────────────────┘
+```
+
+## mapContainsValueLike {#mapcontainsvaluelike}
+
+**Syntax**
+
+```sql
+mapContainsValueLike(map, pattern)
 ```
 
 **Arguments**
@@ -539,7 +664,7 @@ mapContainsKeyLike(map, pattern)
 
 **Returned value**
 
-- `1` if `map` contains `key` like specified pattern, `0` if not.
+- `1` if `map` contains `value` like specified pattern, `0` if not.
 
 **Example**
 
@@ -550,26 +675,26 @@ CREATE TABLE tab (a Map(String, String)) ENGINE = Memory;
 
 INSERT INTO tab VALUES ({'abc':'abc','def':'def'}), ({'hij':'hij','klm':'klm'});
 
-SELECT mapContainsKeyLike(a, 'a%') FROM tab;
+SELECT mapContainsValueLike(a, 'a%') FROM tab;
 ```
 
 Result:
 
 ```text
-┌─mapContainsKeyLike(a, 'a%')─┐
-│                           1 │
-│                           0 │
-└─────────────────────────────┘
+┌─mapContainsV⋯ke(a, 'a%')─┐
+│                        1 │
+│                        0 │
+└──────────────────────────┘
 ```
 
-## mapExtractKeyLike {#mapextractkeylike}
+## mapExtractValueLike {#mapextractvaluelike}
 
-Give a map with string keys and a LIKE pattern, this function returns a map with elements where the key matches the pattern.
+Give a map with string values and a LIKE pattern, this function returns a map with elements where the value matches the pattern.
 
 **Syntax**
 
 ```sql
-mapExtractKeyLike(map, pattern)
+mapExtractValueLike(map, pattern)
 ```
 
 **Arguments**
@@ -579,7 +704,7 @@ mapExtractKeyLike(map, pattern)
 
 **Returned value**
 
-- A map containing elements the key matching the specified pattern. If no elements match the pattern, an empty map is returned.
+- A map containing elements the value matching the specified pattern. If no elements match the pattern, an empty map is returned.
 
 **Example**
 
@@ -590,16 +715,16 @@ CREATE TABLE tab (a Map(String, String)) ENGINE = Memory;
 
 INSERT INTO tab VALUES ({'abc':'abc','def':'def'}), ({'hij':'hij','klm':'klm'});
 
-SELECT mapExtractKeyLike(a, 'a%') FROM tab;
+SELECT mapExtractValueLike(a, 'a%') FROM tab;
 ```
 
 Result:
 
 ```text
-┌─mapExtractKeyLike(a, 'a%')─┐
-│ {'abc':'abc'}              │
-│ {}                         │
-└────────────────────────────┘
+┌─mapExtractValueLike(a, 'a%')─┐
+│ {'abc':'abc'}                │
+│ {}                           │
+└──────────────────────────────┘
 ```
 
 ## mapApply {#mapapply}

src/Analyzer/Passes/FunctionToSubcolumnsPass.cpp

@@ -185,10 +185,10 @@ std::map<std::pair<TypeIndex, String>, NodeToSubcolumnTransformer> node_transfor
         },
     },
     {
-        {TypeIndex::Map, "mapContains"},
+        {TypeIndex::Map, "mapContainsKey"},
         [](QueryTreeNodePtr &, FunctionNode & function_node, ColumnContext & ctx)
         {
-            /// Replace `mapContains(map_argument, argument)` with `has(map_argument.keys, argument)`
+            /// Replace `mapContainsKey(map_argument, argument)` with `has(map_argument.keys, argument)`
             const auto & data_type_map = assert_cast<const DataTypeMap &>(*ctx.column.type);
 
             NameAndTypePair column{ctx.column.name + ".keys", std::make_shared<DataTypeArray>(data_type_map.getKeyType())};