ClickHouse/docs/en/sql-reference/functions/string-functions.md

2535 lines
61 KiB
Markdown
Raw Normal View History

2020-04-03 13:23:32 +00:00
---
2022-08-28 14:53:34 +00:00
slug: /en/sql-reference/functions/string-functions
2023-04-19 17:05:55 +00:00
sidebar_position: 170
sidebar_label: Strings
2020-04-03 13:23:32 +00:00
---
import VersionBadge from '@theme/badges/VersionBadge';
2022-06-02 10:55:18 +00:00
# Functions for Working with Strings
2023-04-20 10:08:49 +00:00
Functions for [searching](string-search-functions.md) in strings and for [replacing](string-replace-functions.md) in strings are described separately.
2020-06-19 10:09:45 +00:00
2022-06-02 10:55:18 +00:00
## empty
2017-04-03 19:49:50 +00:00
2024-07-05 21:47:11 +00:00
Checks whether the input string is empty. A string is considered non-empty if it contains at least one byte, even if this byte is a space or the null byte.
2023-04-19 20:04:59 +00:00
The function is also available for [arrays](array-functions.md#function-empty) and [UUIDs](uuid-functions.md#empty).
2021-08-03 13:07:46 +00:00
**Syntax**
``` sql
empty(x)
```
**Arguments**
- `x` — Input value. [String](../data-types/string.md).
2021-08-03 13:07:46 +00:00
**Returned value**
2024-05-23 13:48:20 +00:00
- Returns `1` for an empty string or `0` for a non-empty string. [UInt8](../data-types/int-uint.md).
2021-08-03 13:07:46 +00:00
**Example**
```sql
SELECT empty('');
```
Result:
2023-04-19 20:04:59 +00:00
```result
2021-08-03 13:07:46 +00:00
┌─empty('')─┐
│ 1 │
└───────────┘
```
2017-04-03 19:49:50 +00:00
2022-06-02 10:55:18 +00:00
## notEmpty
2024-07-05 21:47:11 +00:00
Checks whether the input string is non-empty. A string is considered non-empty if it contains at least one byte, even if this byte is a space or the null byte.
2023-04-19 20:04:59 +00:00
The function is also available for [arrays](array-functions.md#function-notempty) and [UUIDs](uuid-functions.md#notempty).
2021-08-06 09:04:55 +00:00
**Syntax**
``` sql
2021-08-10 10:53:35 +00:00
notEmpty(x)
2021-08-06 09:04:55 +00:00
```
**Arguments**
- `x` — Input value. [String](../data-types/string.md).
2021-08-06 09:04:55 +00:00
**Returned value**
2024-05-23 13:48:20 +00:00
- Returns `1` for a non-empty string or `0` for an empty string string. [UInt8](../data-types/int-uint.md).
2021-08-06 09:04:55 +00:00
**Example**
```sql
2021-08-10 10:53:35 +00:00
SELECT notEmpty('text');
2021-08-06 09:04:55 +00:00
```
Result:
2023-04-19 20:04:59 +00:00
```result
2021-08-10 10:53:35 +00:00
┌─notEmpty('text')─┐
│ 1 │
└──────────────────┘
2021-08-06 09:04:55 +00:00
```
2017-04-03 19:49:50 +00:00
2022-06-02 10:55:18 +00:00
## length
2024-04-24 16:43:44 +00:00
Returns the length of a string in bytes rather than in characters or Unicode code points. The function also works for arrays.
2017-04-03 19:49:50 +00:00
2023-07-17 02:52:05 +00:00
Alias: `OCTET_LENGTH`
2024-04-24 16:43:44 +00:00
**Syntax**
```sql
length(s)
```
**Parameters**
2024-07-05 21:47:11 +00:00
- `s` — An input string or array. [String](../data-types/string)/[Array](../data-types/array).
2024-04-24 16:43:44 +00:00
**Returned value**
2024-04-24 17:54:00 +00:00
- Length of the string or array `s` in bytes. [UInt64](../data-types/int-uint).
2024-04-24 16:43:44 +00:00
**Example**
Query:
```sql
SELECT length('Hello, world!');
```
Result:
```response
┌─length('Hello, world!')─┐
│ 13 │
└─────────────────────────┘
```
Query:
```sql
SELECT length([1, 2, 3, 4]);
```
Result:
```response
┌─length([1, 2, 3, 4])─┐
│ 4 │
└──────────────────────┘
```
2022-06-02 10:55:18 +00:00
## lengthUTF8
2024-04-24 16:43:44 +00:00
Returns the length of a string in Unicode code points rather than in bytes or characters. It assumes that the string contains valid UTF-8 encoded text. If this assumption is violated, no exception is thrown and the result is undefined.
2024-04-24 16:43:44 +00:00
Aliases:
2024-04-03 09:09:35 +00:00
- `CHAR_LENGTH`
2023-04-19 20:04:59 +00:00
- `CHARACTER_LENGTH`
2024-04-24 16:43:44 +00:00
**Syntax**
```sql
lengthUTF8(s)
```
**Parameters**
2024-07-05 21:47:11 +00:00
- `s` — String containing valid UTF-8 encoded text. [String](../data-types/string).
2024-04-24 16:43:44 +00:00
**Returned value**
- Length of the string `s` in Unicode code points. [UInt64](../data-types/int-uint.md).
**Example**
Query:
```sql
SELECT lengthUTF8('Здравствуй, мир!');
```
Result:
```response
┌─lengthUTF8('Здравствуй, мир!')─┐
│ 16 │
└────────────────────────────────┘
```
## left
2024-04-12 10:41:45 +00:00
Returns a substring of string `s` with a specified `offset` starting from the left.
**Syntax**
``` sql
left(s, offset)
```
**Parameters**
2024-07-05 21:47:11 +00:00
- `s` — The string to calculate a substring from. [String](../data-types/string.md) or [FixedString](../data-types/fixedstring.md).
- `offset` — The number of bytes of the offset. [UInt*](../data-types/int-uint).
**Returned value**
- For positive `offset`: A substring of `s` with `offset` many bytes, starting from the left of the string.
- For negative `offset`: A substring of `s` with `length(s) - |offset|` bytes, starting from the left of the string.
- An empty string if `length` is 0.
**Example**
Query:
```sql
SELECT left('Hello', 3);
```
Result:
```response
Hel
```
Query:
```sql
SELECT left('Hello', -3);
```
Result:
```response
He
```
## leftUTF8
2024-04-12 10:41:45 +00:00
Returns a substring of a UTF-8 encoded string `s` with a specified `offset` starting from the left.
**Syntax**
``` sql
leftUTF8(s, offset)
```
**Parameters**
2024-07-05 21:47:11 +00:00
- `s` — The UTF-8 encoded string to calculate a substring from. [String](../data-types/string.md) or [FixedString](../data-types/fixedstring.md).
- `offset` — The number of bytes of the offset. [UInt*](../data-types/int-uint).
**Returned value**
- For positive `offset`: A substring of `s` with `offset` many bytes, starting from the left of the string.
- For negative `offset`: A substring of `s` with `length(s) - |offset|` bytes, starting from the left of the string.
- An empty string if `length` is 0.
**Example**
Query:
```sql
SELECT leftUTF8('Привет', 4);
```
Result:
```response
Прив
```
Query:
```sql
SELECT leftUTF8('Привет', -4);
```
Result:
```response
Пр
```
2022-06-02 10:55:18 +00:00
## leftPad
2021-08-03 18:58:32 +00:00
2023-04-19 20:04:59 +00:00
Pads a string from the left with spaces or with a specified string (multiple times, if needed) until the resulting string reaches the specified `length`.
2021-08-03 18:58:32 +00:00
**Syntax**
``` sql
2023-04-19 20:04:59 +00:00
leftPad(string, length[, pad_string])
2021-08-03 18:58:32 +00:00
```
2023-04-19 20:04:59 +00:00
Alias: `LPAD`
2021-08-03 18:58:32 +00:00
**Arguments**
2023-04-19 20:04:59 +00:00
- `string` — Input string that should be padded. [String](../data-types/string.md).
- `length` — The length of the resulting string. [UInt or Int](../data-types/int-uint.md). If the value is smaller than the input string length, then the input string is shortened to `length` characters.
- `pad_string` — The string to pad the input string with. [String](../data-types/string.md). Optional. If not specified, then the input string is padded with spaces.
2021-08-03 18:58:32 +00:00
2021-08-09 14:29:26 +00:00
**Returned value**
2021-08-03 18:58:32 +00:00
2024-05-23 13:48:20 +00:00
- A left-padded string of the given length. [String](../data-types/string.md).
2021-08-03 18:58:32 +00:00
**Example**
``` sql
SELECT leftPad('abc', 7, '*'), leftPad('def', 7);
2021-08-03 18:58:32 +00:00
```
Result:
2023-04-19 20:04:59 +00:00
```result
┌─leftPad('abc', 7, '*')─┬─leftPad('def', 7)─┐
****abc │ def │
└────────────────────────┴───────────────────┘
2021-08-03 18:58:32 +00:00
```
2022-06-02 10:55:18 +00:00
## leftPadUTF8
2021-08-06 15:03:31 +00:00
2023-04-19 20:04:59 +00:00
Pads the string from the left with spaces or a specified string (multiple times, if needed) until the resulting string reaches the given length. Unlike [leftPad](#leftpad) which measures the string length in bytes, the string length is measured in code points.
2021-08-06 15:03:31 +00:00
**Syntax**
``` sql
2023-04-19 20:04:59 +00:00
leftPadUTF8(string, length[, pad_string])
2021-08-06 15:03:31 +00:00
```
**Arguments**
2023-04-19 20:04:59 +00:00
- `string` — Input string that should be padded. [String](../data-types/string.md).
- `length` — The length of the resulting string. [UInt or Int](../data-types/int-uint.md). If the value is smaller than the input string length, then the input string is shortened to `length` characters.
- `pad_string` — The string to pad the input string with. [String](../data-types/string.md). Optional. If not specified, then the input string is padded with spaces.
2021-08-06 15:03:31 +00:00
2021-08-09 14:29:26 +00:00
**Returned value**
2021-08-06 15:03:31 +00:00
2024-05-23 13:48:20 +00:00
- A left-padded string of the given length. [String](../data-types/string.md).
2021-08-06 15:03:31 +00:00
**Example**
``` sql
SELECT leftPadUTF8('абвг', 7, '*'), leftPadUTF8('дежз', 7);
2021-08-06 15:03:31 +00:00
```
Result:
2023-04-19 20:04:59 +00:00
```result
┌─leftPadUTF8('абвг', 7, '*')─┬─leftPadUTF8('дежз', 7)─┐
***абвг │ дежз │
└─────────────────────────────┴────────────────────────┘
2021-08-06 15:03:31 +00:00
```
## right
2024-04-12 10:41:45 +00:00
Returns a substring of string `s` with a specified `offset` starting from the right.
**Syntax**
``` sql
right(s, offset)
```
**Parameters**
2024-07-05 21:47:11 +00:00
- `s` — The string to calculate a substring from. [String](../data-types/string.md) or [FixedString](../data-types/fixedstring.md).
- `offset` — The number of bytes of the offset. [UInt*](../data-types/int-uint).
**Returned value**
- For positive `offset`: A substring of `s` with `offset` many bytes, starting from the right of the string.
- For negative `offset`: A substring of `s` with `length(s) - |offset|` bytes, starting from the right of the string.
- An empty string if `length` is 0.
**Example**
Query:
```sql
SELECT right('Hello', 3);
```
Result:
```response
llo
```
Query:
```sql
SELECT right('Hello', -3);
```
Result:
```response
lo
```
## rightUTF8
2024-04-12 10:41:45 +00:00
Returns a substring of UTF-8 encoded string `s` with a specified `offset` starting from the right.
**Syntax**
``` sql
rightUTF8(s, offset)
```
**Parameters**
2024-07-05 21:47:11 +00:00
- `s` — The UTF-8 encoded string to calculate a substring from. [String](../data-types/string.md) or [FixedString](../data-types/fixedstring.md).
- `offset` — The number of bytes of the offset. [UInt*](../data-types/int-uint).
**Returned value**
- For positive `offset`: A substring of `s` with `offset` many bytes, starting from the right of the string.
- For negative `offset`: A substring of `s` with `length(s) - |offset|` bytes, starting from the right of the string.
- An empty string if `length` is 0.
**Example**
Query:
```sql
SELECT rightUTF8('Привет', 4);
```
Result:
```response
ивет
```
Query:
```sql
SELECT rightUTF8('Привет', -4);
```
Result:
```response
ет
```
2022-06-02 10:55:18 +00:00
## rightPad
2021-08-03 18:58:32 +00:00
2023-04-19 20:04:59 +00:00
Pads a string from the right with spaces or with a specified string (multiple times, if needed) until the resulting string reaches the specified `length`.
2021-08-03 18:58:32 +00:00
**Syntax**
``` sql
2023-04-19 20:04:59 +00:00
rightPad(string, length[, pad_string])
2021-08-03 18:58:32 +00:00
```
2023-04-19 20:04:59 +00:00
Alias: `RPAD`
2021-08-03 18:58:32 +00:00
**Arguments**
2023-04-19 20:04:59 +00:00
- `string` — Input string that should be padded. [String](../data-types/string.md).
- `length` — The length of the resulting string. [UInt or Int](../data-types/int-uint.md). If the value is smaller than the input string length, then the input string is shortened to `length` characters.
- `pad_string` — The string to pad the input string with. [String](../data-types/string.md). Optional. If not specified, then the input string is padded with spaces.
2021-08-03 18:58:32 +00:00
2021-08-09 14:29:26 +00:00
**Returned value**
2021-08-03 18:58:32 +00:00
2024-05-23 13:48:20 +00:00
- A left-padded string of the given length. [String](../data-types/string.md).
2021-08-03 18:58:32 +00:00
**Example**
``` sql
2021-08-09 13:43:17 +00:00
SELECT rightPad('abc', 7, '*'), rightPad('abc', 7);
2021-08-03 18:58:32 +00:00
```
Result:
2023-04-19 20:04:59 +00:00
```result
2021-08-09 13:43:17 +00:00
┌─rightPad('abc', 7, '*')─┬─rightPad('abc', 7)─┐
│ abc**** │ abc │
└─────────────────────────┴────────────────────┘
2021-08-03 18:58:32 +00:00
```
2022-06-02 10:55:18 +00:00
## rightPadUTF8
2021-08-06 15:03:31 +00:00
2023-04-19 20:04:59 +00:00
Pads the string from the right with spaces or a specified string (multiple times, if needed) until the resulting string reaches the given length. Unlike [rightPad](#rightpad) which measures the string length in bytes, the string length is measured in code points.
2021-08-06 15:03:31 +00:00
**Syntax**
``` sql
2023-04-19 20:04:59 +00:00
rightPadUTF8(string, length[, pad_string])
2021-08-06 15:03:31 +00:00
```
**Arguments**
2023-04-19 20:04:59 +00:00
- `string` — Input string that should be padded. [String](../data-types/string.md).
- `length` — The length of the resulting string. [UInt or Int](../data-types/int-uint.md). If the value is smaller than the input string length, then the input string is shortened to `length` characters.
- `pad_string` — The string to pad the input string with. [String](../data-types/string.md). Optional. If not specified, then the input string is padded with spaces.
2021-08-06 15:03:31 +00:00
2021-08-09 14:29:26 +00:00
**Returned value**
2021-08-06 15:03:31 +00:00
2024-05-23 13:48:20 +00:00
- A right-padded string of the given length. [String](../data-types/string.md).
2021-08-06 15:03:31 +00:00
**Example**
``` sql
2021-08-09 13:43:17 +00:00
SELECT rightPadUTF8('абвг', 7, '*'), rightPadUTF8('абвг', 7);
2021-08-06 15:03:31 +00:00
```
Result:
2023-04-19 20:04:59 +00:00
```result
2021-08-09 13:43:17 +00:00
┌─rightPadUTF8('абвг', 7, '*')─┬─rightPadUTF8('абвг', 7)─┐
│ абвг*** │ абвг │
└──────────────────────────────┴─────────────────────────┘
2021-08-06 15:03:31 +00:00
```
2023-04-19 20:04:59 +00:00
## lower
Converts the ASCII Latin symbols in a string to lowercase.
2024-04-10 16:27:01 +00:00
*Syntax**
``` sql
lower(input)
```
2023-04-19 20:04:59 +00:00
Alias: `lcase`
2017-04-03 19:49:50 +00:00
2024-04-10 16:27:01 +00:00
**Parameters**
- `input`: A string type [String](../data-types/string.md).
2024-04-10 16:27:01 +00:00
**Returned value**
- A [String](../data-types/string.md) data type value.
2024-04-10 16:27:01 +00:00
**Example**
Query:
```sql
SELECT lower('CLICKHOUSE');
```
```response
┌─lower('CLICKHOUSE')─┐
│ clickhouse │
└─────────────────────┘
```
2023-04-19 20:04:59 +00:00
## upper
2023-04-19 20:04:59 +00:00
Converts the ASCII Latin symbols in a string to uppercase.
2024-04-10 04:24:07 +00:00
**Syntax**
``` sql
upper(input)
```
2023-04-19 20:04:59 +00:00
Alias: `ucase`
2017-04-03 19:49:50 +00:00
2024-04-10 04:24:07 +00:00
**Parameters**
2024-07-05 21:47:11 +00:00
- `input` — A string type [String](../data-types/string.md).
2024-04-10 04:24:07 +00:00
**Returned value**
- A [String](../data-types/string.md) data type value.
2024-04-10 04:24:07 +00:00
**Examples**
Query:
``` sql
2024-04-10 16:27:01 +00:00
SELECT upper('clickhouse');
2024-04-10 04:24:07 +00:00
```
``` response
2024-04-10 16:27:01 +00:00
┌─upper('clickhouse')─┐
│ CLICKHOUSE │
└─────────────────────┘
2024-04-10 04:24:07 +00:00
```
2022-06-02 10:55:18 +00:00
## lowerUTF8
2023-04-19 20:04:59 +00:00
Converts a string to lowercase, assuming that the string contains valid UTF-8 encoded text. If this assumption is violated, no exception is thrown and the result is undefined.
2024-07-05 21:47:11 +00:00
:::note
2024-07-06 09:17:21 +00:00
Does not detect the language, e.g. for Turkish the result might not be exactly correct (i/İ vs. i/I). If the length of the UTF-8 byte sequence is different for upper and lower case of a code point (such as `ẞ` and `ß`), the result may be incorrect for this code point.
2024-07-05 21:47:11 +00:00
:::
2023-04-19 20:04:59 +00:00
2024-07-05 21:47:11 +00:00
**Syntax**
```sql
lowerUTF8(input)
```
**Parameters**
- `input` — A string type [String](../data-types/string.md).
**Returned value**
- A [String](../data-types/string.md) data type value.
**Example**
Query:
``` sql
SELECT lowerUTF8('MÜNCHEN') as Lowerutf8;
```
Result:
``` response
┌─Lowerutf8─┐
│ münchen │
└───────────┘
```
2022-06-02 10:55:18 +00:00
## upperUTF8
2017-04-03 19:49:50 +00:00
2023-04-19 20:04:59 +00:00
Converts a string to uppercase, assuming that the string contains valid UTF-8 encoded text. If this assumption is violated, no exception is thrown and the result is undefined.
2024-07-05 21:47:11 +00:00
:::note
2024-07-06 09:17:21 +00:00
Does not detect the language, e.g. for Turkish the result might not be exactly correct (i/İ vs. i/I). If the length of the UTF-8 byte sequence is different for upper and lower case of a code point (such as `ẞ` and `ß`), the result may be incorrect for this code point.
2024-07-05 21:47:11 +00:00
:::
2024-04-10 04:24:07 +00:00
**Syntax**
``` sql
upperUTF8(input)
```
**Parameters**
2024-07-05 21:47:11 +00:00
- `input` — A string type [String](../data-types/string.md).
2024-04-10 04:24:07 +00:00
**Returned value**
- A [String](../data-types/string.md) data type value.
2024-04-10 04:24:07 +00:00
**Example**
Query:
``` sql
2024-04-10 10:12:29 +00:00
SELECT upperUTF8('München') as Upperutf8;
2024-04-10 04:24:07 +00:00
```
2024-07-05 21:47:11 +00:00
Result:
2024-04-10 04:24:07 +00:00
``` response
┌─Upperutf8─┐
2024-04-10 10:12:29 +00:00
│ MÜNCHEN │
2024-04-10 04:24:07 +00:00
└───────────┘
```
2022-06-02 10:55:18 +00:00
## isValidUTF8
2019-04-07 18:58:13 +00:00
2023-04-19 20:04:59 +00:00
Returns 1, if the set of bytes constitutes valid UTF-8-encoded text, otherwise 0.
2019-04-07 18:58:13 +00:00
2024-07-05 21:47:11 +00:00
**Syntax**
``` sql
isValidUTF8(input)
```
**Parameters**
- `input` — A string type [String](../data-types/string.md).
**Returned value**
- Returns `1`, if the set of bytes constitutes valid UTF-8-encoded text, otherwise `0`.
Query:
``` sql
SELECT isValidUTF8('\xc3\xb1') AS valid, isValidUTF8('\xc3\x28') AS invalid;
```
Result:
``` response
┌─valid─┬─invalid─┐
│ 1 │ 0 │
└───────┴─────────┘
```
2022-06-02 10:55:18 +00:00
## toValidUTF8
2019-05-17 12:55:21 +00:00
Replaces invalid UTF-8 characters by the `<60>` (U+FFFD) character. All running in a row invalid characters are collapsed into the one replacement character.
2023-04-19 20:04:59 +00:00
**Syntax**
2020-03-20 10:10:48 +00:00
``` sql
toValidUTF8(input_string)
```
2021-02-16 11:21:23 +00:00
**Arguments**
- `input_string` — Any set of bytes represented as the [String](../data-types/string.md) data type object.
2023-04-19 20:04:59 +00:00
**Returned value**
- A valid UTF-8 string.
**Example**
2020-03-20 10:10:48 +00:00
``` sql
SELECT toValidUTF8('\x61\xF0\x80\x80\x80b');
```
2020-03-20 10:10:48 +00:00
2023-04-19 20:04:59 +00:00
```result
2019-05-23 11:37:05 +00:00
┌─toValidUTF8('a<><61><EFBFBD><EFBFBD>b')─┐
│ a<>b │
└───────────────────────┘
2021-10-14 10:15:45 +00:00
```
2022-06-02 10:55:18 +00:00
## repeat
Concatenates a string as many times with itself as specified.
2021-02-16 11:31:24 +00:00
**Syntax**
2020-03-20 10:10:48 +00:00
``` sql
repeat(s, n)
```
2023-04-19 20:04:59 +00:00
Alias: `REPEAT`
**Arguments**
- `s` — The string to repeat. [String](../data-types/string.md).
- `n` — The number of times to repeat the string. [UInt* or Int*](../data-types/int-uint.md).
**Returned value**
2024-05-23 13:48:20 +00:00
A string containing string `s` repeated `n` times. If `n` <= 0, the function returns the empty string. [String](../data-types/string.md).
**Example**
2020-03-20 10:10:48 +00:00
``` sql
SELECT repeat('abc', 10);
```
Result:
2023-04-19 20:04:59 +00:00
```result
┌─repeat('abc', 10)──────────────┐
│ abcabcabcabcabcabcabcabcabcabc │
└────────────────────────────────┘
```
## space
Concatenates a space (` `) as many times with itself as specified.
**Syntax**
``` sql
space(n)
```
Alias: `SPACE`.
**Arguments**
- `n` — The number of times to repeat the space. [UInt* or Int*](../data-types/int-uint.md).
**Returned value**
2024-05-23 13:48:20 +00:00
The string containing string ` ` repeated `n` times. If `n` <= 0, the function returns the empty string. [String](../data-types/string.md).
**Example**
Query:
``` sql
SELECT space(3);
```
Result:
``` text
┌─space(3) ────┐
│ │
└──────────────┘
```
2022-06-02 10:55:18 +00:00
## reverse
2017-04-03 19:49:50 +00:00
2023-04-19 20:04:59 +00:00
Reverses the sequence of bytes in a string.
2017-04-03 19:49:50 +00:00
2022-06-02 10:55:18 +00:00
## reverseUTF8
2023-04-19 20:04:59 +00:00
Reverses a sequence of Unicode code points in a string. Assumes that the string contains valid UTF-8 encoded text. If this assumption is violated, no exception is thrown and the result is undefined.
2022-06-02 10:55:18 +00:00
## concat
2023-11-15 15:42:00 +00:00
Concatenates the given arguments.
2020-03-20 10:10:48 +00:00
**Syntax**
2020-03-20 10:10:48 +00:00
``` sql
concat(s1, s2, ...)
```
**Arguments**
2024-07-02 01:54:37 +00:00
Values of arbitrary type.
2023-11-15 15:42:00 +00:00
Arguments which are not of types [String](../data-types/string.md) or [FixedString](../data-types/fixedstring.md) are converted to strings using their default serialization. As this decreases performance, it is not recommended to use non-String/FixedString arguments.
**Returned values**
2023-04-19 20:04:59 +00:00
The String created by concatenating the arguments.
2023-04-19 20:04:59 +00:00
If any of arguments is `NULL`, the function returns `NULL`.
**Example**
2023-11-15 15:42:00 +00:00
Query:
2020-03-20 10:10:48 +00:00
``` sql
SELECT concat('Hello, ', 'World!');
```
Result:
2023-04-19 20:04:59 +00:00
```result
2019-12-26 12:51:48 +00:00
┌─concat('Hello, ', 'World!')─┐
│ Hello, World! │
└─────────────────────────────┘
```
2023-11-15 15:42:00 +00:00
Query:
2023-11-15 13:57:34 +00:00
```sql
SELECT concat(42, 144);
```
Result:
```result
┌─concat(42, 144)─┐
│ 42144 │
└─────────────────┘
```
2022-06-02 10:55:18 +00:00
## concatAssumeInjective
2023-04-19 20:04:59 +00:00
Like [concat](#concat) but assumes that `concat(s1, s2, ...) → sn` is injective. Can be used for optimization of GROUP BY.
2023-04-19 20:04:59 +00:00
A function is called injective if it returns for different arguments different results. In other words: different arguments never produce identical result.
2020-03-20 10:10:48 +00:00
**Syntax**
2020-03-20 10:10:48 +00:00
``` sql
concatAssumeInjective(s1, s2, ...)
```
**Arguments**
Values of type String or FixedString.
**Returned values**
2023-04-19 20:04:59 +00:00
The String created by concatenating the arguments.
2023-04-19 20:04:59 +00:00
If any of argument values is `NULL`, the function returns `NULL`.
**Example**
2019-12-26 12:51:48 +00:00
Input table:
2020-03-20 10:10:48 +00:00
``` sql
2020-02-02 21:59:23 +00:00
CREATE TABLE key_val(`key1` String, `key2` String, `value` UInt32) ENGINE = TinyLog;
INSERT INTO key_val VALUES ('Hello, ','World',1), ('Hello, ','World',2), ('Hello, ','World!',3), ('Hello',', World!',2);
SELECT * from key_val;
2019-12-26 12:51:48 +00:00
```
2023-04-19 20:04:59 +00:00
```result
2019-12-26 12:51:48 +00:00
┌─key1────┬─key2─────┬─value─┐
│ Hello, │ World │ 1 │
│ Hello, │ World │ 2 │
│ Hello, │ World! │ 3 │
│ Hello │ , World! │ 2 │
└─────────┴──────────┴───────┘
```
2020-03-20 10:10:48 +00:00
``` sql
SELECT concat(key1, key2), sum(value) FROM key_val GROUP BY concatAssumeInjective(key1, key2);
```
Result:
2023-04-19 20:04:59 +00:00
```result
┌─concat(key1, key2)─┬─sum(value)─┐
│ Hello, World! │ 3 │
│ Hello, World! │ 2 │
│ Hello, World │ 3 │
└────────────────────┴────────────┘
```
2023-04-19 20:04:59 +00:00
## concatWithSeparator
Concatenates the given strings with a given separator.
2017-04-03 19:49:50 +00:00
2023-04-19 20:04:59 +00:00
**Syntax**
``` sql
concatWithSeparator(sep, expr1, expr2, expr3...)
```
2017-04-03 19:49:50 +00:00
2023-11-15 15:42:00 +00:00
Alias: `concat_ws`
2023-04-19 20:04:59 +00:00
**Arguments**
- sep — separator. Const [String](../data-types/string.md) or [FixedString](../data-types/fixedstring.md).
- exprN — expression to be concatenated. Arguments which are not of types [String](../data-types/string.md) or [FixedString](../data-types/fixedstring.md) are converted to strings using their default serialization. As this decreases performance, it is not recommended to use non-String/FixedString arguments.
2017-04-03 19:49:50 +00:00
2023-04-19 20:04:59 +00:00
**Returned values**
2023-04-19 20:04:59 +00:00
The String created by concatenating the arguments.
2023-04-19 20:04:59 +00:00
If any of the argument values is `NULL`, the function returns `NULL`.
2023-04-19 20:04:59 +00:00
**Example**
2017-04-03 19:49:50 +00:00
2023-04-19 20:04:59 +00:00
``` sql
SELECT concatWithSeparator('a', '1', '2', '3', '4')
```
2022-06-22 09:56:37 +00:00
2023-04-19 20:04:59 +00:00
Result:
```result
┌─concatWithSeparator('a', '1', '2', '3', '4')─┐
2023-12-13 16:49:39 +00:00
│ 1a2a3a4 │
└──────────────────────────────────────────────┘
2023-04-19 20:04:59 +00:00
```
## concatWithSeparatorAssumeInjective
Like `concatWithSeparator` but assumes that `concatWithSeparator(sep, expr1, expr2, expr3...) → result` is injective. Can be used for optimization of GROUP BY.
A function is called injective if it returns for different arguments different results. In other words: different arguments never produce identical result.
2023-11-28 14:59:20 +00:00
## substring
2023-04-19 20:04:59 +00:00
2023-11-28 14:59:20 +00:00
Returns the substring of a string `s` which starts at the specified byte index `offset`. Byte counting starts from 1. If `offset` is 0, an empty string is returned. If `offset` is negative, the substring starts `pos` characters from the end of the string, rather than from the beginning. An optional argument `length` specifies the maximum number of bytes the returned substring may have.
2023-04-19 20:04:59 +00:00
**Syntax**
```sql
2023-11-28 14:59:20 +00:00
substring(s, offset[, length])
2023-04-19 20:04:59 +00:00
```
2024-07-05 21:47:11 +00:00
Aliases:
2023-04-19 20:04:59 +00:00
- `substr`
- `mid`
- `byteSlice`
2023-04-19 20:04:59 +00:00
2023-11-28 14:59:20 +00:00
**Arguments**
- `s` — The string to calculate a substring from. [String](../data-types/string.md), [FixedString](../data-types/fixedstring.md) or [Enum](../data-types/enum.md)
- `offset` — The starting position of the substring in `s` . [(U)Int*](../data-types/int-uint.md).
- `length` — The maximum length of the substring. [(U)Int*](../data-types/int-uint.md). Optional.
2023-11-28 14:59:20 +00:00
**Returned value**
2024-05-23 13:48:20 +00:00
A substring of `s` with `length` many bytes, starting at index `offset`. [String](../data-types/string.md).
2023-11-28 14:59:20 +00:00
**Example**
``` sql
SELECT 'database' AS db, substr(db, 5), substr(db, 5, 1)
```
Result:
```result
┌─db───────┬─substring('database', 5)─┬─substring('database', 5, 1)─┐
│ database │ base │ b │
└──────────┴──────────────────────────┴─────────────────────────────┘
```
2023-04-19 20:04:59 +00:00
## substringUTF8
2024-03-08 15:07:04 +00:00
Returns the substring of a string `s` which starts at the specified byte index `offset` for Unicode code points. Byte counting starts from `1`. If `offset` is `0`, an empty string is returned. If `offset` is negative, the substring starts `pos` characters from the end of the string, rather than from the beginning. An optional argument `length` specifies the maximum number of bytes the returned substring may have.
2023-04-19 20:04:59 +00:00
2024-03-08 15:07:04 +00:00
Assumes that the string contains valid UTF-8 encoded text. If this assumption is violated, no exception is thrown and the result is undefined.
**Syntax**
```sql
substringUTF8(s, offset[, length])
```
**Arguments**
2024-07-05 21:47:11 +00:00
- `s` — The string to calculate a substring from. [String](../data-types/string.md), [FixedString](../data-types/fixedstring.md) or [Enum](../data-types/enum.md)
- `offset` — The starting position of the substring in `s` . [(U)Int*](../data-types/int-uint.md).
- `length` — The maximum length of the substring. [(U)Int*](../data-types/int-uint.md). Optional.
2024-03-08 15:07:04 +00:00
**Returned value**
A substring of `s` with `length` many bytes, starting at index `offset`.
**Implementation details**
Assumes that the string contains valid UTF-8 encoded text. If this assumption is violated, no exception is thrown and the result is undefined.
**Example**
```sql
SELECT 'Täglich grüßt das Murmeltier.' AS str,
substringUTF8(str, 9),
substringUTF8(str, 9, 5)
2024-03-08 15:07:04 +00:00
```
```response
Täglich grüßt das Murmeltier. grüßt das Murmeltier. grüßt
2024-03-08 15:07:04 +00:00
```
2023-06-28 03:28:20 +00:00
2023-11-28 14:59:20 +00:00
## substringIndex
2023-06-28 03:28:20 +00:00
Returns the substring of `s` before `count` occurrences of the delimiter `delim`, as in Spark or MySQL.
2023-06-28 03:28:20 +00:00
**Syntax**
```sql
substringIndex(s, delim, count)
2023-06-28 03:28:20 +00:00
```
Alias: `SUBSTRING_INDEX`
**Arguments**
2024-07-05 21:47:11 +00:00
- s — The string to extract substring from. [String](../data-types/string.md).
- delim — The character to split. [String](../data-types/string.md).
- count — The number of occurrences of the delimiter to count before extracting the substring. If count is positive, everything to the left of the final delimiter (counting from the left) is returned. If count is negative, everything to the right of the final delimiter (counting from the right) is returned. [UInt or Int](../data-types/int-uint.md)
2023-06-28 03:28:20 +00:00
**Example**
``` sql
SELECT substringIndex('www.clickhouse.com', '.', 2)
```
Result:
```
┌─substringIndex('www.clickhouse.com', '.', 2)─┐
│ www.clickhouse │
└──────────────────────────────────────────────┘
```
2023-11-28 14:59:20 +00:00
## substringIndexUTF8
2023-06-28 03:28:20 +00:00
2024-03-08 15:07:04 +00:00
Returns the substring of `s` before `count` occurrences of the delimiter `delim`, specifically for Unicode code points.
Assumes that the string contains valid UTF-8 encoded text. If this assumption is violated, no exception is thrown and the result is undefined.
**Syntax**
```sql
substringIndexUTF8(s, delim, count)
```
**Arguments**
2024-07-05 21:47:11 +00:00
- `s` — The string to extract substring from. [String](../data-types/string.md).
- `delim` — The character to split. [String](../data-types/string.md).
- `count` — The number of occurrences of the delimiter to count before extracting the substring. If count is positive, everything to the left of the final delimiter (counting from the left) is returned. If count is negative, everything to the right of the final delimiter (counting from the right) is returned. [UInt or Int](../data-types/int-uint.md)
2024-03-08 15:07:04 +00:00
**Returned value**
A substring [String](../data-types/string.md) of `s` before `count` occurrences of `delim`.
2024-03-08 15:07:04 +00:00
**Implementation details**
Assumes that the string contains valid UTF-8 encoded text. If this assumption is violated, no exception is thrown and the result is undefined.
**Example**
```sql
SELECT substringIndexUTF8('www.straßen-in-europa.de', '.', 2)
2024-03-08 15:07:04 +00:00
```
```response
2024-03-13 12:41:56 +00:00
www.straßen-in-europa
2024-03-08 15:07:04 +00:00
```
2023-04-19 20:04:59 +00:00
## appendTrailingCharIfAbsent
Appends character `c` to string `s` if `s` is non-empty and does not end with character `c`.
**Syntax**
```sql
appendTrailingCharIfAbsent(s, c)
```
## convertCharset
Returns string `s` converted from the encoding `from` to encoding `to`.
**Syntax**
```sql
convertCharset(s, from, to)
```
## base58Encode
2024-10-21 08:23:44 +00:00
Encodes a string using [Base58](https://datatracker.ietf.org/doc/html/draft-msporny-base58) in the "Bitcoin" alphabet.
2022-06-22 09:56:37 +00:00
**Syntax**
```sql
2022-08-30 14:08:23 +00:00
base58Encode(plaintext)
2022-06-22 09:56:37 +00:00
```
**Arguments**
- `plaintext` — [String](../data-types/string.md) column or constant.
2022-06-22 09:56:37 +00:00
**Returned value**
2024-10-21 08:23:44 +00:00
- A string containing the encoded value of the argument. [String](../data-types/string.md) or [FixedString](../data-types/fixedstring.md).
2022-06-22 09:56:37 +00:00
**Example**
``` sql
2022-07-16 17:45:33 +00:00
SELECT base58Encode('Encoded');
2022-08-30 14:08:23 +00:00
```
Result:
2023-04-19 20:04:59 +00:00
```result
2022-08-30 14:08:23 +00:00
┌─base58Encode('Encoded')─┐
│ 3dc8KtHrwM │
└─────────────────────────┘
```
2023-04-19 20:04:59 +00:00
## base58Decode
2022-08-30 14:08:23 +00:00
2024-10-21 08:23:44 +00:00
Accepts a string and decodes it using [Base58](https://datatracker.ietf.org/doc/html/draft-msporny-base58) encoding scheme using "Bitcoin" alphabet.
2022-08-30 14:08:23 +00:00
**Syntax**
```sql
2023-04-19 20:04:59 +00:00
base58Decode(encoded)
2022-08-30 14:08:23 +00:00
```
**Arguments**
2024-10-21 08:23:44 +00:00
- `encoded` — [String](../data-types/string.md) or [FixedString](../data-types/fixedstring.md). If the string is not a valid Base58-encoded value, an exception is thrown.
2022-08-30 14:08:23 +00:00
**Returned value**
2024-05-23 13:48:20 +00:00
- A string containing the decoded value of the argument. [String](../data-types/string.md).
2022-08-30 14:08:23 +00:00
**Example**
``` sql
2022-08-30 11:40:26 +00:00
SELECT base58Decode('3dc8KtHrwM');
2022-06-22 09:56:37 +00:00
```
Result:
2023-04-19 20:04:59 +00:00
```result
2022-08-30 14:08:23 +00:00
┌─base58Decode('3dc8KtHrwM')─┐
│ Encoded │
└────────────────────────────┘
2022-06-22 09:56:37 +00:00
```
2023-04-19 20:04:59 +00:00
## tryBase58Decode
2023-04-19 20:04:59 +00:00
Like `base58Decode` but returns an empty string in case of error.
**Syntax**
```sql
tryBase58Decode(encoded)
```
**Parameters**
2024-10-21 08:23:44 +00:00
- `encoded`: [String](../data-types/string.md) or [FixedString](../data-types/fixedstring.md). If the string is not a valid Base58-encoded value, returns an empty string in case of error.
**Returned value**
- A string containing the decoded value of the argument.
**Examples**
Query:
```sql
2024-04-29 07:33:46 +00:00
SELECT tryBase58Decode('3dc8KtHrwM') as res, tryBase58Decode('invalid') as res_invalid;
```
```response
2024-04-29 07:33:46 +00:00
┌─res─────┬─res_invalid─┐
│ Encoded │ │
└─────────┴─────────────┘
```
2023-04-19 20:04:59 +00:00
## base64Encode
Encodes a String or FixedString as base64, according to [RFC 4648](https://datatracker.ietf.org/doc/html/rfc4648#section-4).
2018-11-02 19:06:05 +00:00
2021-02-16 11:13:01 +00:00
Alias: `TO_BASE64`.
**Syntax**
```sql
base64Encode(plaintext)
```
**Arguments**
- `plaintext` — [String](../data-types/string.md) column or constant.
**Returned value**
- A string containing the encoded value of the argument.
**Example**
``` sql
SELECT base64Encode('clickhouse');
```
Result:
```result
┌─base64Encode('clickhouse')─┐
│ Y2xpY2tob3VzZQ== │
└────────────────────────────┘
```
## base64URLEncode
Encodes an URL (String or FixedString) as base64 with URL-specific modifications, according to [RFC 4648](https://datatracker.ietf.org/doc/html/rfc4648#section-5).
**Syntax**
```sql
base64URLEncode(url)
```
**Arguments**
- `url` — [String](../data-types/string.md) column or constant.
**Returned value**
- A string containing the encoded value of the argument.
**Example**
``` sql
SELECT base64URLEncode('https://clickhouse.com');
```
Result:
```result
┌─base64URLEncode('https://clickhouse.com')─┐
│ aHR0cDovL2NsaWNraG91c2UuY29t │
└───────────────────────────────────────────┘
```
2023-04-19 20:04:59 +00:00
## base64Decode
Accepts a String and decodes it from base64, according to [RFC 4648](https://datatracker.ietf.org/doc/html/rfc4648#section-4). Throws an exception in case of an error.
2018-11-02 19:06:05 +00:00
2021-02-16 11:13:01 +00:00
Alias: `FROM_BASE64`.
**Syntax**
```sql
base64Decode(encoded)
```
**Arguments**
- `encoded` — [String](../data-types/string.md) column or constant. If the string is not a valid Base64-encoded value, an exception is thrown.
**Returned value**
- A string containing the decoded value of the argument.
**Example**
``` sql
SELECT base64Decode('Y2xpY2tob3VzZQ==');
```
Result:
```result
┌─base64Decode('Y2xpY2tob3VzZQ==')─┐
│ clickhouse │
└──────────────────────────────────┘
```
## base64URLDecode
Accepts a base64-encoded URL and decodes it from base64 with URL-specific modifications, according to [RFC 4648](https://datatracker.ietf.org/doc/html/rfc4648#section-5). Throws an exception in case of an error.
**Syntax**
```sql
base64URLDecode(encodedUrl)
```
**Arguments**
- `encodedURL` — [String](../data-types/string.md) column or constant. If the string is not a valid Base64-encoded value with URL-specific modifications, an exception is thrown.
**Returned value**
- A string containing the decoded value of the argument.
**Example**
``` sql
SELECT base64URLDecode('aHR0cDovL2NsaWNraG91c2UuY29t');
```
Result:
```result
┌─base64URLDecode('aHR0cDovL2NsaWNraG91c2UuY29t')─┐
│ https://clickhouse.com │
└─────────────────────────────────────────────────┘
```
2023-04-19 20:04:59 +00:00
## tryBase64Decode
2023-04-19 20:04:59 +00:00
Like `base64Decode` but returns an empty string in case of error.
**Syntax**
```sql
tryBase64Decode(encoded)
```
**Arguments**
2024-07-05 21:47:11 +00:00
- `encoded` — [String](../data-types/string.md) column or constant. If the string is not a valid Base64-encoded value, returns an empty string.
**Returned value**
- A string containing the decoded value of the argument.
**Examples**
Query:
```sql
SELECT tryBase64Decode('RW5jb2RlZA==') as res, tryBase64Decode('invalid') as res_invalid;
```
```response
┌─res────────┬─res_invalid─┐
│ clickhouse │ │
└────────────┴─────────────┘
```
## tryBase64URLDecode
2024-06-10 10:14:45 +00:00
Like `base64URLDecode` but returns an empty string in case of error.
2024-06-10 10:14:45 +00:00
**Syntax**
```sql
tryBase64URLDecode(encodedUrl)
```
**Parameters**
2024-07-05 21:47:11 +00:00
- `encodedURL` — [String](../data-types/string.md) column or constant. If the string is not a valid Base64-encoded value with URL-specific modifications, returns an empty string.
**Returned value**
- A string containing the decoded value of the argument.
**Examples**
Query:
```sql
SELECT tryBase64URLDecode('aHR0cDovL2NsaWNraG91c2UuY29t') as res, tryBase64Decode('aHR0cHM6Ly9jbGlja') as res_invalid;
```
```response
┌─res────────────────────┬─res_invalid─┐
│ https://clickhouse.com │ │
└────────────────────────┴─────────────┘
```
2024-01-10 13:34:55 +00:00
## endsWith {#endswith}
2023-04-19 20:04:59 +00:00
Returns whether string `str` ends with `suffix`.
2023-04-19 20:04:59 +00:00
**Syntax**
2019-09-26 11:39:06 +00:00
2023-04-19 20:04:59 +00:00
```sql
endsWith(str, suffix)
2019-09-26 11:39:06 +00:00
```
## endsWithUTF8
2023-07-26 02:53:07 +00:00
Returns whether string `str` ends with `suffix`, the difference between `endsWithUTF8` and `endsWith` is that `endsWithUTF8` match `str` and `suffix` by UTF-8 characters.
**Syntax**
```sql
endsWithUTF8(str, suffix)
```
**Example**
``` sql
2023-07-31 04:07:50 +00:00
SELECT endsWithUTF8('中国', '\xbd'), endsWith('中国', '\xbd')
```
Result:
```result
┌─endsWithUTF8('中国', '½')─┬─endsWith('中国', '½')─┐
│ 0 │ 1 │
└──────────────────────────┴──────────────────────┘
```
2024-01-10 13:34:55 +00:00
## startsWith {#startswith}
2019-09-26 11:39:06 +00:00
2023-04-19 20:04:59 +00:00
Returns whether string `str` starts with `prefix`.
2019-09-26 11:39:06 +00:00
2023-04-19 20:04:59 +00:00
**Syntax**
2019-09-26 11:39:06 +00:00
2023-04-19 20:04:59 +00:00
```sql
startsWith(str, prefix)
2019-09-26 11:39:06 +00:00
```
2023-04-19 20:04:59 +00:00
**Example**
2019-09-26 11:39:06 +00:00
2023-04-19 20:04:59 +00:00
``` sql
SELECT startsWith('Spider-Man', 'Spi');
2019-09-26 11:39:06 +00:00
```
## startsWithUTF8
<VersionBadge minVersion='23.8' />
2023-07-26 02:53:07 +00:00
Returns whether string `str` starts with `prefix`, the difference between `startsWithUTF8` and `startsWith` is that `startsWithUTF8` match `str` and `suffix` by UTF-8 characters.
**Example**
``` sql
2023-07-31 04:07:50 +00:00
SELECT startsWithUTF8('中国', '\xe4'), startsWith('中国', '\xe4')
```
2023-07-31 04:07:50 +00:00
Result:
```result
┌─startsWithUTF8('中国', '⥩─┬─startsWith('中国', '⥩─┐
│ 0 │ 1 │
└────────────────────────────┴────────────────────────┘
```
2022-06-02 10:55:18 +00:00
## trim
2023-04-19 20:04:59 +00:00
Removes the specified characters from the start or end of a string. If not specified otherwise, the function removes whitespace (ASCII-character 32).
**Syntax**
2020-03-20 10:10:48 +00:00
``` sql
trim([[LEADING|TRAILING|BOTH] trim_character FROM] input_string)
```
**Arguments**
- `trim_character` — Specified characters for trim. [String](../data-types/string.md).
- `input_string` — String for trim. [String](../data-types/string.md).
**Returned value**
2024-05-23 13:48:20 +00:00
A string without leading and/or trailing specified characters. [String](../data-types/string.md).
**Example**
2020-03-20 10:10:48 +00:00
``` sql
SELECT trim(BOTH ' ()' FROM '( Hello, world! )');
```
Result:
2023-04-19 20:04:59 +00:00
```result
┌─trim(BOTH ' ()' FROM '( Hello, world! )')─┐
│ Hello, world! │
└───────────────────────────────────────────────┘
```
2022-06-02 10:55:18 +00:00
## trimLeft
2023-04-19 20:04:59 +00:00
Removes the consecutive occurrences of whitespace (ASCII-character 32) from the start of a string.
2020-03-20 10:10:48 +00:00
**Syntax**
2020-03-20 10:10:48 +00:00
``` sql
trimLeft(input_string)
```
Alias: `ltrim(input_string)`.
**Arguments**
- `input_string` — string to trim. [String](../data-types/string.md).
**Returned value**
2024-05-23 13:48:20 +00:00
A string without leading common whitespaces. [String](../data-types/string.md).
**Example**
2020-03-20 10:10:48 +00:00
``` sql
SELECT trimLeft(' Hello, world! ');
```
Result:
2023-04-19 20:04:59 +00:00
```result
┌─trimLeft(' Hello, world! ')─┐
│ Hello, world! │
└─────────────────────────────────────┘
```
2022-06-02 10:55:18 +00:00
## trimRight
2023-04-19 20:04:59 +00:00
Removes the consecutive occurrences of whitespace (ASCII-character 32) from the end of a string.
2020-03-20 10:10:48 +00:00
**Syntax**
2020-03-20 10:10:48 +00:00
``` sql
trimRight(input_string)
```
Alias: `rtrim(input_string)`.
**Arguments**
- `input_string` — string to trim. [String](../data-types/string.md).
**Returned value**
2024-05-23 13:48:20 +00:00
A string without trailing common whitespaces. [String](../data-types/string.md).
**Example**
2020-03-20 10:10:48 +00:00
``` sql
SELECT trimRight(' Hello, world! ');
```
Result:
2023-04-19 20:04:59 +00:00
```result
┌─trimRight(' Hello, world! ')─┐
│ Hello, world! │
└──────────────────────────────────────┘
```
2022-06-02 10:55:18 +00:00
## trimBoth
2023-04-19 20:04:59 +00:00
Removes the consecutive occurrences of whitespace (ASCII-character 32) from both ends of a string.
2020-03-20 10:10:48 +00:00
**Syntax**
2020-03-20 10:10:48 +00:00
``` sql
trimBoth(input_string)
```
Alias: `trim(input_string)`.
**Arguments**
- `input_string` — string to trim. [String](../data-types/string.md).
**Returned value**
2024-05-23 13:48:20 +00:00
A string without leading and trailing common whitespaces. [String](../data-types/string.md).
**Example**
2020-03-20 10:10:48 +00:00
``` sql
SELECT trimBoth(' Hello, world! ');
```
Result:
2023-04-19 20:04:59 +00:00
```result
┌─trimBoth(' Hello, world! ')─┐
│ Hello, world! │
└─────────────────────────────────────┘
```
2023-04-19 20:04:59 +00:00
## CRC32
2019-06-17 21:49:37 +00:00
2023-04-19 20:04:59 +00:00
Returns the CRC32 checksum of a string using CRC-32-IEEE 802.3 polynomial and initial value `0xffffffff` (zlib implementation).
The result type is UInt32.
2023-04-19 20:04:59 +00:00
## CRC32IEEE
Returns the CRC32 checksum of a string, using CRC-32-IEEE 802.3 polynomial.
2019-06-17 21:49:37 +00:00
The result type is UInt32.
2023-04-19 20:04:59 +00:00
## CRC64
Returns the CRC64 checksum of a string, using CRC-64-ECMA polynomial.
The result type is UInt64.
2022-06-02 10:55:18 +00:00
## normalizeQuery
2024-07-07 16:51:52 +00:00
Replaces literals, sequences of literals and complex aliases (containing whitespace, more than two digits or at least 36 bytes long such as UUIDs) with placeholder `?`.
**Syntax**
``` sql
normalizeQuery(x)
```
2021-07-29 15:20:55 +00:00
**Arguments**
- `x` — Sequence of characters. [String](../data-types/string.md).
2020-09-28 20:58:08 +00:00
**Returned value**
- Sequence of characters with placeholders. [String](../data-types/string.md).
**Example**
Query:
``` sql
SELECT normalizeQuery('[1, 2, 3, x]') AS query;
```
Result:
2023-04-19 20:04:59 +00:00
```result
┌─query────┐
│ [?.., x] │
└──────────┘
```
## normalizeQueryKeepNames
Replaces literals, sequences of literals with placeholder `?` but does not replace complex aliases (containing whitespace, more than two digits
or at least 36 bytes long such as UUIDs). This helps better analyze complex query logs.
**Syntax**
``` sql
normalizeQueryKeepNames(x)
```
**Arguments**
- `x` — Sequence of characters. [String](../data-types/string.md).
**Returned value**
- Sequence of characters with placeholders. [String](../data-types/string.md).
**Example**
Query:
``` sql
SELECT normalizeQuery('SELECT 1 AS aComplexName123'), normalizeQueryKeepNames('SELECT 1 AS aComplexName123');
```
Result:
```result
┌─normalizeQuery('SELECT 1 AS aComplexName123')─┬─normalizeQueryKeepNames('SELECT 1 AS aComplexName123')─┐
│ SELECT ? AS `?` │ SELECT ? AS aComplexName123 │
└───────────────────────────────────────────────┴────────────────────────────────────────────────────────┘
```
2022-06-02 10:55:18 +00:00
## normalizedQueryHash
Returns identical 64bit hash values without the values of literals for similar queries. Can be helpful to analyze query logs.
2021-07-29 15:20:55 +00:00
**Syntax**
``` sql
normalizedQueryHash(x)
```
2021-07-29 15:20:55 +00:00
**Arguments**
- `x` — Sequence of characters. [String](../data-types/string.md).
**Returned value**
- Hash value. [UInt64](../data-types/int-uint.md#uint-ranges).
**Example**
Query:
``` sql
SELECT normalizedQueryHash('SELECT 1 AS `xyz`') != normalizedQueryHash('SELECT 1 AS `abc`') AS res;
```
Result:
2023-04-19 20:04:59 +00:00
```result
┌─res─┐
│ 1 │
└─────┘
```
## normalizedQueryHashKeepNames
Like [normalizedQueryHash](#normalizedqueryhash) it returns identical 64bit hash values without the values of literals for similar queries but it does not replace complex aliases (containing whitespace, more than two digits
or at least 36 bytes long such as UUIDs) with a placeholder before hashing. Can be helpful to analyze query logs.
**Syntax**
``` sql
normalizedQueryHashKeepNames(x)
```
**Arguments**
- `x` — Sequence of characters. [String](../data-types/string.md).
**Returned value**
- Hash value. [UInt64](../data-types/int-uint.md#uint-ranges).
**Example**
``` sql
SELECT normalizedQueryHash('SELECT 1 AS `xyz123`') != normalizedQueryHash('SELECT 1 AS `abc123`') AS normalizedQueryHash;
SELECT normalizedQueryHashKeepNames('SELECT 1 AS `xyz123`') != normalizedQueryHashKeepNames('SELECT 1 AS `abc123`') AS normalizedQueryHashKeepNames;
```
Result:
```result
┌─normalizedQueryHash─┐
│ 0 │
└─────────────────────┘
┌─normalizedQueryHashKeepNames─┐
│ 1 │
└──────────────────────────────┘
```
2022-06-02 10:55:18 +00:00
## normalizeUTF8NFC
2021-10-19 22:31:39 +00:00
2023-04-19 20:04:59 +00:00
Converts a string to [NFC normalized form](https://en.wikipedia.org/wiki/Unicode_equivalence#Normal_forms), assuming the string is valid UTF8-encoded text.
2021-10-19 22:31:39 +00:00
**Syntax**
``` sql
normalizeUTF8NFC(words)
2021-10-19 22:31:39 +00:00
```
**Arguments**
- `words` — UTF8-encoded input string. [String](../data-types/string.md).
2021-10-19 22:31:39 +00:00
**Returned value**
- String transformed to NFC normalization form. [String](../data-types/string.md).
2021-10-19 22:31:39 +00:00
2021-10-22 20:10:02 +00:00
**Example**
``` sql
SELECT length('â'), normalizeUTF8NFC('â') AS nfc, length(nfc) AS nfc_len;
2021-10-22 20:10:02 +00:00
```
Result:
2023-04-19 20:04:59 +00:00
```result
┌─length('â')─┬─nfc─┬─nfc_len─┐
│ 2 │ â │ 2 │
2021-10-22 20:10:02 +00:00
└─────────────┴─────┴─────────┘
```
2022-06-02 10:55:18 +00:00
## normalizeUTF8NFD
2021-10-22 20:10:02 +00:00
2023-04-19 20:04:59 +00:00
Converts a string to [NFD normalized form](https://en.wikipedia.org/wiki/Unicode_equivalence#Normal_forms), assuming the string is valid UTF8-encoded text.
2021-10-22 20:10:02 +00:00
**Syntax**
``` sql
normalizeUTF8NFD(words)
```
**Arguments**
- `words` — UTF8-encoded input string. [String](../data-types/string.md).
2021-10-22 20:10:02 +00:00
**Returned value**
- String transformed to NFD normalization form. [String](../data-types/string.md).
2021-10-22 20:10:02 +00:00
**Example**
``` sql
SELECT length('â'), normalizeUTF8NFD('â') AS nfd, length(nfd) AS nfd_len;
2021-10-22 20:10:02 +00:00
```
Result:
2023-04-19 20:04:59 +00:00
```result
┌─length('â')─┬─nfd─┬─nfd_len─┐
│ 2 │ â │ 3 │
2021-10-22 20:10:02 +00:00
└─────────────┴─────┴─────────┘
```
2022-06-02 10:55:18 +00:00
## normalizeUTF8NFKC
2021-10-22 20:10:02 +00:00
2023-04-19 20:04:59 +00:00
Converts a string to [NFKC normalized form](https://en.wikipedia.org/wiki/Unicode_equivalence#Normal_forms), assuming the string is valid UTF8-encoded text.
2021-10-22 20:10:02 +00:00
**Syntax**
``` sql
normalizeUTF8NFKC(words)
```
**Arguments**
- `words` — UTF8-encoded input string. [String](../data-types/string.md).
2021-10-22 20:10:02 +00:00
**Returned value**
- String transformed to NFKC normalization form. [String](../data-types/string.md).
2021-10-22 20:10:02 +00:00
**Example**
``` sql
SELECT length('â'), normalizeUTF8NFKC('â') AS nfkc, length(nfkc) AS nfkc_len;
2021-10-22 20:10:02 +00:00
```
Result:
2023-04-19 20:04:59 +00:00
```result
┌─length('â')─┬─nfkc─┬─nfkc_len─┐
│ 2 │ â │ 2 │
2021-10-22 20:10:02 +00:00
└─────────────┴──────┴──────────┘
```
2022-06-02 10:55:18 +00:00
## normalizeUTF8NFKD
2021-10-22 20:10:02 +00:00
2023-04-19 20:04:59 +00:00
Converts a string to [NFKD normalized form](https://en.wikipedia.org/wiki/Unicode_equivalence#Normal_forms), assuming the string is valid UTF8-encoded text.
2021-10-22 20:10:02 +00:00
**Syntax**
``` sql
normalizeUTF8NFKD(words)
```
**Arguments**
- `words` — UTF8-encoded input string. [String](../data-types/string.md).
2021-10-22 20:10:02 +00:00
**Returned value**
- String transformed to NFKD normalization form. [String](../data-types/string.md).
2021-10-22 20:10:02 +00:00
**Example**
``` sql
SELECT length('â'), normalizeUTF8NFKD('â') AS nfkd, length(nfkd) AS nfkd_len;
2021-10-22 20:10:02 +00:00
```
Result:
2023-04-19 20:04:59 +00:00
```result
┌─length('â')─┬─nfkd─┬─nfkd_len─┐
│ 2 │ â │ 3 │
2021-10-22 20:10:02 +00:00
└─────────────┴──────┴──────────┘
```
2021-10-19 22:31:39 +00:00
2022-06-02 10:55:18 +00:00
## encodeXMLComponent
2020-12-27 11:21:58 +00:00
2023-04-19 20:04:59 +00:00
Escapes characters with special meaning in XML such that they can afterwards be place into a XML text node or attribute.
2020-12-27 11:21:58 +00:00
2023-04-19 20:04:59 +00:00
The following characters are replaced: `<`, `&`, `>`, `"`, `'`.
Also see the [list of XML and HTML character entity references](https://en.wikipedia.org/wiki/List_of_XML_and_HTML_character_entity_references).
2020-12-27 20:49:05 +00:00
2021-07-29 15:20:55 +00:00
**Syntax**
2020-12-27 11:21:58 +00:00
``` sql
encodeXMLComponent(x)
```
2021-07-29 15:20:55 +00:00
**Arguments**
2020-12-27 11:21:58 +00:00
- `x` — An input string. [String](../data-types/string.md).
2020-12-27 11:21:58 +00:00
**Returned value**
2020-12-27 11:21:58 +00:00
- The escaped string. [String](../data-types/string.md).
2020-12-27 11:21:58 +00:00
**Example**
``` sql
2020-12-27 20:49:05 +00:00
SELECT encodeXMLComponent('Hello, "world"!');
SELECT encodeXMLComponent('<123>');
SELECT encodeXMLComponent('&clickhouse');
SELECT encodeXMLComponent('\'foo\'');
2020-12-27 11:21:58 +00:00
```
Result:
2023-04-19 20:04:59 +00:00
```result
2020-12-27 20:49:05 +00:00
Hello, &quot;world&quot;!
&lt;123&gt;
&amp;clickhouse
&apos;foo&apos;
2020-12-27 11:21:58 +00:00
```
2022-06-02 10:55:18 +00:00
## decodeXMLComponent
2021-02-12 19:28:03 +00:00
2023-04-19 20:04:59 +00:00
Un-escapes substrings with special meaning in XML. These substrings are: `&quot;` `&amp;` `&apos;` `&gt;` `&lt;`
2021-02-15 18:25:32 +00:00
This function also replaces numeric character references with Unicode characters. Both decimal (like `&#10003;`) and hexadecimal (`&#x2713;`) forms are supported.
2021-02-12 19:28:03 +00:00
**Syntax**
``` sql
decodeXMLComponent(x)
```
**Arguments**
2021-02-12 19:28:03 +00:00
- `x` — An input string. [String](../data-types/string.md).
2021-02-12 19:28:03 +00:00
**Returned value**
- The un-escaped string. [String](../data-types/string.md).
2021-02-12 19:28:03 +00:00
**Example**
``` sql
SELECT decodeXMLComponent('&apos;foo&apos;');
SELECT decodeXMLComponent('&lt; &#x3A3; &gt;');
```
Result:
2023-04-19 20:04:59 +00:00
```result
2021-07-29 15:20:55 +00:00
'foo'
2021-02-12 19:28:03 +00:00
< Σ >
```
2023-08-31 04:42:51 +00:00
## decodeHTMLComponent
Un-escapes substrings with special meaning in HTML. For example: `&hbar;` `&gt;` `&diamondsuit;` `&heartsuit;` `&lt;` etc.
This function also replaces numeric character references with Unicode characters. Both decimal (like `&#10003;`) and hexadecimal (`&#x2713;`) forms are supported.
**Syntax**
``` sql
2023-12-14 02:54:52 +00:00
decodeHTMLComponent(x)
2023-08-31 04:42:51 +00:00
```
**Arguments**
- `x` — An input string. [String](../data-types/string.md).
2023-08-31 04:42:51 +00:00
**Returned value**
- The un-escaped string. [String](../data-types/string.md).
2023-08-31 04:42:51 +00:00
**Example**
``` sql
SELECT decodeHTMLComponent(''CH');
2023-12-14 04:32:12 +00:00
SELECT decodeHTMLComponent('I&heartsuit;ClickHouse');
2023-08-31 04:42:51 +00:00
```
Result:
```result
'CH'
I♥ClickHouse'
```
2022-06-02 10:55:18 +00:00
## extractTextFromHTML
2021-03-28 18:42:04 +00:00
2023-04-19 20:04:59 +00:00
This function extracts plain text from HTML or XHTML.
2023-04-19 20:04:59 +00:00
It does not conform 100% to the HTML, XML or XHTML specification but the implementation is reasonably accurate and fast. The rules are the following:
1. Comments are skipped. Example: `<!-- test -->`. Comment must end with `-->`. Nested comments are disallowed.
2021-04-07 18:35:11 +00:00
Note: constructions like `<!-->` and `<!--->` are not valid comments in HTML but they are skipped by other rules.
2023-04-19 20:04:59 +00:00
2. CDATA is pasted verbatim. Note: CDATA is XML/XHTML-specific and processed on a "best-effort" basis.
2021-04-07 18:35:11 +00:00
3. `script` and `style` elements are removed with all their content. Note: it is assumed that closing tag cannot appear inside content. For example, in JS string literal has to be escaped like `"<\/script>"`.
2021-04-07 19:23:53 +00:00
Note: comments and CDATA are possible inside `script` or `style` - then closing tags are not searched inside CDATA. Example: `<script><![CDATA[</script>]]></script>`. But they are still searched inside comments. Sometimes it becomes complicated: `<script>var x = "<!--"; </script> var y = "-->"; alert(x + y);</script>`
2021-04-06 19:10:22 +00:00
Note: `script` and `style` can be the names of XML namespaces - then they are not treated like usual `script` or `style` elements. Example: `<script:a>Hello</script:a>`.
Note: whitespaces are possible after closing tag name: `</script >` but not before: `< / script>`.
4. Other tags or tag-like elements are skipped without inner content. Example: `<a>.</a>`
2021-04-07 18:35:11 +00:00
Note: it is expected that this HTML is illegal: `<a test=">"></a>`
Note: it also skips something like tags: `<>`, `<!>`, etc.
Note: tag without end is skipped to the end of input: `<hello `
2021-04-06 19:10:22 +00:00
5. HTML and XML entities are not decoded. They must be processed by separate function.
6. Whitespaces in the text are collapsed or inserted by specific rules.
- Whitespaces at the beginning and at the end are removed.
- Consecutive whitespaces are collapsed.
- But if the text is separated by other elements and there is no whitespace, it is inserted.
2021-04-07 18:35:11 +00:00
- It may cause unnatural examples: `Hello<b>world</b>`, `Hello<!-- -->world` - there is no whitespace in HTML, but the function inserts it. Also consider: `Hello<p>world</p>`, `Hello<br>world`. This behavior is reasonable for data analysis, e.g. to convert HTML to a bag of words.
7. Also note that correct handling of whitespaces requires the support of `<pre></pre>` and CSS `display` and `white-space` properties.
2021-03-28 18:42:04 +00:00
**Syntax**
``` sql
extractTextFromHTML(x)
```
2021-04-03 16:16:56 +00:00
**Arguments**
2021-03-28 18:42:04 +00:00
- `x` — input text. [String](../data-types/string.md).
2021-03-28 18:42:04 +00:00
**Returned value**
- Extracted text. [String](../data-types/string.md).
2021-03-28 18:42:04 +00:00
**Example**
2021-04-03 19:31:24 +00:00
The first example contains several tags and a comment and also shows whitespace processing.
The second example shows `CDATA` and `script` tag processing.
2021-04-07 18:35:11 +00:00
In the third example text is extracted from the full HTML response received by the [url](../../sql-reference/table-functions/url.md) function.
2021-04-03 16:16:56 +00:00
2021-03-28 18:42:04 +00:00
``` sql
SELECT extractTextFromHTML(' <p> A text <i>with</i><b>tags</b>. <!-- comments --> </p> ');
2021-04-03 16:16:56 +00:00
SELECT extractTextFromHTML('<![CDATA[The content within <b>CDATA</b>]]> <script>alert("Script");</script>');
2021-04-05 19:37:01 +00:00
SELECT extractTextFromHTML(html) FROM url('http://www.donothingfor2minutes.com/', RawBLOB, 'html String');
2021-03-28 18:42:04 +00:00
```
Result:
2023-04-19 20:04:59 +00:00
```result
A text with tags .
2021-04-03 16:16:56 +00:00
The content within <b>CDATA</b>
2021-04-05 19:37:01 +00:00
Do Nothing for 2 Minutes 2:00 &nbsp;
2021-04-03 16:16:56 +00:00
```
2022-10-25 04:07:07 +00:00
2023-04-19 20:04:59 +00:00
## ascii {#ascii}
2022-10-25 04:07:07 +00:00
2023-04-19 20:04:59 +00:00
Returns the ASCII code point (as Int32) of the first character of string `s`.
2022-10-25 04:07:07 +00:00
2023-04-19 20:04:59 +00:00
If `s` is empty, the result is 0. If the first character is not an ASCII character or not part of the Latin-1 supplement range of UTF-16, the result is undefined.
2022-12-01 02:56:53 +00:00
**Syntax**
2023-04-19 20:04:59 +00:00
```sql
ascii(s)
2022-12-01 02:56:53 +00:00
```
2023-04-09 09:00:20 +00:00
## soundex
Returns the [Soundex code](https://en.wikipedia.org/wiki/Soundex) of a string.
2023-04-09 09:00:20 +00:00
**Syntax**
``` sql
soundex(val)
2023-04-09 09:00:20 +00:00
```
**Arguments**
2024-07-05 21:47:11 +00:00
- `val` — Input value. [String](../data-types/string.md)
2023-04-09 09:00:20 +00:00
**Returned value**
- The Soundex code of the input value. [String](../data-types/string.md)
2023-04-09 09:00:20 +00:00
**Example**
``` sql
select soundex('aksel');
```
Result:
2023-04-19 20:04:59 +00:00
```result
2023-04-09 09:00:20 +00:00
┌─soundex('aksel')─┐
│ A240 │
└──────────────────┘
```
2023-06-30 13:11:06 +00:00
## punycodeEncode
2024-01-03 17:35:37 +00:00
Returns the [Punycode](https://en.wikipedia.org/wiki/Punycode) representation of a string.
2024-01-05 12:18:21 +00:00
The string must be UTF8-encoded, otherwise the behavior is undefined.
**Syntax**
``` sql
punycodeEncode(val)
```
**Arguments**
2024-07-05 21:47:11 +00:00
- `val` — Input value. [String](../data-types/string.md)
**Returned value**
- A Punycode representation of the input value. [String](../data-types/string.md)
**Example**
``` sql
select punycodeEncode('München');
```
Result:
```result
┌─punycodeEncode('München')─┐
│ Mnchen-3ya │
└───────────────────────────┘
```
## punycodeDecode
Returns the UTF8-encoded plaintext of a [Punycode](https://en.wikipedia.org/wiki/Punycode)-encoded string.
If no valid Punycode-encoded string is given, an exception is thrown.
**Syntax**
``` sql
punycodeEncode(val)
```
**Arguments**
2024-07-05 21:47:11 +00:00
- `val` — Punycode-encoded string. [String](../data-types/string.md)
**Returned value**
- The plaintext of the input value. [String](../data-types/string.md)
**Example**
``` sql
select punycodeDecode('Mnchen-3ya');
```
Result:
```result
2024-01-05 12:18:21 +00:00
┌─punycodeDecode('Mnchen-3ya')─┐
│ München │
└──────────────────────────────┘
```
2024-01-05 12:18:21 +00:00
## tryPunycodeDecode
2024-01-05 12:18:21 +00:00
Like `punycodeDecode` but returns an empty string if no valid Punycode-encoded string is given.
2024-01-03 17:35:37 +00:00
## idnaEncode
2024-07-05 21:47:11 +00:00
Returns the ASCII representation (ToASCII algorithm) of a domain name according to the [Internationalized Domain Names in Applications](https://en.wikipedia.org/wiki/Internationalized_domain_name#Internationalizing_Domain_Names_in_Applications) (IDNA) mechanism.
2024-01-05 12:18:21 +00:00
The input string must be UTF-encoded and translatable to an ASCII string, otherwise an exception is thrown.
2024-01-03 17:35:37 +00:00
Note: No percent decoding or trimming of tabs, spaces or control characters is performed.
**Syntax**
```sql
idnaEncode(val)
```
**Arguments**
2024-07-05 21:47:11 +00:00
- `val` — Input value. [String](../data-types/string.md)
2024-01-03 17:35:37 +00:00
**Returned value**
- A ASCII representation according to the IDNA mechanism of the input value. [String](../data-types/string.md)
**Example**
``` sql
select idnaEncode('straße.münchen.de');
```
Result:
```result
┌─idnaEncode('straße.münchen.de')─────┐
│ xn--strae-oqa.xn--mnchen-3ya.de │
└─────────────────────────────────────┘
```
2024-01-05 12:18:21 +00:00
## tryIdnaEncode
2024-01-03 17:35:37 +00:00
2024-01-05 12:18:21 +00:00
Like `idnaEncode` but returns an empty string in case of an error instead of throwing an exception.
2024-01-03 17:35:37 +00:00
## idnaDecode
2024-07-05 21:47:11 +00:00
Returns the Unicode (UTF-8) representation (ToUnicode algorithm) of a domain name according to the [Internationalized Domain Names in Applications](https://en.wikipedia.org/wiki/Internationalized_domain_name#Internationalizing_Domain_Names_in_Applications) (IDNA) mechanism.
2024-01-03 17:35:37 +00:00
In case of an error (e.g. because the input is invalid), the input string is returned.
Note that repeated application of `idnaEncode()` and `idnaDecode()` does not necessarily return the original string due to case normalization.
**Syntax**
```sql
idnaDecode(val)
```
**Arguments**
2024-07-05 21:47:11 +00:00
- `val` — Input value. [String](../data-types/string.md)
2024-01-03 17:35:37 +00:00
**Returned value**
- A Unicode (UTF-8) representation according to the IDNA mechanism of the input value. [String](../data-types/string.md)
**Example**
``` sql
select idnaDecode('xn--strae-oqa.xn--mnchen-3ya.de');
```
Result:
```result
┌─idnaDecode('xn--strae-oqa.xn--mnchen-3ya.de')─┐
│ straße.münchen.de │
└───────────────────────────────────────────────┘
```
## byteHammingDistance
Calculates the [hamming distance](https://en.wikipedia.org/wiki/Hamming_distance) between two byte strings.
**Syntax**
```sql
byteHammingDistance(string1, string2)
```
**Examples**
``` sql
SELECT byteHammingDistance('karolin', 'kathrin');
```
Result:
``` text
┌─byteHammingDistance('karolin', 'kathrin')─┐
│ 3 │
└───────────────────────────────────────────┘
```
2024-07-05 21:47:11 +00:00
Alias: `mismatches`
## stringJaccardIndex
Calculates the [Jaccard similarity index](https://en.wikipedia.org/wiki/Jaccard_index) between two byte strings.
**Syntax**
```sql
stringJaccardIndex(string1, string2)
```
**Examples**
``` sql
SELECT stringJaccardIndex('clickhouse', 'mouse');
```
Result:
``` text
┌─stringJaccardIndex('clickhouse', 'mouse')─┐
│ 0.4 │
└───────────────────────────────────────────┘
```
## stringJaccardIndexUTF8
2024-06-12 12:09:37 +00:00
Like [stringJaccardIndex](#stringjaccardindex) but for UTF8-encoded strings.
## editDistance
Calculates the [edit distance](https://en.wikipedia.org/wiki/Edit_distance) between two byte strings.
**Syntax**
```sql
editDistance(string1, string2)
```
**Examples**
``` sql
SELECT editDistance('clickhouse', 'mouse');
```
Result:
``` text
┌─editDistance('clickhouse', 'mouse')─┐
│ 6 │
└─────────────────────────────────────┘
```
2024-07-05 21:47:11 +00:00
Alias: `levenshteinDistance`
2024-06-14 07:12:31 +00:00
## editDistanceUTF8
Calculates the [edit distance](https://en.wikipedia.org/wiki/Edit_distance) between two UTF8 strings.
**Syntax**
```sql
editDistanceUTF8(string1, string2)
```
**Examples**
``` sql
SELECT editDistanceUTF8('我是谁', '我是我');
```
Result:
``` text
┌─editDistanceUTF8('我是谁', '我是我')──┐
│ 1 │
└─────────────────────────────────────┘
```
2024-07-05 21:47:11 +00:00
Alias: `levenshteinDistanceUTF8`
2024-06-14 07:12:31 +00:00
## damerauLevenshteinDistance
Calculates the [Damerau-Levenshtein distance](https://en.wikipedia.org/wiki/Damerau%E2%80%93Levenshtein_distance) between two byte strings.
**Syntax**
```sql
damerauLevenshteinDistance(string1, string2)
```
**Examples**
``` sql
SELECT damerauLevenshteinDistance('clickhouse', 'mouse');
```
Result:
``` text
┌─damerauLevenshteinDistance('clickhouse', 'mouse')─┐
│ 6 │
└───────────────────────────────────────────────────┘
```
## jaroSimilarity
Calculates the [Jaro similarity](https://en.wikipedia.org/wiki/Jaro%E2%80%93Winkler_distance#Jaro_similarity) between two byte strings.
**Syntax**
```sql
jaroSimilarity(string1, string2)
```
**Examples**
``` sql
SELECT jaroSimilarity('clickhouse', 'click');
```
Result:
``` text
┌─jaroSimilarity('clickhouse', 'click')─┐
│ 0.8333333333333333 │
└───────────────────────────────────────┘
```
## jaroWinklerSimilarity
Calculates the [Jaro-Winkler similarity](https://en.wikipedia.org/wiki/Jaro%E2%80%93Winkler_distance#Jaro%E2%80%93Winkler_similarity) between two byte strings.
**Syntax**
```sql
jaroWinklerSimilarity(string1, string2)
```
**Examples**
``` sql
SELECT jaroWinklerSimilarity('clickhouse', 'click');
```
Result:
``` text
┌─jaroWinklerSimilarity('clickhouse', 'click')─┐
│ 0.8999999999999999 │
└──────────────────────────────────────────────┘
```
2023-06-30 13:11:06 +00:00
## initcap
2023-07-03 11:37:55 +00:00
Convert the first letter of each word to upper case and the rest to lower case. Words are sequences of alphanumeric characters separated by non-alphanumeric characters.
2024-07-06 09:17:21 +00:00
:::note
Because `initCap` converts only the first letter of each word to upper case you may observe unexpected behaviour for words containing apostrophes or capital letters. For example:
```sql
SELECT initCap('mother''s daughter'), initCap('joe McAdam');
```
will return
2023-07-03 11:37:55 +00:00
2024-07-06 09:17:21 +00:00
```response
┌─initCap('mother\'s daughter')─┬─initCap('joe McAdam')─┐
│ Mother'S Daughter │ Joe Mcadam │
└───────────────────────────────┴───────────────────────┘
```
2023-07-03 11:37:55 +00:00
2024-07-06 09:17:21 +00:00
This is a known behaviour, with no plans currently to fix it.
:::
2024-07-05 21:47:11 +00:00
**Syntax**
```sql
initcap(val)
```
**Arguments**
2023-07-03 11:37:55 +00:00
2024-07-05 21:47:11 +00:00
- `val` — Input value. [String](../data-types/string.md).
**Returned value**
- `val` with the first letter of each word converted to upper case. [String](../data-types/string.md).
**Example**
Query:
```sql
SELECT initcap('building for fast');
```
Result:
```text
┌─initcap('building for fast')─┐
│ Building For Fast │
└──────────────────────────────┘
```
2023-07-03 11:37:55 +00:00
2024-07-05 21:47:11 +00:00
## initcapUTF8
2023-07-03 11:37:55 +00:00
2024-07-08 10:58:29 +00:00
Like [initcap](#initcap), `initcapUTF8` converts the first letter of each word to upper case and the rest to lower case. Assumes that the string contains valid UTF-8 encoded text.
2024-07-05 21:47:11 +00:00
If this assumption is violated, no exception is thrown and the result is undefined.
2023-07-03 11:37:55 +00:00
2024-07-05 21:47:11 +00:00
:::note
This function does not detect the language, e.g. for Turkish the result might not be exactly correct (i/İ vs. i/I).
2023-07-03 11:50:26 +00:00
If the length of the UTF-8 byte sequence is different for upper and lower case of a code point, the result may be incorrect for this code point.
2024-07-05 21:47:11 +00:00
:::
**Syntax**
```sql
initcapUTF8(val)
```
**Arguments**
- `val` — Input value. [String](../data-types/string.md).
**Returned value**
- `val` with the first letter of each word converted to upper case. [String](../data-types/string.md).
**Example**
Query:
```sql
SELECT initcapUTF8('не тормозит');
```
Result:
```text
┌─initcapUTF8('не тормозит')─┐
Не Тормозит │
└────────────────────────────┘
```
## firstLine
Returns the first line from a multi-line string.
**Syntax**
```sql
firstLine(val)
```
**Arguments**
2024-07-05 21:47:11 +00:00
- `val` — Input value. [String](../data-types/string.md)
**Returned value**
- The first line of the input value or the whole value if there is no line
separators. [String](../data-types/string.md)
**Example**
```sql
select firstLine('foo\nbar\nbaz');
```
Result:
```result
┌─firstLine('foo\nbar\nbaz')─┐
│ foo │
└────────────────────────────┘
```