You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@doris.apache.org by mo...@apache.org on 2026/10/23 04:22:34 UTC
(doris-website) branch master updated: [i18n](ru) Translate 100 documentation pages (T09 20261022T114000Z-015) (#4452)
This is an automated email from the ASF dual-hosted git repository.
morningman pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/doris-website.git
The following commit(s) were added to refs/heads/master by this push:
new e913ee593aac [i18n](ru) Translate 100 documentation pages (T09 20261022T114000Z-015) (#4452)
e913ee593aac is described below
commit e913ee593aac4c4cdff5bb31998ecc345dc836e0
Author: Mingyu Chen (Rayner) <mo...@gmail.com>
AuthorDate: Fri Oct 23 05:22:28 2026 +0100
[i18n](ru) Translate 100 documentation pages (T09 20261022T114000Z-015) (#4452)
Translate 100 English documentation pages into Russian with local Codex.
Source: `87417f1fefb604bf8a98d1fea0ace4beaccc4b2c`. Model:
`gpt-6.1-sol`; reasoning effort: `xhigh`.
These are machine translations requiring Russian proofreading. Each
document has its own state shard.
Retry summary: 97/100 generated pages passed on the first attempt; 0
pages copied across versions; 103 total model calls. Prompt rules used:
comments, inline-code, code-blocks, numbers, metadata, headings,
glossary.
| Source | Operation | Model calls | Result |
| --- | --- | ---: | --- |
|
`docs/sql-manual/sql-functions/scalar-functions/string-functions/auto-partition-name.md`
| Translate | 1 | Local gates passed |
|
`docs/sql-manual/sql-functions/scalar-functions/string-functions/char-length.md`
| Translate | 1 | Local gates passed |
|
`docs/sql-manual/sql-functions/scalar-functions/string-functions/char.md`
| Translate | 1 | Local gates passed |
|
`docs/sql-manual/sql-functions/scalar-functions/string-functions/compress.md`
| Translate | 1 | Local gates passed |
|
`docs/sql-manual/sql-functions/scalar-functions/string-functions/concat-ws.md`
| Translate | 1 | Local gates passed |
|
`docs/sql-manual/sql-functions/scalar-functions/string-functions/concat.md`
| Translate | 1 | Local gates passed |
|
`docs/sql-manual/sql-functions/scalar-functions/string-functions/count_substrings.md`
| Translate | 1 | Local gates passed |
|
`docs/sql-manual/sql-functions/scalar-functions/string-functions/cut-to-first-significant-subdomain.md`
| Translate | 1 | Local gates passed |
|
`docs/sql-manual/sql-functions/scalar-functions/string-functions/damerau_levenshtein_distance.md`
| Translate | 1 | Local gates passed |
|
`docs/sql-manual/sql-functions/scalar-functions/string-functions/decode.md`
| Translate | 1 | Local gates passed |
|
`docs/sql-manual/sql-functions/scalar-functions/string-functions/digital-masking.md`
| Translate | 1 | Local gates passed |
|
`docs/sql-manual/sql-functions/scalar-functions/string-functions/domain-without-www.md`
| Translate | 2 | Local gates passed |
|
`docs/sql-manual/sql-functions/scalar-functions/string-functions/domain.md`
| Translate | 1 | Local gates passed |
|
`docs/sql-manual/sql-functions/scalar-functions/string-functions/elt.md`
| Translate | 1 | Local gates passed |
|
`docs/sql-manual/sql-functions/scalar-functions/string-functions/encode.md`
| Translate | 1 | Local gates passed |
|
`docs/sql-manual/sql-functions/scalar-functions/string-functions/ends-with.md`
| Translate | 1 | Local gates passed |
|
`docs/sql-manual/sql-functions/scalar-functions/string-functions/export-set.md`
| Translate | 2 | Local gates passed |
|
`docs/sql-manual/sql-functions/scalar-functions/string-functions/extract-url-parameter.md`
| Translate | 1 | Local gates passed |
|
`docs/sql-manual/sql-functions/scalar-functions/string-functions/find-in-set.md`
| Translate | 1 | Local gates passed |
|
`docs/sql-manual/sql-functions/scalar-functions/string-functions/first-significant-subdomain.md`
| Translate | 1 | Local gates passed |
|
`docs/sql-manual/sql-functions/scalar-functions/string-functions/format-number.md`
| Translate | 1 | Local gates passed |
|
`docs/sql-manual/sql-functions/scalar-functions/string-functions/format.md`
| Translate | 1 | Local gates passed |
|
`docs/sql-manual/sql-functions/scalar-functions/string-functions/from-base64.md`
| Translate | 1 | Local gates passed |
|
`docs/sql-manual/sql-functions/scalar-functions/string-functions/hamming_distance.md`
| Translate | 1 | Local gates passed |
|
`docs/sql-manual/sql-functions/scalar-functions/string-functions/hex.md`
| Translate | 1 | Local gates passed |
|
`docs/sql-manual/sql-functions/scalar-functions/string-functions/initcap.md`
| Translate | 1 | Local gates passed |
|
`docs/sql-manual/sql-functions/scalar-functions/string-functions/instr.md`
| Translate | 1 | Local gates passed |
|
`docs/sql-manual/sql-functions/scalar-functions/string-functions/int-to-uuid.md`
| Translate | 1 | Local gates passed |
|
`docs/sql-manual/sql-functions/scalar-functions/string-functions/is-uuid.md`
| Translate | 1 | Local gates passed |
|
`docs/sql-manual/sql-functions/scalar-functions/string-functions/is-valid-utf8.md`
| Translate | 1 | Local gates passed |
|
`docs/sql-manual/sql-functions/scalar-functions/string-functions/lcase.md`
| Translate | 1 | Local gates passed |
|
`docs/sql-manual/sql-functions/scalar-functions/string-functions/length.md`
| Translate | 1 | Local gates passed |
|
`docs/sql-manual/sql-functions/scalar-functions/string-functions/levenshtein.md`
| Translate | 1 | Local gates passed |
|
`docs/sql-manual/sql-functions/scalar-functions/string-functions/locate.md`
| Translate | 1 | Local gates passed |
|
`docs/sql-manual/sql-functions/scalar-functions/string-functions/lpad.md`
| Translate | 1 | Local gates passed |
|
`docs/sql-manual/sql-functions/scalar-functions/string-functions/ltrim-in.md`
| Translate | 1 | Local gates passed |
|
`docs/sql-manual/sql-functions/scalar-functions/string-functions/ltrim.md`
| Translate | 1 | Local gates passed |
|
`docs/sql-manual/sql-functions/scalar-functions/string-functions/make-set.md`
| Translate | 1 | Local gates passed |
|
`docs/sql-manual/sql-functions/scalar-functions/string-functions/mask-first-n.md`
| Translate | 1 | Local gates passed |
|
`docs/sql-manual/sql-functions/scalar-functions/string-functions/mask-last-n.md`
| Translate | 1 | Local gates passed |
|
`docs/sql-manual/sql-functions/scalar-functions/string-functions/mask.md`
| Translate | 1 | Local gates passed |
|
`docs/sql-manual/sql-functions/scalar-functions/string-functions/multi-match-any.md`
| Translate | 1 | Local gates passed |
|
`docs/sql-manual/sql-functions/scalar-functions/string-functions/multi-search-all-positions.md`
| Translate | 1 | Local gates passed |
|
`docs/sql-manual/sql-functions/scalar-functions/string-functions/ngram-search.md`
| Translate | 1 | Local gates passed |
|
`docs/sql-manual/sql-functions/scalar-functions/string-functions/overlay.md`
| Translate | 1 | Local gates passed |
|
`docs/sql-manual/sql-functions/scalar-functions/string-functions/overview.md`
| Translate | 1 | Local gates passed |
|
`docs/sql-manual/sql-functions/scalar-functions/string-functions/parse-data-size.md`
| Translate | 1 | Local gates passed |
|
`docs/sql-manual/sql-functions/scalar-functions/string-functions/parse-url.md`
| Translate | 1 | Local gates passed |
|
`docs/sql-manual/sql-functions/scalar-functions/string-functions/position.md`
| Translate | 1 | Local gates passed |
|
`docs/sql-manual/sql-functions/scalar-functions/string-functions/protocol.md`
| Translate | 1 | Local gates passed |
|
`docs/sql-manual/sql-functions/scalar-functions/string-functions/quote.md`
| Translate | 1 | Local gates passed |
|
`docs/sql-manual/sql-functions/scalar-functions/string-functions/random_bytes.md`
| Translate | 1 | Local gates passed |
|
`docs/sql-manual/sql-functions/scalar-functions/string-functions/regexp-count.md`
| Translate | 1 | Local gates passed |
|
`docs/sql-manual/sql-functions/scalar-functions/string-functions/regexp-extract-all-array.md`
| Translate | 1 | Local gates passed |
|
`docs/sql-manual/sql-functions/scalar-functions/string-functions/regexp-extract-all.md`
| Translate | 1 | Local gates passed |
|
`docs/sql-manual/sql-functions/scalar-functions/string-functions/regexp-extract-or-null.md`
| Translate | 1 | Local gates passed |
|
`docs/sql-manual/sql-functions/scalar-functions/string-functions/regexp-extract.md`
| Translate | 1 | Local gates passed |
|
`docs/sql-manual/sql-functions/scalar-functions/string-functions/regexp-replace-one.md`
| Translate | 1 | Local gates passed |
|
`docs/sql-manual/sql-functions/scalar-functions/string-functions/regexp-replace.md`
| Translate | 1 | Local gates passed |
|
`docs/sql-manual/sql-functions/scalar-functions/string-functions/regexp.md`
| Translate | 2 | Local gates passed |
|
`docs/sql-manual/sql-functions/scalar-functions/string-functions/repeat.md`
| Translate | 1 | Local gates passed |
|
`docs/sql-manual/sql-functions/scalar-functions/string-functions/replace-empty.md`
| Translate | 1 | Local gates passed |
|
`docs/sql-manual/sql-functions/scalar-functions/string-functions/replace.md`
| Translate | 1 | Local gates passed |
|
`docs/sql-manual/sql-functions/scalar-functions/string-functions/reverse.md`
| Translate | 1 | Local gates passed |
|
`docs/sql-manual/sql-functions/scalar-functions/string-functions/rpad.md`
| Translate | 1 | Local gates passed |
|
`docs/sql-manual/sql-functions/scalar-functions/string-functions/rtrim-in.md`
| Translate | 1 | Local gates passed |
|
`docs/sql-manual/sql-functions/scalar-functions/string-functions/rtrim.md`
| Translate | 1 | Local gates passed |
|
`docs/sql-manual/sql-functions/scalar-functions/string-functions/soundex.md`
| Translate | 1 | Local gates passed |
|
`docs/sql-manual/sql-functions/scalar-functions/string-functions/space.md`
| Translate | 1 | Local gates passed |
|
`docs/sql-manual/sql-functions/scalar-functions/string-functions/split-by-regexp.md`
| Translate | 1 | Local gates passed |
|
`docs/sql-manual/sql-functions/scalar-functions/string-functions/split-by-string.md`
| Translate | 1 | Local gates passed |
|
`docs/sql-manual/sql-functions/scalar-functions/string-functions/split-part.md`
| Translate | 1 | Local gates passed |
|
`docs/sql-manual/sql-functions/scalar-functions/string-functions/starts-with.md`
| Translate | 1 | Local gates passed |
|
`docs/sql-manual/sql-functions/scalar-functions/string-functions/strcmp.md`
| Translate | 1 | Local gates passed |
|
`docs/sql-manual/sql-functions/scalar-functions/string-functions/strleft.md`
| Translate | 1 | Local gates passed |
|
`docs/sql-manual/sql-functions/scalar-functions/string-functions/strright.md`
| Translate | 1 | Local gates passed |
|
`docs/sql-manual/sql-functions/scalar-functions/string-functions/sub-replace.md`
| Translate | 1 | Local gates passed |
|
`docs/sql-manual/sql-functions/scalar-functions/string-functions/substring-index.md`
| Translate | 1 | Local gates passed |
|
`docs/sql-manual/sql-functions/scalar-functions/string-functions/substring.md`
| Translate | 1 | Local gates passed |
|
`docs/sql-manual/sql-functions/scalar-functions/string-functions/to-base64.md`
| Translate | 1 | Local gates passed |
|
`docs/sql-manual/sql-functions/scalar-functions/string-functions/tokenize.md`
| Translate | 1 | Local gates passed |
|
`docs/sql-manual/sql-functions/scalar-functions/string-functions/top-level-domain.md`
| Translate | 1 | Local gates passed |
|
`docs/sql-manual/sql-functions/scalar-functions/string-functions/translate.md`
| Translate | 1 | Local gates passed |
|
`docs/sql-manual/sql-functions/scalar-functions/string-functions/trim-in.md`
| Translate | 1 | Local gates passed |
|
`docs/sql-manual/sql-functions/scalar-functions/string-functions/trim.md`
| Translate | 1 | Local gates passed |
|
`docs/sql-manual/sql-functions/scalar-functions/string-functions/ucase.md`
| Translate | 1 | Local gates passed |
|
`docs/sql-manual/sql-functions/scalar-functions/string-functions/uncompress.md`
| Translate | 1 | Local gates passed |
|
`docs/sql-manual/sql-functions/scalar-functions/string-functions/unhex.md`
| Translate | 1 | Local gates passed |
|
`docs/sql-manual/sql-functions/scalar-functions/string-functions/unicode_normalize.md`
| Translate | 1 | Local gates passed |
|
`docs/sql-manual/sql-functions/scalar-functions/string-functions/url-decode.md`
| Translate | 1 | Local gates passed |
|
`docs/sql-manual/sql-functions/scalar-functions/string-functions/url-encode.md`
| Translate | 1 | Local gates passed |
|
`docs/sql-manual/sql-functions/scalar-functions/string-functions/uuid.md`
| Translate | 1 | Local gates passed |
|
`docs/sql-manual/sql-functions/scalar-functions/string-functions/xpath-string.md`
| Translate | 1 | Local gates passed |
|
`docs/sql-manual/sql-functions/scalar-functions/struct-functions/named-struct.md`
| Translate | 1 | Local gates passed |
|
`docs/sql-manual/sql-functions/scalar-functions/struct-functions/struct-element.md`
| Translate | 1 | Local gates passed |
|
`docs/sql-manual/sql-functions/scalar-functions/struct-functions/struct.md`
| Translate | 1 | Local gates passed |
|
`docs/sql-manual/sql-functions/scalar-functions/system-functions/connection-id.md`
| Translate | 1 | Local gates passed |
|
`docs/sql-manual/sql-functions/scalar-functions/system-functions/current-catalog.md`
| Translate | 1 | Local gates passed |
|
`docs/sql-manual/sql-functions/scalar-functions/system-functions/current-user.md`
| Translate | 1 | Local gates passed |
|
`docs/sql-manual/sql-functions/scalar-functions/system-functions/database.md`
| Translate | 1 | Local gates passed |
Validation:
- scope-ru: passed
- configuration-ru: passed
- state-protection-ru: passed
- syntax-ru: passed
- internal-links-ru: passed
Local checks reuse translation state, protection, Markdown/MDX syntax
and internal-link functions for Russian files.
Copied pages skip content, syntax and link rechecks; only file scope,
state identity and hashes are verified.
Local validation does not build the website or run the CI test suites.
GitHub CI runs after a PR is created.
Failures are fed into the next translation prompt, with at most three
total model attempts per page.
The third translation is retained when local checks still fail, as
requested; this does not waive GitHub CI.
Retained warnings:
None.
Remaining blocking local checks: none.
This batch is independent of other translation PRs. The runner continues
without waiting for merge.
<!-- russian-local-t09 source=87417f1fefb604bf8a98d1fea0ace4beaccc4b2c
-->
Co-authored-by: morningman <mo...@apache.org>
---
.../string-functions/auto-partition-name.md | 113 ++++++
.../string-functions/char-length.md | 88 +++++
.../scalar-functions/string-functions/char.md | 85 +++++
.../scalar-functions/string-functions/compress.md | 81 +++++
.../scalar-functions/string-functions/concat-ws.md | 168 +++++++++
.../scalar-functions/string-functions/concat.md | 137 ++++++++
.../string-functions/count_substrings.md | 142 ++++++++
.../cut-to-first-significant-subdomain.md | 68 ++++
.../damerau_levenshtein_distance.md | 168 +++++++++
.../scalar-functions/string-functions/decode.md | 85 +++++
.../string-functions/digital-masking.md | 94 +++++
.../string-functions/domain-without-www.md | 39 +++
.../scalar-functions/string-functions/domain.md | 41 +++
.../scalar-functions/string-functions/elt.md | 140 ++++++++
.../scalar-functions/string-functions/encode.md | 90 +++++
.../scalar-functions/string-functions/ends-with.md | 162 +++++++++
.../string-functions/export-set.md | 161 +++++++++
.../string-functions/extract-url-parameter.md | 48 +++
.../string-functions/find-in-set.md | 163 +++++++++
.../first-significant-subdomain.md | 41 +++
.../string-functions/format-number.md | 87 +++++
.../scalar-functions/string-functions/format.md | 96 ++++++
.../string-functions/from-base64.md | 169 +++++++++
.../string-functions/hamming_distance.md | 37 ++
.../scalar-functions/string-functions/hex.md | 104 ++++++
.../scalar-functions/string-functions/initcap.md | 90 +++++
.../scalar-functions/string-functions/instr.md | 163 +++++++++
.../string-functions/int-to-uuid.md | 57 +++
.../scalar-functions/string-functions/is-uuid.md | 102 ++++++
.../string-functions/is-valid-utf8.md | 146 ++++++++
.../scalar-functions/string-functions/lcase.md | 76 ++++
.../scalar-functions/string-functions/length.md | 151 ++++++++
.../string-functions/levenshtein.md | 156 +++++++++
.../scalar-functions/string-functions/locate.md | 165 +++++++++
.../scalar-functions/string-functions/lpad.md | 151 ++++++++
.../scalar-functions/string-functions/ltrim-in.md | 71 ++++
.../scalar-functions/string-functions/ltrim.md | 78 +++++
.../scalar-functions/string-functions/make-set.md | 115 +++++++
.../string-functions/mask-first-n.md | 166 +++++++++
.../string-functions/mask-last-n.md | 166 +++++++++
.../scalar-functions/string-functions/mask.md | 168 +++++++++
.../string-functions/multi-match-any.md | 74 ++++
.../string-functions/multi-search-all-positions.md | 117 +++++++
.../string-functions/ngram-search.md | 105 ++++++
.../scalar-functions/string-functions/overlay.md | 102 ++++++
.../scalar-functions/string-functions/overview.md | 126 +++++++
.../string-functions/parse-data-size.md | 134 +++++++
.../scalar-functions/string-functions/parse-url.md | 61 ++++
.../scalar-functions/string-functions/position.md | 165 +++++++++
.../scalar-functions/string-functions/protocol.md | 59 ++++
.../scalar-functions/string-functions/quote.md | 106 ++++++
.../string-functions/random_bytes.md | 94 +++++
.../string-functions/regexp-count.md | 249 ++++++++++++++
.../string-functions/regexp-extract-all-array.md | 82 +++++
.../string-functions/regexp-extract-all.md | 305 ++++++++++++++++
.../string-functions/regexp-extract-or-null.md | 342 ++++++++++++++++++
.../string-functions/regexp-extract.md | 295 ++++++++++++++++
.../string-functions/regexp-replace-one.md | 185 ++++++++++
.../string-functions/regexp-replace.md | 184 ++++++++++
.../scalar-functions/string-functions/regexp.md | 383 +++++++++++++++++++++
.../scalar-functions/string-functions/repeat.md | 162 +++++++++
.../string-functions/replace-empty.md | 73 ++++
.../scalar-functions/string-functions/replace.md | 107 ++++++
.../scalar-functions/string-functions/reverse.md | 157 +++++++++
.../scalar-functions/string-functions/rpad.md | 164 +++++++++
.../scalar-functions/string-functions/rtrim-in.md | 124 +++++++
.../scalar-functions/string-functions/rtrim.md | 147 ++++++++
.../scalar-functions/string-functions/soundex.md | 154 +++++++++
.../scalar-functions/string-functions/space.md | 84 +++++
.../string-functions/split-by-regexp.md | 171 +++++++++
.../string-functions/split-by-string.md | 166 +++++++++
.../string-functions/split-part.md | 159 +++++++++
.../string-functions/starts-with.md | 165 +++++++++
.../scalar-functions/string-functions/strcmp.md | 75 ++++
.../scalar-functions/string-functions/strleft.md | 138 ++++++++
.../scalar-functions/string-functions/strright.md | 150 ++++++++
.../string-functions/sub-replace.md | 120 +++++++
.../string-functions/substring-index.md | 155 +++++++++
.../scalar-functions/string-functions/substring.md | 193 +++++++++++
.../scalar-functions/string-functions/to-base64.md | 152 ++++++++
.../scalar-functions/string-functions/tokenize.md | 180 ++++++++++
.../string-functions/top-level-domain.md | 69 ++++
.../scalar-functions/string-functions/translate.md | 155 +++++++++
.../scalar-functions/string-functions/trim-in.md | 125 +++++++
.../scalar-functions/string-functions/trim.md | 147 ++++++++
.../scalar-functions/string-functions/ucase.md | 140 ++++++++
.../string-functions/uncompress.md | 67 ++++
.../scalar-functions/string-functions/unhex.md | 136 ++++++++
.../string-functions/unicode_normalize.md | 137 ++++++++
.../string-functions/url-decode.md | 39 +++
.../string-functions/url-encode.md | 42 +++
.../scalar-functions/string-functions/uuid.md | 62 ++++
.../string-functions/xpath-string.md | 100 ++++++
.../struct-functions/named-struct.md | 112 ++++++
.../struct-functions/struct-element.md | 124 +++++++
.../scalar-functions/struct-functions/struct.md | 98 ++++++
.../system-functions/connection-id.md | 35 ++
.../system-functions/current-catalog.md | 35 ++
.../system-functions/current-user.md | 51 +++
.../scalar-functions/system-functions/database.md | 44 +++
.../string-functions/auto-partition-name.json | 37 ++
.../string-functions/char-length.json | 37 ++
.../scalar-functions/string-functions/char.json | 37 ++
.../string-functions/compress.json | 37 ++
.../string-functions/concat-ws.json | 37 ++
.../scalar-functions/string-functions/concat.json | 37 ++
.../string-functions/count_substrings.json | 37 ++
.../cut-to-first-significant-subdomain.json | 37 ++
.../damerau_levenshtein_distance.json | 37 ++
.../scalar-functions/string-functions/decode.json | 37 ++
.../string-functions/digital-masking.json | 37 ++
.../string-functions/domain-without-www.json | 46 +++
.../scalar-functions/string-functions/domain.json | 37 ++
.../scalar-functions/string-functions/elt.json | 37 ++
.../scalar-functions/string-functions/encode.json | 37 ++
.../string-functions/ends-with.json | 37 ++
.../string-functions/export-set.json | 46 +++
.../string-functions/extract-url-parameter.json | 37 ++
.../string-functions/find-in-set.json | 37 ++
.../first-significant-subdomain.json | 37 ++
.../string-functions/format-number.json | 37 ++
.../scalar-functions/string-functions/format.json | 37 ++
.../string-functions/from-base64.json | 37 ++
.../string-functions/hamming_distance.json | 37 ++
.../scalar-functions/string-functions/hex.json | 37 ++
.../scalar-functions/string-functions/initcap.json | 37 ++
.../scalar-functions/string-functions/instr.json | 37 ++
.../string-functions/int-to-uuid.json | 37 ++
.../scalar-functions/string-functions/is-uuid.json | 37 ++
.../string-functions/is-valid-utf8.json | 37 ++
.../scalar-functions/string-functions/lcase.json | 37 ++
.../scalar-functions/string-functions/length.json | 37 ++
.../string-functions/levenshtein.json | 37 ++
.../scalar-functions/string-functions/locate.json | 37 ++
.../scalar-functions/string-functions/lpad.json | 37 ++
.../string-functions/ltrim-in.json | 37 ++
.../scalar-functions/string-functions/ltrim.json | 37 ++
.../string-functions/make-set.json | 37 ++
.../string-functions/mask-first-n.json | 37 ++
.../string-functions/mask-last-n.json | 37 ++
.../scalar-functions/string-functions/mask.json | 37 ++
.../string-functions/multi-match-any.json | 37 ++
.../multi-search-all-positions.json | 37 ++
.../string-functions/ngram-search.json | 37 ++
.../scalar-functions/string-functions/overlay.json | 37 ++
.../string-functions/overview.json | 37 ++
.../string-functions/parse-data-size.json | 37 ++
.../string-functions/parse-url.json | 37 ++
.../string-functions/position.json | 37 ++
.../string-functions/protocol.json | 37 ++
.../scalar-functions/string-functions/quote.json | 37 ++
.../string-functions/random_bytes.json | 37 ++
.../string-functions/regexp-count.json | 37 ++
.../string-functions/regexp-extract-all-array.json | 37 ++
.../string-functions/regexp-extract-all.json | 37 ++
.../string-functions/regexp-extract-or-null.json | 37 ++
.../string-functions/regexp-extract.json | 37 ++
.../string-functions/regexp-replace-one.json | 37 ++
.../string-functions/regexp-replace.json | 37 ++
.../scalar-functions/string-functions/regexp.json | 46 +++
.../scalar-functions/string-functions/repeat.json | 37 ++
.../string-functions/replace-empty.json | 37 ++
.../scalar-functions/string-functions/replace.json | 37 ++
.../scalar-functions/string-functions/reverse.json | 37 ++
.../scalar-functions/string-functions/rpad.json | 37 ++
.../string-functions/rtrim-in.json | 37 ++
.../scalar-functions/string-functions/rtrim.json | 37 ++
.../scalar-functions/string-functions/soundex.json | 37 ++
.../scalar-functions/string-functions/space.json | 37 ++
.../string-functions/split-by-regexp.json | 37 ++
.../string-functions/split-by-string.json | 37 ++
.../string-functions/split-part.json | 37 ++
.../string-functions/starts-with.json | 37 ++
.../scalar-functions/string-functions/strcmp.json | 37 ++
.../scalar-functions/string-functions/strleft.json | 37 ++
.../string-functions/strright.json | 37 ++
.../string-functions/sub-replace.json | 37 ++
.../string-functions/substring-index.json | 37 ++
.../string-functions/substring.json | 37 ++
.../string-functions/to-base64.json | 37 ++
.../string-functions/tokenize.json | 37 ++
.../string-functions/top-level-domain.json | 37 ++
.../string-functions/translate.json | 37 ++
.../scalar-functions/string-functions/trim-in.json | 37 ++
.../scalar-functions/string-functions/trim.json | 37 ++
.../scalar-functions/string-functions/ucase.json | 37 ++
.../string-functions/uncompress.json | 37 ++
.../scalar-functions/string-functions/unhex.json | 37 ++
.../string-functions/unicode_normalize.json | 37 ++
.../string-functions/url-decode.json | 37 ++
.../string-functions/url-encode.json | 37 ++
.../scalar-functions/string-functions/uuid.json | 37 ++
.../string-functions/xpath-string.json | 37 ++
.../struct-functions/named-struct.json | 37 ++
.../struct-functions/struct-element.json | 37 ++
.../scalar-functions/struct-functions/struct.json | 37 ++
.../system-functions/connection-id.json | 37 ++
.../system-functions/current-catalog.json | 37 ++
.../system-functions/current-user.json | 37 ++
.../system-functions/database.json | 37 ++
200 files changed, 16237 insertions(+)
diff --git a/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/string-functions/auto-partition-name.md b/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/string-functions/auto-partition-name.md
new file mode 100644
index 000000000000..d509860bdea4
--- /dev/null
+++ b/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/string-functions/auto-partition-name.md
@@ -0,0 +1,113 @@
+---
+{
+ "title": "AUTO_PARTITION_NAME",
+ "language": "ru",
+ "description": "Функция AUTO_PARTITION_NAME используется для формирования имён партиций при автоматическом партиционировании. Она поддерживает два режима: в режиме RANGE имена партиций формируются на основе единиц времени, а в режиме LIST имена партиций формируются на основе строковых значений."
+}
+---
+
+## Описание {#description}
+
+Функция AUTO_PARTITION_NAME используется для формирования имён партиций при автоматическом партиционировании. Она поддерживает два режима: в режиме RANGE имена партиций формируются на основе единиц времени, а в режиме LIST имена партиций формируются на основе строковых значений.
+
+Поддерживается начиная с Apache Doris 2.1.6.
+
+## Синтаксис {#syntax}
+
+```sql
+AUTO_PARTITION_NAME('RANGE', <unit>, <datetime>)
+AUTO_PARTITION_NAME('LIST', <value>[, <value> ...])
+```
+
+## Параметры {#parameters}
+
+| Параметр | Описание |
+| ----------- | ----------------------------------------- |
+| `'RANGE'` | Режим партиционирования RANGE, в котором имена партиций формируются на основе времени |
+| `'LIST'` | Режим партиционирования LIST, в котором имена партиций формируются на основе строковых значений |
+| `<unit>` | Единица времени для режима RANGE: `year`, `month`, `day`, `hour`, `minute`, `second`. Тип: VARCHAR |
+| `<datetime>` | Значение даты и времени для режима RANGE. Тип: DATETIME |
+| `<value>` | Значение партиции для режима LIST (можно указать несколько значений). Тип: VARCHAR |
+
+## Возвращаемое значение {#return-value}
+
+Возвращает значение типа VARCHAR, представляющее сформированное имя партиции.
+
+Особые случаи:
+- Режим RANGE: имя партиции имеет формат `pYYYYMMDDHHMMSS` и усекается до точности, соответствующей указанной единице времени
+- Режим LIST: имя партиции имеет формат `p<value><length>`, несколько значений разделяются указанием длины
+- Если параметры недопустимы, возвращается ошибка
+
+## Примеры {#examples}
+
+1. Базовое использование: RANGE по дням
+```sql
+SELECT auto_partition_name('range', 'day', '2022-12-12 19:20:30');
+```
+```text
++------------------------------------------------------------+
+| auto_partition_name('range', 'day', '2022-12-12 19:20:30') |
++------------------------------------------------------------+
+| p20221212000000 |
++------------------------------------------------------------+
+```
+
+2. RANGE по месяцам
+```sql
+SELECT auto_partition_name('range', 'month', '2022-12-12 19:20:30');
+```
+```text
++--------------------------------------------------------------+
+| auto_partition_name('range', 'month', '2022-12-12 19:20:30') |
++--------------------------------------------------------------+
+| p20221201000000 |
++--------------------------------------------------------------+
+```
+
+3. LIST с одним значением
+```sql
+SELECT auto_partition_name('list', 'helloworld');
+```
+```text
++-------------------------------------------+
+| auto_partition_name('list', 'helloworld') |
++-------------------------------------------+
+| phelloworld10 |
++-------------------------------------------+
+```
+
+4. LIST с несколькими значениями
+```sql
+SELECT auto_partition_name('list', 'hello', 'world');
+```
+```text
++-----------------------------------------------+
+| auto_partition_name('list', 'hello', 'world') |
++-----------------------------------------------+
+| phello5world5 |
++-----------------------------------------------+
+```
+
+5. Поддержка специальных символов UTF-8: режим LIST
+```sql
+SELECT auto_partition_name('list', 'ṭṛì', 'ḍḍumai');
+```
+```text
++-------------------------------------------------------+
+| auto_partition_name('list', 'ṭṛì', 'ḍḍumai') |
++-------------------------------------------------------+
+| p1e6d1e5bec31e0d1e0dumai6 |
++-------------------------------------------------------+
+```
+
+6. Недопустимое значение параметра единицы времени
+```sql
+SELECT auto_partition_name('range', 'years', '2022-12-12');
+```
+```text
+ERROR 1105 (HY000): errCode = 2, detailMessage = range auto_partition_name must accept year|month|day|hour|minute|second for 2nd argument
+```
+
+### Ключевые слова {#keywords}
+
+ AUTO_PARTITION_NAME,AUTO,PARTITION,NAME
diff --git a/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/string-functions/char-length.md b/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/string-functions/char-length.md
new file mode 100644
index 000000000000..0d5d10511968
--- /dev/null
+++ b/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/string-functions/char-length.md
@@ -0,0 +1,88 @@
+---
+{
+ "title": "CHAR_LENGTH",
+ "language": "ru",
+ "description": "Функция CHAR_LENGTH вычисляет количество символов (не байтов) в строке. Для многобайтовых символов (например, китайских иероглифов) она возвращает количество символов."
+}
+---
+
+## Описание {#description}
+
+Функция CHAR_LENGTH вычисляет количество символов (не байтов) в строке. Для многобайтовых символов (например, китайских иероглифов) она возвращает количество символов.
+
+В настоящее время поддерживается только кодировка UTF-8.
+
+## Псевдоним {#alias}
+
+- CHARACTER_LENGTH
+
+## Синтаксис {#syntax}
+
+```sql
+CHAR_LENGTH(<str>)
+```
+
+## Параметры {#parameters}
+
+| Параметр | Описание |
+| ------- | ----------------------------------------- |
+| `<str>` | Строка, для которой требуется вычислить количество символов. Тип: VARCHAR |
+
+## Возвращаемое значение {#return-value}
+
+Возвращает значение типа INT, представляющее количество символов в строке.
+
+Особые случаи:
+- Если параметр равен NULL, возвращает NULL
+- Для пустой строки возвращает 0
+- Каждый многобайтовый символ UTF-8 считается за 1 символ
+
+## Примеры {#examples}
+
+1. Английские символы
+```sql
+SELECT CHAR_LENGTH('hello');
+```
+```text
++----------------------+
+| char_length('hello') |
++----------------------+
+| 5 |
++----------------------+
+```
+
+2. Китайские иероглифы (каждый китайский иероглиф считается одним символом)
+```sql
+SELECT CHAR_LENGTH('中国');
+```
+```text
++----------------------+
+| char_length('中国') |
++----------------------+
+| 2 |
++----------------------+
+```
+
+3. Обработка значения NULL
+```sql
+SELECT CHAR_LENGTH(NULL);
+```
+```text
++--------------------+
+| char_length(NULL) |
++--------------------+
+| NULL |
++--------------------+
+```
+
+4. Сравнение с функцией LENGTH (LENGTH возвращает количество байтов)
+```sql
+SELECT CHAR_LENGTH('中国') AS char_len, LENGTH('中国') AS byte_len;
+```
+```text
++----------+----------+
+| char_len | byte_len |
++----------+----------+
+| 2 | 6 |
++----------+----------+
+```
diff --git a/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/string-functions/char.md b/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/string-functions/char.md
new file mode 100644
index 000000000000..dd85922f3ef1
--- /dev/null
+++ b/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/string-functions/char.md
@@ -0,0 +1,85 @@
+---
+{
+ "title": "CHAR | Строковые функции",
+ "language": "ru",
+ "description": "Функция CHAR интерпретирует каждый аргумент как целое число и возвращает строку из символов, соответствующих этим целочисленным кодам.",
+ "sidebar_label": "CHAR"
+}
+---
+
+# CHAR {#char}
+
+## Описание {#description}
+
+Функция CHAR интерпретирует каждый аргумент как целое число и возвращает строку из символов, соответствующих этим целочисленным кодам.
+
+## Синтаксис {#syntax}
+
+```sql
+CHAR(<expr>[, <expr> ...] [USING <charset_name>])
+```
+
+## Параметры {#parameters}
+
+| Параметр | Описание |
+| ------------------ | ----------------------------------------- |
+| `<expr>` | Целочисленный код, преобразуемый в символ. Тип: INT |
+
+## Возвращаемое значение {#return-value}
+
+Возвращает значение типа VARCHAR: строку из символов, соответствующих целочисленным кодам, переданным в аргументах.
+
+Особые случаи:
+- Если какой-либо аргумент равен NULL, возвращает пустую строку
+- Если результирующая строка недопустима для заданного набора символов, возвращает NULL
+- Аргументы со значением больше 255 преобразуются в многобайтовые символы. Например, `CHAR(15049882)` эквивалентно `CHAR(229, 164, 154)`
+
+## Примеры {#examples}
+
+1. Базовое использование: формирование символов ASCII
+```sql
+SELECT CHAR(68, 111, 114, 105, 115);
+```
+```text
++--------------------------------------+
+| CHAR(68, 111, 114, 105, 115) |
++--------------------------------------+
+| Doris |
++--------------------------------------+
+```
+
+2. Многобайтовые символы UTF-8 (китайские)
+```sql
+SELECT CHAR(15049882, 15179199, 14989469);
+```
+```text
++--------------------------------------------+
+| CHAR(15049882, 15179199, 14989469) |
++--------------------------------------------+
+| 多睿丝 |
++--------------------------------------------+
+```
+
+3. Недопустимый символ приводит к возврату NULL
+```sql
+SELECT CHAR(255);
+```
+```text
++-------------------+
+| CHAR(255) |
++-------------------+
+| NULL |
++-------------------+
+```
+
+4. Обработка значения NULL
+```sql
+SELECT CHAR(NULL);
+```
+```text
++------------+
+| CHAR(NULL) |
++------------+
+| |
++------------+
+```
diff --git a/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/string-functions/compress.md b/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/string-functions/compress.md
new file mode 100644
index 000000000000..1d2592fa7af9
--- /dev/null
+++ b/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/string-functions/compress.md
@@ -0,0 +1,81 @@
+---
+{
+ "title": "COMPRESS",
+ "language": "ru",
+ "description": "Функция COMPRESS сжимает строку с помощью алгоритма сжатия zlib, возвращая двоичные данные."
+}
+---
+
+## Описание {#description}
+
+Функция COMPRESS сжимает строку с помощью алгоритма сжатия zlib, возвращая двоичные данные. Сжатые данные можно распаковать обратно в исходную строку с помощью функции UNCOMPRESS.
+
+## Синтаксис {#syntax}
+
+```sql
+COMPRESS(<str>)
+```
+
+## Параметры {#parameters}
+
+| Параметр | Описание |
+| -------- | ----------------------------------------- |
+| `<str>` | Строка, которую нужно сжать. Тип: VARCHAR |
+
+## Возвращаемое значение {#return-value}
+
+Возвращает значение типа VARCHAR, содержащее сжатые двоичные данные (нечитаемые для человека).
+
+Особые случаи:
+- Если параметр равен NULL, возвращает NULL
+- Если на вход подана пустая строка `''`, возвращает пустую строку `''`
+
+## Примеры {#examples}
+
+1. Базовое использование: сжатие и распаковка
+```sql
+SELECT uncompress(compress('hello'));
+```
+```text
++-------------------------------+
+| uncompress(compress('hello')) |
++-------------------------------+
+| hello |
++-------------------------------+
+```
+
+2. Обработка пустой строки
+```sql
+SELECT compress('');
+```
+```text
++--------------+
+| compress('') |
++--------------+
+| |
++--------------+
+```
+
+3. Обработка значения NULL
+```sql
+SELECT compress(NULL);
+```
+```text
++----------------+
+| compress(NULL) |
++----------------+
+| NULL |
++----------------+
+```
+
+4. Проверка символов UTF-8
+```sql
+SELECT uncompress(compress('ṭṛì'));
+```
+```text
++----------------------------------+
+| uncompress(compress('ṭṛì')) |
++----------------------------------+
+| ṭṛì |
++----------------------------------+
+```
diff --git a/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/string-functions/concat-ws.md b/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/string-functions/concat-ws.md
new file mode 100644
index 000000000000..f47defe91c83
--- /dev/null
+++ b/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/string-functions/concat-ws.md
@@ -0,0 +1,168 @@
+---
+{
+ "title": "CONCAT_WS",
+ "language": "ru",
+ "description": "Функция CONCATWS (конкатенация с разделителем) объединяет несколько строк или массивов с помощью указанного разделителя. В отличие от функции CONCAT,"
+}
+---
+
+## Описание {#description}
+
+Функция CONCAT_WS (конкатенация с разделителем) объединяет несколько строк или массивов с помощью указанного разделителя. В отличие от функции CONCAT, CONCAT_WS автоматически пропускает значения NULL (но не пустые строки) и вставляет разделитель между значениями, отличными от NULL. Функция поддерживает режимы со строковыми аргументами и с аргументами в виде массивов и удобна для формирования данных в формате CSV, объединения частей пути и создания списков тегов.
+
+## Синтаксис {#syntax}
+
+```sql
+-- String mode
+CONCAT_WS(<sep>, <str> [, <str> ...])
+
+-- Array mode
+CONCAT_WS(<sep>, <array> [, <array> ...])
+```
+
+## Параметры {#parameters}
+
+| Параметр | Описание |
+|-------|-----------------|
+| `<sep>` | Строка-разделитель для объединения частей. Тип: VARCHAR |
+| `<str>` | Строковые аргументы для объединения. Тип: VARCHAR |
+| `<array>` | Аргументы в виде массивов для объединения; элементы массивов должны быть строкового типа. Тип: ARRAY<VARCHAR> |
+
+## Возвращаемое значение {#return-value}
+
+Возвращает значение типа VARCHAR, представляющее собой строку, объединённую с помощью разделителей.
+
+Правила объединения:
+- Первый аргумент используется как разделитель при объединении последующих аргументов
+- Значения NULL автоматически пропускаются, а пустые строки сохраняются
+- Поддерживаются строковые аргументы или аргументы в виде массивов, но смешивать их нельзя
+- Поддерживаются многобайтовые символы UTF-8 в разделителях и содержимом
+
+Особые случаи:
+- Если разделитель равен NULL, возвращается NULL
+- Если все объединяемые аргументы равны NULL, возвращается пустая строка
+- В режиме массивов элементы NULL пропускаются, а элементы с пустыми строками сохраняются
+- Если среди нескольких переданных массивов есть массивы со значением NULL, возвращается пустая строка
+- Смешивать строковые аргументы и аргументы в виде массивов не допускается
+
+## Примеры {#examples}
+
+1. Простое объединение строк
+```sql
+SELECT CONCAT_WS(',', 'apple', 'banana', 'orange'), CONCAT_WS('-', 'hello', 'world');
+```
+```text
++-------------------------------------------+----------------------------------+
+| CONCAT_WS(',', 'apple', 'banana', 'orange') | CONCAT_WS('-', 'hello', 'world') |
++-------------------------------------------+----------------------------------+
+| apple,banana,orange | hello-world |
++-------------------------------------------+----------------------------------+
+```
+
+2. Обработка разделителя NULL
+```sql
+SELECT CONCAT_WS(NULL, 'd', 'is'), CONCAT_WS('or', 'd', NULL, 'is');
+```
+```text
++----------------------------+----------------------------------+
+| CONCAT_WS(NULL, 'd', 'is') | CONCAT_WS('or', 'd', NULL, 'is') |
++----------------------------+----------------------------------+
+| NULL | doris |
++----------------------------+----------------------------------+
+```
+
+3. Обработка пустых строк (пустые строки сохраняются)
+```sql
+SELECT CONCAT_WS('|', 'hello', '', 'world', NULL), CONCAT_WS(',', '', 'test', '');
+```
+```text
++--------------------------------------------+-------------------------------+
+| CONCAT_WS('|', 'hello', '', 'world', NULL) | CONCAT_WS(',', '', 'test', '') |
++--------------------------------------------+-------------------------------+
+| hello||world | ,test, |
++--------------------------------------------+-------------------------------+
+```
+
+4. Все значения равны NULL
+```sql
+SELECT CONCAT_WS('x', NULL, NULL), CONCAT_WS('-', NULL, NULL, NULL);
+```
+```text
++----------------------------+---------------------------------+
+| CONCAT_WS('x', NULL, NULL) | CONCAT_WS('-', NULL, NULL, NULL) |
++----------------------------+---------------------------------+
+| | |
++----------------------------+---------------------------------+
+```
+
+5. Основы использования режима массивов
+```sql
+SELECT CONCAT_WS('or', ['d', 'is']), CONCAT_WS('-', ['apple', 'banana', 'cherry']);
+```
+```text
++------------------------------+--------------------------------------------+
+| CONCAT_WS('or', ['d', 'is']) | CONCAT_WS('-', ['apple', 'banana', 'cherry']) |
++------------------------------+--------------------------------------------+
+| doris | apple-banana-cherry |
++------------------------------+--------------------------------------------+
+```
+
+6. Значения NULL в массивах
+```sql
+SELECT CONCAT_WS('or', ['d', NULL, 'is']), CONCAT_WS(',', [NULL, 'a', 'b', NULL, 'c']);
+```
+```text
++------------------------------------+------------------------------------------+
+| CONCAT_WS('or', ['d', NULL, 'is']) | CONCAT_WS(',', [NULL, 'a', 'b', NULL, 'c']) |
++------------------------------------+------------------------------------------+
+| doris | a,b,c |
++------------------------------------+------------------------------------------+
+```
+
+7. Объединение нескольких массивов
+```sql
+SELECT CONCAT_WS('-', ['a', 'b'], ['c', NULL], ['d']), CONCAT_WS('|', ['x'], ['y', 'z']);
+```
+```text
++------------------------------------------------+----------------------------------+
+| CONCAT_WS('-', ['a', 'b'], ['c', NULL], ['d']) | CONCAT_WS('|', ['x'], ['y', 'z']) |
++------------------------------------------------+----------------------------------+
+| a-b-c-d | x|y|z |
++------------------------------------------------+----------------------------------+
+```
+
+8. Массив NULL среди нескольких массивов
+```sql
+SELECT CONCAT_WS('-', ['a', 'b'], NULL, ['c', NULL], ['d']);
+```
+```text
++-----------------------------------------------------+
+| CONCAT_WS('-', ['a', 'b'], NULL, ['c', NULL], ['d']) |
++-----------------------------------------------------+
+| |
++-----------------------------------------------------+
+```
+
+9. Обработка многобайтовых символов UTF-8
+```sql
+SELECT CONCAT_WS('x', 'ṭṛì', 'ḍḍumai'), CONCAT_WS('→', ['ṭṛì', 'ḍḍumai', 'hello']);
+```
+```text
++-------------------------------+----------------------------------------------+
+| CONCAT_WS('x', 'ṭṛì', 'ḍḍumai') | CONCAT_WS('→', ['ṭṛì', 'ḍḍumai', 'hello']) |
++-------------------------------+----------------------------------------------+
+| ṭṛìxḍḍumai | ṭṛì→ḍḍumai→hello |
++-------------------------------+----------------------------------------------+
+```
+
+10. Формирование данных в формате CSV и объединение частей пути
+```sql
+SELECT CONCAT_WS(',', 'Name', 'Age', 'City'), CONCAT_WS('/', 'home', 'user', 'documents', 'file.txt');
+```
+```text
++------------------------------------+--------------------------------------------------------+
+| CONCAT_WS(',', 'Name', 'Age', 'City') | CONCAT_WS('/', 'home', 'user', 'documents', 'file.txt') |
++------------------------------------+--------------------------------------------------------+
+| Name,Age,City | home/user/documents/file.txt |
++------------------------------------+--------------------------------------------------------+
+```
diff --git a/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/string-functions/concat.md b/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/string-functions/concat.md
new file mode 100644
index 000000000000..7ab451614616
--- /dev/null
+++ b/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/string-functions/concat.md
@@ -0,0 +1,137 @@
+---
+{
+ "title": "CONCAT",
+ "language": "ru",
+ "description": "Функция CONCAT последовательно объединяет несколько строк в одну."
+}
+---
+
+## Описание {#description}
+
+Функция CONCAT последовательно объединяет несколько строк в одну. Она принимает переменное число аргументов и относится к базовым и наиболее часто используемым функциям обработки строк. Она широко применяется для объединения данных, формирования отчётов и динамического построения SQL-запросов. Обратите внимание: если хотя бы один аргумент равен NULL, весь результат будет NULL.
+
+## Синтаксис {#syntax}
+
+```sql
+CONCAT(<expr> [, <expr> ...])
+```
+
+## Параметры {#parameters}
+
+| Параметр | Описание |
+|----------|--------------|
+| `<expr>` | Строковое выражение для объединения: строковая константа, имя столбца или другое выражение. Тип: VARCHAR |
+
+## Возвращаемое значение {#return-value}
+
+Возвращает значение типа VARCHAR, представляющее собой строку, полученную объединением всех аргументов.
+
+Правила объединения:
+- Строки объединяются в порядке передачи аргументов
+- Поддерживается любое число аргументов (не менее 1)
+- Поддерживается корректное объединение многобайтовых символов UTF-8
+- Числа и значения других типов автоматически преобразуются в строки
+
+Особые случаи:
+- Если хотя бы один аргумент равен NULL, возвращается NULL (это основное отличие от CONCAT_WS)
+- Если аргументы не указаны, возникает синтаксическая ошибка
+- Аргументы с пустыми строками не влияют на результат объединения
+- Допускается сочетание строковых значений со значениями других типов
+
+## Примеры {#examples}
+
+1. Простое объединение строк
+```sql
+SELECT CONCAT('a', 'b'), CONCAT('a', 'b', 'c');
+```
+```text
++------------------+-----------------------+
+| CONCAT('a', 'b') | CONCAT('a', 'b', 'c') |
++------------------+-----------------------+
+| ab | abc |
++------------------+-----------------------+
+```
+
+2. Обработка значений NULL (ключевая особенность)
+```sql
+SELECT CONCAT('a', NULL, 'c'), CONCAT('hello', NULL);
+```
+```text
++------------------------+---------------------+
+| CONCAT('a', NULL, 'c') | CONCAT('hello', NULL) |
++------------------------+---------------------+
+| NULL | NULL |
++------------------------+---------------------+
+```
+
+3. Обработка пустых строк
+```sql
+SELECT CONCAT('hello', '', 'world'), CONCAT('', 'test', '');
+```
+```text
++-----------------------------+------------------------+
+| CONCAT('hello', '', 'world') | CONCAT('', 'test', '') |
++-----------------------------+------------------------+
+| helloworld | test |
++-----------------------------+------------------------+
+```
+
+4. Сочетание чисел и строк
+```sql
+SELECT CONCAT('User', 123), CONCAT('Price: $', 99.99);
+```
+```text
++---------------------+---------------------------+
+| CONCAT('User', 123) | CONCAT('Price: $', 99.99) |
++---------------------+---------------------------+
+| User123 | Price: $99.99 |
++---------------------+---------------------------+
+```
+
+5. Объединение нескольких аргументов
+```sql
+SELECT CONCAT('A', 'B', 'C', 'D', 'E'), CONCAT('1', '2', '3', '4', '5');
+```
+```text
++----------------------------------+----------------------------------+
+| CONCAT('A', 'B', 'C', 'D', 'E') | CONCAT('1', '2', '3', '4', '5') |
++----------------------------------+----------------------------------+
+| ABCDE | 12345 |
++----------------------------------+----------------------------------+
+```
+
+6. Объединение многобайтовых символов UTF-8
+```sql
+SELECT CONCAT('ṭṛì', ' ', 'ḍḍumai'), CONCAT('Hello', ' ', 'ṭṛì', ' ', 'ḍḍumai');
+```
+```text
++------------------------------+--------------------------------------+
+| CONCAT('ṭṛì', ' ', 'ḍḍumai') | CONCAT('Hello', ' ', 'ṭṛì', ' ', 'ḍḍumai') |
++------------------------------+--------------------------------------+
+| ṭṛì ḍḍumai | Hello ṭṛì ḍḍumai |
++------------------------------+--------------------------------------+
+```
+
+7. Формирование путей и URL
+```sql
+SELECT CONCAT('/home/', 'user/', 'file.txt'), CONCAT('https://', 'www.example.com', '/api');
+```
+```text
++--------------------------------------+----------------------------------------------+
+| CONCAT('/home/', 'user/', 'file.txt') | CONCAT('https://', 'www.example.com', '/api') |
++--------------------------------------+----------------------------------------------+
+| /home/user/file.txt | https://www.example.com/api |
++--------------------------------------+----------------------------------------------+
+```
+
+8. Формирование адресов электронной почты
+```sql
+SELECT CONCAT('user', '@', 'example.com'), CONCAT('admin.', 'support', '@', 'company.org');
+```
+```text
++------------------------------------+-----------------------------------------------+
+| CONCAT('user', '@', 'example.com') | CONCAT('admin.', 'support', '@', 'company.org') |
++------------------------------------+-----------------------------------------------+
+| user@example.com | admin.support@company.org |
++------------------------------------+-----------------------------------------------+
+```
diff --git a/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/string-functions/count_substrings.md b/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/string-functions/count_substrings.md
new file mode 100644
index 000000000000..98103fd42ec9
--- /dev/null
+++ b/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/string-functions/count_substrings.md
@@ -0,0 +1,142 @@
+---
+{
+ "title": "COUNT_SUBSTRINGS",
+ "language": "ru",
+ "description": "Функция COUNT_SUBSTRINGS подсчитывает количество вхождений заданной подстроки в строку."
+}
+---
+
+## Описание {#description}
+
+Функция COUNT_SUBSTRINGS подсчитывает количество вхождений заданной подстроки в строку. Примечание: при обнаружении совпадения текущая реализация продолжает поиск, смещаясь на длину подстроки. Например, при str='ccc' и pattern='cc' возвращается результат 1.
+
+## Синтаксис {#syntax}
+
+```sql
+COUNT_SUBSTRINGS(<str>, <pattern>[, <start_pos>])
+```
+
+## Параметры {#parameters}
+| Параметр | Описание |
+| ------------- | ------------------------------------------------------------------ |
+| `<str>` | Строка, в которой выполняется поиск. Тип: STRING |
+| `<pattern>` | Подстрока для поиска. Тип: STRING |
+| `<start_pos>` | Позиция начала поиска (нумерация с 1). Тип: INT. Необязательный параметр |
+
+## Возвращаемое значение {#return-value}
+
+Возвращает значение типа INT, равное количеству вхождений подстроки в строку.
+
+Особые случаи:
+- Если str имеет значение NULL, возвращается NULL
+- Если pattern является пустой строкой, возвращается 0
+- Если str является пустой строкой, возвращается 0
+- Если start_pos меньше или равен 0 либо превышает длину строки, возвращается 0
+- Если pattern длиннее str (или оставшейся части str, начиная с позиции start_pos), возвращается 0
+
+:::caution Изменение поведения (4.1.4)
+
+В версии 4.1.4 исправлена ошибка поиска совпадения с выходом за границы строки: если оставшихся символов не хватало для полной подстроки pattern, предыдущие версии могли всё же засчитать одно лишнее вхождение. Например, `count_substrings('ab', 'abc')` в предыдущих версиях мог возвращать `1`, а после исправления корректно возвращает `0`; `count_substrings('ccc', 'cc', 3)` после исправления возвращает `0`.
+
+:::
+
+## Примеры {#examples}
+
+1. Базовое использование
+```sql
+SELECT count_substrings('a1b1c1d', '1');
+```
+```text
++----------------------------------+
+| count_substrings('a1b1c1d', '1') |
++----------------------------------+
+| 3 |
++----------------------------------+
+```
+
+2. Пример с последовательными запятыми
+```sql
+SELECT count_substrings(',,a,b,c,', ',');
+```
+```text
++-----------------------------------+
+| count_substrings(',,a,b,c,', ',') |
++-----------------------------------+
+| 5 |
++-----------------------------------+
+```
+
+3. Пример с перекрывающимися подстроками
+```sql
+SELECT count_substrings('ccc', 'cc');
+```
+```text
++--------------------------------+
+| count_substrings('ccc', 'cc') |
++--------------------------------+
+| 1 |
++--------------------------------+
+```
+
+4. Обработка значения NULL
+```sql
+SELECT count_substrings(NULL, ',');
+```
+```text
++-----------------------------+
+| count_substrings(NULL, ',') |
++-----------------------------+
+| NULL |
++-----------------------------+
+```
+
+5. Обработка пустой строки
+```sql
+SELECT count_substrings('a,b,c,abcde', '');
+```
+```text
++-------------------------------------+
+| count_substrings('a,b,c,abcde', '') |
++-------------------------------------+
+| 0 |
++-------------------------------------+
+```
+
+6. Использование параметра начальной позиции
+```sql
+SELECT count_substrings('ṭṛì ḍḍumai ṭṛì ti ḍḍumannàri', 'ḍḍu', 1),
+ count_substrings('ṭṛì ḍḍumai ṭṛì ti ḍḍumannàri', 'ḍḍu', 6);
+```
+```text
++-----------------------------------------------------------------------------------+-----------------------------------------------------------------------------------+
+| count_substrings('ṭṛì ḍḍumai ṭṛì ti ḍḍumannàri', 'ḍḍu', 1) | count_substrings('ṭṛì ḍḍumai ṭṛì ti ḍḍumannàri', 'ḍḍu', 6) |
++-----------------------------------------------------------------------------------+-----------------------------------------------------------------------------------+
+| 2 | 1 |
++-----------------------------------------------------------------------------------+-----------------------------------------------------------------------------------+
+```
+
+7. Начальная позиция вне допустимого диапазона
+```sql
+SELECT count_substrings('éèêëìíîïðñòó éèêëìíîïðñòó', 'éèê', 0),
+ count_substrings('éèêëìíîïðñòó éèêëìíîïðñòó', 'éèê', 30);
+```
+```text
++------------------------------------------------------------------------------------+-------------------------------------------------------------------------------------+
+| count_substrings('éèêëìíîïðñòó éèêëìíîïðñòó', 'éèê', 0) | count_substrings('éèêëìíîïðñòó éèêëìíîïðñòó', 'éèê', 30) |
++------------------------------------------------------------------------------------+-------------------------------------------------------------------------------------+
+| 0 | 0 |
++------------------------------------------------------------------------------------+-------------------------------------------------------------------------------------+
+```
+
+8. Многобайтовая китайская подстрока с указанием начальной позиции
+```sql
+SELECT count_substrings('你好，世界！你好，世界！', '世界', 0),
+ count_substrings('你好，世界！你好，世界！', '世界', 30);
+```
+```text
++-----------------------------------------------------------------------+------------------------------------------------------------------------+
+| count_substrings('你好，世界！你好，世界！', '世界', 0) | count_substrings('你好，世界！你好，世界！', '世界', 30) |
++-----------------------------------------------------------------------+------------------------------------------------------------------------+
+| 0 | 0 |
++-----------------------------------------------------------------------+------------------------------------------------------------------------+
+```
diff --git a/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/string-functions/cut-to-first-significant-subdomain.md b/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/string-functions/cut-to-first-significant-subdomain.md
new file mode 100644
index 000000000000..5312c718c370
--- /dev/null
+++ b/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/string-functions/cut-to-first-significant-subdomain.md
@@ -0,0 +1,68 @@
+---
+{
+ "title": "CUT_TO_FIRST_SIGNIFICANT_SUBDOMAIN",
+ "language": "ru",
+ "description": "Функция CUT_TO_FIRST_SIGNIFICANT_SUBDOMAIN извлекает значимую часть доменного имени из URL, включая домен верхнего уровня и поддомены вплоть до первого значимого поддомена."
+}
+---
+
+## Описание {#description}
+
+Функция CUT_TO_FIRST_SIGNIFICANT_SUBDOMAIN извлекает значимую часть доменного имени из URL, включая домен верхнего уровня и поддомены вплоть до «первого значимого поддомена». Если входной URL некорректен, функция возвращает пустую строку.
+
+## Синтаксис {#syntax}
+
+```sql
+CUT_TO_FIRST_SIGNIFICANT_SUBDOMAIN(<url>)
+```
+
+## Параметры {#parameters}
+| Параметр | Описание |
+| --------- | --------------------------------------------- |
+| `<url>` | Строка URL для обработки. Тип: VARCHAR |
+
+## Возвращаемое значение {#return-value}
+
+Возвращает значение типа VARCHAR, содержащее извлечённую часть доменного имени.
+
+Особые случаи:
+- Если url равен NULL, возвращает NULL
+- Если url не соответствует допустимому формату доменного имени, возвращает пустую строку
+
+## Примеры {#examples}
+
+1. Обработка обычного доменного имени
+```sql
+SELECT cut_to_first_significant_subdomain('www.baidu.com');
+```
+```text
++-----------------------------------------------------+
+| cut_to_first_significant_subdomain('www.baidu.com') |
++-----------------------------------------------------+
+| baidu.com |
++-----------------------------------------------------+
+```
+
+2. Обработка многоуровневого доменного имени
+```sql
+SELECT cut_to_first_significant_subdomain('www.google.com.cn');
+```
+```text
++---------------------------------------------------------+
+| cut_to_first_significant_subdomain('www.google.com.cn') |
++---------------------------------------------------------+
+| google.com.cn |
++---------------------------------------------------------+
+```
+
+3. Обработка некорректного доменного имени
+```sql
+SELECT cut_to_first_significant_subdomain('wwwwwwww');
+```
+```text
++------------------------------------------------+
+| cut_to_first_significant_subdomain('wwwwwwww') |
++------------------------------------------------+
+| |
++------------------------------------------------+
+```
diff --git a/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/string-functions/damerau_levenshtein_distance.md b/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/string-functions/damerau_levenshtein_distance.md
new file mode 100644
index 000000000000..97b881e9da38
--- /dev/null
+++ b/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/string-functions/damerau_levenshtein_distance.md
@@ -0,0 +1,168 @@
+---
+{
+ "title": "DAMERAU_LEVENSHTEIN_DISTANCE",
+ "language": "ru",
+ "description": "Функция DAMERAU_LEVENSHTEIN_DISTANCE вычисляет расстояние редактирования Дамерау-Левенштейна между двумя строками."
+}
+---
+
+## Описание {#description}
+
+Функция `DAMERAU_LEVENSHTEIN_DISTANCE` вычисляет [расстояние редактирования Дамерау-Левенштейна](https://en.wikipedia.org/wiki/Damerau%E2%80%93Levenshtein_distance) между двумя строками.
+
+Расстояние редактирования Дамерау-Левенштейна представляет собой минимальное число операций над отдельными символами, необходимых для преобразования одной строки в другую. Поддерживаются следующие операции редактирования:
+
+- Вставка символа
+- Удаление символа
+- Замена символа
+- Перестановка двух соседних символов
+
+По сравнению с `LEVENSHTEIN`, функция `DAMERAU_LEVENSHTEIN_DISTANCE` считает перестановку соседних символов одной операцией редактирования, поэтому лучше подходит для обработки ошибок ввода, вызванных обратным порядком символов. Например, для преобразования `abcd` в `abdc` достаточно переставить соседние символы `c` и `d`, поэтому расстояние Дамерау-Левенштейна равно 1, а расстояние Левенштейна равно 2.
+
+Функция вычисляет расстояние по символам UTF-8, а не по байтам. Поэтому многобайтовые символы, например китайские иероглифы, считаются одним символом.
+
+## Синтаксис {#syntax}
+
+```sql
+DAMERAU_LEVENSHTEIN_DISTANCE(<str1>, <str2>)
+```
+
+## Параметры {#parameters}
+
+| Параметр | Описание |
+| -- | -- |
+| `<str1>` | Первая строка. Тип: VARCHAR |
+| `<str2>` | Вторая строка. Тип: VARCHAR |
+
+## Возвращаемое значение {#return-value}
+
+Возвращает значение типа INT, представляющее расстояние редактирования Дамерау-Левенштейна между двумя строками.
+
+Особые случаи:
+
+- Если любой из аргументов равен NULL, возвращается NULL.
+- Если строки идентичны, возвращается 0.
+- Если одна из строк пуста, возвращается количество символов в другой строке.
+- Функция коммутативна: `DAMERAU_LEVENSHTEIN_DISTANCE(a, b)` и `DAMERAU_LEVENSHTEIN_DISTANCE(b, a)` возвращают одинаковый результат.
+- Если входные данные слишком велики и размер внутренней матрицы расстояний превышает предельное значение, функция возвращает ошибку.
+
+## Примеры {#examples}
+
+1. Базовое использование
+
+```sql
+SELECT damerau_levenshtein_distance('kitten', 'sitting');
+```
+
+```text
++---------------------------------------------------+
+| damerau_levenshtein_distance('kitten', 'sitting') |
++---------------------------------------------------+
+| 3 |
++---------------------------------------------------+
+```
+
+2. Перестановка соседних символов
+
+```sql
+SELECT damerau_levenshtein_distance('abcd', 'abdc');
+```
+
+```text
++----------------------------------------------+
+| damerau_levenshtein_distance('abcd', 'abdc') |
++----------------------------------------------+
+| 1 |
++----------------------------------------------+
+```
+
+`abcd` можно преобразовать в `abdc`, переставив соседние символы `c` и `d`, поэтому расстояние равно 1.
+
+3. Отличие от `LEVENSHTEIN`
+
+```sql
+SELECT levenshtein('abcd', 'abdc'), damerau_levenshtein_distance('abcd', 'abdc');
+```
+
+```text
++-----------------------------+----------------------------------------------+
+| levenshtein('abcd', 'abdc') | damerau_levenshtein_distance('abcd', 'abdc') |
++-----------------------------+----------------------------------------------+
+| 2 | 1 |
++-----------------------------+----------------------------------------------+
+```
+
+`LEVENSHTEIN` не поддерживает перестановку, поэтому нужны 2 операции редактирования. `DAMERAU_LEVENSHTEIN_DISTANCE` поддерживает перестановку соседних символов, поэтому нужна только 1 операция редактирования.
+
+4. Символы UTF-8
+
+```sql
+SELECT damerau_levenshtein_distance('你好', '好你');
+```
+
+```text
++--------------------------------------------------+
+| damerau_levenshtein_distance('你好', '好你') |
++--------------------------------------------------+
+| 1 |
++--------------------------------------------------+
+```
+
+`你` и `好` являются двумя символами UTF-8, а для перестановки соседних символов нужна 1 операция редактирования.
+
+5. Вставка, удаление и замена
+
+```sql
+SELECT
+ damerau_levenshtein_distance('', 'abc'),
+ damerau_levenshtein_distance('数据库', '数据'),
+ damerau_levenshtein_distance('flaw', 'lawn');
+```
+
+```text
++-----------------------------------------+-----------------------------------------------------+----------------------------------------------+
+| damerau_levenshtein_distance('', 'abc') | damerau_levenshtein_distance('数据库', '数据') | damerau_levenshtein_distance('flaw', 'lawn') |
++-----------------------------------------+-----------------------------------------------------+----------------------------------------------+
+| 3 | 1 | 2 |
++-----------------------------------------+-----------------------------------------------------+----------------------------------------------+
+```
+
+6. Пример полного расстояния Дамерау-Левенштейна
+
+```sql
+SELECT damerau_levenshtein_distance('CA', 'ABC');
+```
+
+```text
++-------------------------------------------+
+| damerau_levenshtein_distance('CA', 'ABC') |
++-------------------------------------------+
+| 2 |
++-------------------------------------------+
+```
+
+Эта функция вычисляет полное расстояние Дамерау-Левенштейна. Для `CA` и `ABC` минимальное расстояние редактирования равно 2.
+
+7. Аргументы NULL
+
+```sql
+SELECT damerau_levenshtein_distance(NULL, 'abc'), damerau_levenshtein_distance('abc', NULL);
+```
+
+```text
++-------------------------------------------+-------------------------------------------+
+| damerau_levenshtein_distance(NULL, 'abc') | damerau_levenshtein_distance('abc', NULL) |
++-------------------------------------------+-------------------------------------------+
+| NULL | NULL |
++-------------------------------------------+-------------------------------------------+
+```
+
+8. Слишком большой объём входных данных
+
+```sql
+SELECT damerau_levenshtein_distance(repeat('a', 4096), repeat('b', 4096));
+```
+
+```text
+ERROR 1105 (HY000): errCode = 2, detailMessage = (127.0.0.1)[INVALID_ARGUMENT]damerau_levenshtein_distance distance matrix is too large: 16793604 cells exceeds limit 16777216
+```
diff --git a/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/string-functions/decode.md b/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/string-functions/decode.md
new file mode 100644
index 000000000000..8db7b6412ed7
--- /dev/null
+++ b/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/string-functions/decode.md
@@ -0,0 +1,85 @@
+---
+{
+ "title": "DECODE",
+ "language": "ru",
+ "description": "Преобразует значение VARBINARY в строку с использованием указанной кодировки, обеспечивая совместимое с Hive преобразование символов."
+}
+---
+
+<version since="dev">
+
+</version>
+
+## Описание {#description}
+
+Преобразует значение `VARBINARY` в строку с использованием указанной кодировки. Имена кодировок нечувствительны к регистру. Поддерживаются кодировки `US-ASCII`, `ISO-8859-1`, `UTF-8`, `UTF-16BE`, `UTF-16LE` и `UTF-16`.
+
+## Синтаксис {#syntax}
+
+```sql
+DECODE(<binary>, <charset>)
+```
+
+## Параметры {#parameters}
+
+| Параметр | Описание |
+| :--- | :--- |
+| `<binary>` | Двоичное значение для декодирования. Тип: VARBINARY. |
+| `<charset>` | Строковый литерал с именем кодировки входных байтов или `NULL`. Поддерживаемые значения: `US-ASCII`, `ISO-8859-1`, `UTF-8`, `UTF-16BE`, `UTF-16LE` и `UTF-16`. Использование столбца или другого выражения не допускается. |
+
+## Возвращаемое значение {#return-value}
+
+Возвращает значение типа `STRING`, содержащее декодированный текст.
+
+- Если `<charset>` равен `NULL` или если `<binary>` равен `NULL`, а `<charset>` содержит допустимое значение, функция возвращает `NULL`.
+- Если `<binary>` пуст, функция возвращает пустую строку.
+- Для `UTF-16` функция распознаёт BOM с порядком байтов big-endian (`FE FF`) и little-endian (`FF FE`) и удаляет BOM из результата. При отсутствии BOM входные данные декодируются с порядком байтов big-endian. `UTF-16BE` и `UTF-16LE` всегда используют явно заданный порядок байтов.
+- Если `<charset>` не поддерживается, функция возвращает ошибку, даже когда `<binary>` равен `NULL`. Если `<binary>` содержит некорректные данные для указанной кодировки, функция также возвращает ошибку.
+
+## Пример {#example}
+
+**Декодирование байтов UTF-8**
+
+```sql
+SELECT DECODE(CAST(UNHEX('E4B8AD') AS VARBINARY), 'UTF-8') AS decoded_text;
+```
+
+```text
++--------------+
+| decoded_text |
++--------------+
+| 中 |
++--------------+
+```
+
+**Декодирование UTF-16 с порядком байтов little-endian и BOM**
+
+Имя кодировки в нижнем регистре также демонстрирует сопоставление без учёта регистра.
+
+```sql
+SELECT DECODE(CAST(UNHEX('FFFE2D4E') AS VARBINARY), 'utf-16') AS decoded_text;
+```
+
+```text
++--------------+
+| decoded_text |
++--------------+
+| 中 |
++--------------+
+```
+
+**NULL и пустые входные данные**
+
+```sql
+SELECT
+ DECODE(CAST(NULL AS VARBINARY), 'UTF-8') IS NULL AS null_result,
+ DECODE(CAST(UNHEX('') AS VARBINARY), 'UTF-16') = '' AS empty_result;
+```
+
+```text
++-------------+--------------+
+| null_result | empty_result |
++-------------+--------------+
+| 1 | 1 |
++-------------+--------------+
+```
diff --git a/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/string-functions/digital-masking.md b/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/string-functions/digital-masking.md
new file mode 100644
index 000000000000..0b5030b88cef
--- /dev/null
+++ b/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/string-functions/digital-masking.md
@@ -0,0 +1,94 @@
+---
+{
+ "title": "DIGITAL_MASKING",
+ "language": "ru",
+ "description": "Функция DIGITALMASKING маскирует числовые строки, заменяя среднюю часть по фиксированному шаблону."
+}
+---
+
+## Описание {#description}
+
+Функция DIGITAL_MASKING маскирует числовые строки, заменяя среднюю часть на `****` по фиксированному шаблону и сохраняя первые 3 и последние 4 цифры. Эквивалентна `CONCAT(LEFT(id, 3), '****', RIGHT(id, 4))`.
+
+## Синтаксис {#syntax}
+
+```sql
+DIGITAL_MASKING(<digital_number>)
+```
+
+## Параметры {#parameters}
+
+| Параметр | Описание |
+| ------------------ | ----------------------------------------- |
+| `<digital_number>` | Числовая строка, которую необходимо замаскировать. Тип: VARCHAR |
+
+## Возвращаемое значение {#return-value}
+
+Возвращает значение типа VARCHAR, представляющее замаскированную числовую строку.
+
+Особые случаи:
+- Если параметр равен NULL, возвращает NULL
+- Формат маскирования: первые 3 цифры + `****` + последние 4 цифры
+- Если длина строки меньше 7 цифр, начальная и конечная части в результате могут перекрываться
+
+## Примеры {#examples}
+
+1. Основное использование: маскирование телефонного номера из 11 цифр
+```sql
+SELECT digital_masking('13812345678');
+```
+```text
++--------------------------------+
+| digital_masking('13812345678') |
++--------------------------------+
+| 138****5678 |
++--------------------------------+
+```
+
+2. Числа разной длины
+```sql
+SELECT digital_masking('1234567890');
+```
+```text
++-------------------------------+
+| digital_masking('1234567890') |
++-------------------------------+
+| 123****7890 |
++-------------------------------+
+```
+
+3. Короткое число (менее 7 цифр)
+```sql
+SELECT digital_masking('123');
+```
+```text
++------------------------+
+| digital_masking('123') |
++------------------------+
+| 123****123 |
++------------------------+
+```
+
+4. Обработка значения NULL
+```sql
+SELECT digital_masking(NULL);
+```
+```text
++-----------------------+
+| digital_masking(NULL) |
++-----------------------+
+| NULL |
++-----------------------+
+```
+
+5. Строка с символами UTF-8
+```sql
+SELECT digital_masking('13812ṭṛ34678');
+```
+```text
++-------------------------------------+
+| digital_masking('13812ṭṛ34678') |
++-------------------------------------+
+| 138****4678 |
++-------------------------------------+
+```
diff --git a/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/string-functions/domain-without-www.md b/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/string-functions/domain-without-www.md
new file mode 100644
index 000000000000..191681d72053
--- /dev/null
+++ b/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/string-functions/domain-without-www.md
@@ -0,0 +1,39 @@
+---
+{
+ "title": "DOMAIN_WITHOUT_WWW",
+ "language": "ru",
+ "description": "Извлекает доменное имя без префикса www из строки URL"
+}
+---
+
+## Описание {#description}
+
+Извлекает доменное имя без префикса www из строки URL
+
+## Синтаксис {#syntax}
+
+```sql
+DOMAIN_WITHOUT_WWW ( <url> )
+```
+
+## Параметры {#parameters}
+
+| Параметр | Описание |
+|-----------|----------------------|
+| `<url>` | Строка `URL`, из которой нужно извлечь доменное имя без префикса www |
+
+## Возвращаемое значение {#return-value}
+
+Доменное имя из параметра `<url>` без префикса www
+
+```sql
+SELECT DOMAIN_WITHOUT_WWW("https://www.apache.org/docs/gettingStarted/what-is-apache-doris")
+```
+
+```text
++---------------------------------------------------------------------------------------+
+| domain_without_www('https://www.apache.org/docs/gettingStarted/what-is-apache-doris') |
++---------------------------------------------------------------------------------------+
+| apache.org |
++---------------------------------------------------------------------------------------+
+```
diff --git a/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/string-functions/domain.md b/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/string-functions/domain.md
new file mode 100644
index 000000000000..0f3c042a85ae
--- /dev/null
+++ b/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/string-functions/domain.md
@@ -0,0 +1,41 @@
+---
+{
+ "title": "DOMAIN",
+ "language": "ru",
+ "description": "Извлекает доменное имя из URL, представленного строкой"
+}
+---
+
+## Описание {#description}
+
+Извлекает доменное имя из URL, представленного строкой
+
+## Синтаксис {#syntax}
+
+```sql
+DOMAIN ( <url> )
+```
+
+## Параметры {#parameters}
+
+| Параметр | Описание |
+|-----------|--------------------|
+| `<url>` | `URL`, из которого необходимо извлечь доменное имя |
+
+## Возвращаемое значение {#return-value}
+
+Доменное имя из параметра `<url>`
+
+## Пример {#example}
+
+```sql
+SELECT DOMAIN("https://doris.apache.org/docs/gettingStarted/what-is-apache-doris")
+```
+
+```text
++-----------------------------------------------------------------------------+
+| domain('https://doris.apache.org/docs/gettingStarted/what-is-apache-doris') |
++-----------------------------------------------------------------------------+
+| doris.apache.org |
++-----------------------------------------------------------------------------+
+```
diff --git a/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/string-functions/elt.md b/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/string-functions/elt.md
new file mode 100644
index 000000000000..859f7a7ebe5d
--- /dev/null
+++ b/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/string-functions/elt.md
@@ -0,0 +1,140 @@
+---
+{
+ "title": "ELT",
+ "language": "ru",
+ "description": "Функция ELT возвращает строку по указанному индексу. Отсчёт индексов начинается с 1."
+}
+---
+
+## Описание {#description}
+
+Функция ELT возвращает строку по указанному индексу. Отсчёт индексов начинается с 1.
+
+## Синтаксис {#syntax}
+
+```sql
+ELT(<pos>, <str>[, <str> ...])
+```
+
+## Параметры {#parameters}
+
+| Параметр | Описание |
+| -------- | ----------------------------------------- |
+| `<pos>` | Индекс (начиная с 1). Тип: INT |
+| `<str>` | Список строк. Тип: VARCHAR |
+
+## Возвращаемое значение {#return-value}
+
+Возвращает значение типа VARCHAR, представляющее собой строку по указанному индексу.
+
+Особые случаи:
+- Если `<pos>` меньше 1 или больше количества строк, возвращается NULL
+- Если `<pos>` равен NULL, возвращается NULL
+- Отсчёт индексов начинается с 1, первая строка имеет индекс 1
+
+## Примеры {#examples}
+
+1. Базовое использование: получение 1-й строки
+```sql
+SELECT ELT(1, 'aaa', 'bbb', 'ccc');
+```
+```text
++-----------------------------+
+| elt(1, 'aaa', 'bbb', 'ccc') |
++-----------------------------+
+| aaa |
++-----------------------------+
+```
+
+2. Получение 2-й строки
+```sql
+SELECT ELT(2, 'aaa', 'bbb', 'ccc');
+```
+```text
++-----------------------------+
+| elt(2, 'aaa', 'bbb', 'ccc') |
++-----------------------------+
+| bbb |
++-----------------------------+
+```
+
+3. При выходе индекса за допустимые границы возвращается NULL
+```sql
+SELECT ELT(0, 'aaa', 'bbb'), ELT(5, 'aaa', 'bbb');
+```
+```text
++----------------------+----------------------+
+| elt(0, 'aaa', 'bbb') | elt(5, 'aaa', 'bbb') |
++----------------------+----------------------+
+| NULL | NULL |
++----------------------+----------------------+
+```
+
+4. Обработка значения NULL
+```sql
+SELECT ELT(NULL, 'aaa', 'bbb');
+```
+```text
++-------------------------+
+| elt(NULL, 'aaa', 'bbb') |
++-------------------------+
+| NULL |
++-------------------------+
+```
+
+5. Если индекс превышает допустимый диапазон, возвращается NULL
+
+```sql
+SELECT ELT(5, 'aaa', 'bbb', 'ccc');
+```
+
+```text
++-----------------------------+
+| elt(5, 'aaa', 'bbb', 'ccc') |
++-----------------------------+
+| NULL |
++-----------------------------+
+```
+
+6. При отрицательном индексе возвращается NULL
+
+```sql
+SELECT ELT(-1, 'first', 'second');
+```
+
+```text
++----------------------------+
+| elt(-1, 'first', 'second') |
++----------------------------+
+| NULL |
++----------------------------+
+```
+
+7. Строка UTF-8
+
+```sql
+SELECT
+ ELT(2, 'Hello', 'ṭṛ', 'Hola');
+```
+
+```text
++-----------------------------------+
+| ELT(2, 'Hello', 'ṭṛ', 'Hola') |
++-----------------------------------+
+| ṭṛ |
++-----------------------------------+
+```
+
+8. Обработка пустых строк
+
+```sql
+SELECT ELT(2, 'first', '', 'third');
+```
+
+```text
++------------------------------+
+| elt(2, 'first', '', 'third') |
++------------------------------+
+| |
++------------------------------+
+```
diff --git a/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/string-functions/encode.md b/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/string-functions/encode.md
new file mode 100644
index 000000000000..ee28a1608e8c
--- /dev/null
+++ b/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/string-functions/encode.md
@@ -0,0 +1,90 @@
+---
+{
+ "title": "ENCODE",
+ "language": "ru",
+ "description": "Преобразует строку в значение VARBINARY с использованием указанного набора символов для совместимого с Hive преобразования символов."
+}
+---
+
+<version since="dev">
+
+</version>
+
+## Описание {#description}
+
+Преобразует строку в значение `VARBINARY` с использованием указанного набора символов. Регистр в названиях наборов символов не учитывается. Поддерживаются наборы символов `US-ASCII`, `ISO-8859-1`, `UTF-8`, `UTF-16BE`, `UTF-16LE` и `UTF-16`.
+
+## Синтаксис {#syntax}
+
+```sql
+ENCODE(<source>, <charset>)
+```
+
+## Параметры {#parameters}
+
+| Параметр | Описание |
+| :--- | :--- |
+| `<source>` | Строка для кодирования. Тип: STRING. |
+| `<charset>` | Строковый литерал с названием целевого набора символов или `NULL`. Поддерживаемые значения: `US-ASCII`, `ISO-8859-1`, `UTF-8`, `UTF-16BE`, `UTF-16LE` и `UTF-16`. Столбец или другое выражение использовать нельзя. |
+
+## Возвращаемое значение {#return-value}
+
+Возвращает значение `VARBINARY`, содержащее закодированные байты.
+
+- Если `<charset>` равен `NULL` либо `<source>` равен `NULL` при допустимом значении `<charset>`, функция возвращает `NULL`.
+- Если `<source>` — пустая строка, функция возвращает пустое двоичное значение.
+- `UTF-16` записывает метку порядка байтов (BOM) в формате big-endian для непустых входных данных. `UTF-16BE` и `UTF-16LE` не записывают BOM.
+- Если `<charset>` не поддерживается, функция возвращает ошибку, даже если `<source>` равен `NULL`. Если `<source>` содержит символ, который нельзя представить в целевом наборе символов, функция также возвращает ошибку.
+
+## Пример {#example}
+
+**Кодирование одного и того же символа с использованием UTF-8 и ISO-8859-1**
+
+`HEX` используется для отображения байтов возвращаемого двоичного значения.
+
+```sql
+SELECT
+ HEX(ENCODE('é', 'UTF-8')) AS utf8_bytes,
+ HEX(ENCODE('é', 'ISO-8859-1')) AS latin1_bytes;
+```
+
+```text
++------------+--------------+
+| utf8_bytes | latin1_bytes |
++------------+--------------+
+| C3A9 | E9 |
++------------+--------------+
+```
+
+**Сравнение вариантов UTF-16**
+
+```sql
+SELECT
+ HEX(ENCODE('中', 'UTF-16BE')) AS big_endian,
+ HEX(ENCODE('中', 'UTF-16LE')) AS little_endian,
+ HEX(ENCODE('中', 'UTF-16')) AS with_bom;
+```
+
+```text
++------------+---------------+----------+
+| big_endian | little_endian | with_bom |
++------------+---------------+----------+
+| 4E2D | 2D4E | FEFF4E2D |
++------------+---------------+----------+
+```
+
+**NULL и пустые входные данные**
+
+```sql
+SELECT
+ ENCODE(NULL, 'UTF-8') IS NULL AS null_result,
+ HEX(ENCODE('', 'UTF-16')) = '' AS empty_result;
+```
+
+```text
++-------------+--------------+
+| null_result | empty_result |
++-------------+--------------+
+| 1 | 1 |
++-------------+--------------+
+```
diff --git a/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/string-functions/ends-with.md b/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/string-functions/ends-with.md
new file mode 100644
index 000000000000..fb4dcab1eae7
--- /dev/null
+++ b/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/string-functions/ends-with.md
@@ -0,0 +1,162 @@
+---
+{
+ "title": "ENDS_WITH",
+ "language": "ru",
+ "description": "Функция ENDSWITH проверяет, заканчивается ли строка указанным суффиксом."
+}
+---
+
+## Описание {#description}
+
+Функция ENDS_WITH проверяет, заканчивается ли строка указанным суффиксом.
+
+## Синтаксис {#syntax}
+
+```sql
+ENDS_WITH(<str>, <suffix>)
+```
+
+## Параметры {#parameters}
+
+| Параметр | Описание |
+|----------|--------------|
+| `str` | Основная строка для проверки. Тип: VARCHAR |
+| `suffix` | Строка суффикса для сопоставления. Тип: VARCHAR |
+
+## Возвращаемое значение {#return-value}
+
+Возвращает значение типа BOOLEAN (в Doris отображается как TINYINT, где 1 означает true, а 0 означает false).
+
+Правила сопоставления:
+- Точное совпадение суффикса с учётом регистра
+- Пустой суффикс совпадает с окончанием любой строки (возвращается true)
+- Поддерживается корректное сопоставление многобайтовых символов UTF-8
+- Длина суффикса не может превышать длину основной строки (кроме случая, когда суффикс пуст)
+
+Особые случаи:
+- Если хотя бы один из параметров равен NULL, возвращается NULL
+- Если суффикс является пустой строкой, возвращается true (любая строка заканчивается пустой строкой)
+- Если основная строка пуста, а суффикс непустой, возвращается false
+- Если обе строки пусты, возвращается true
+
+## Примеры {#examples}
+
+1. Базовое сопоставление суффикса
+```sql
+SELECT ENDS_WITH('Hello doris', 'doris'), ENDS_WITH('Hello doris', 'Hello');
+```
+```text
++-----------------------------------+-----------------------------------+
+| ENDS_WITH('Hello doris', 'doris') | ENDS_WITH('Hello doris', 'Hello') |
++-----------------------------------+-----------------------------------+
+| 1 | 0 |
++-----------------------------------+-----------------------------------+
+```
+
+2. Учёт регистра
+```sql
+SELECT ENDS_WITH('Hello World', 'world'), ENDS_WITH('Hello World', 'World');
+```
+```text
++-----------------------------------+-----------------------------------+
+| ENDS_WITH('Hello World', 'world') | ENDS_WITH('Hello World', 'World') |
++-----------------------------------+-----------------------------------+
+| 0 | 1 |
++-----------------------------------+-----------------------------------+
+```
+
+3. Обработка значений NULL
+```sql
+SELECT ENDS_WITH(NULL, 'test'), ENDS_WITH('test', NULL);
+```
+```text
++--------------------------+--------------------------+
+| ENDS_WITH(NULL, 'test') | ENDS_WITH('test', NULL) |
++--------------------------+--------------------------+
+| NULL | NULL |
++--------------------------+--------------------------+
+```
+
+4. Обработка пустых строк
+```sql
+SELECT ENDS_WITH('hello', ''), ENDS_WITH('', 'world');
+```
+```text
++-------------------------+--------------------------+
+| ENDS_WITH('hello', '') | ENDS_WITH('', 'world') |
++-------------------------+--------------------------+
+| 1 | 0 |
++-------------------------+--------------------------+
+```
+
+5. Полное совпадение строк
+```sql
+SELECT ENDS_WITH('test', 'test'), ENDS_WITH('testing', 'test');
+```
+```text
++---------------------------+------------------------------+
+| ENDS_WITH('test', 'test') | ENDS_WITH('testing', 'test') |
++---------------------------+------------------------------+
+| 1 | 0 |
++---------------------------+------------------------------+
+```
+
+6. Проверка расширения файла
+```sql
+SELECT ENDS_WITH('document.pdf', '.pdf'), ENDS_WITH('image.jpg', '.png');
+```
+```text
++------------------------------------+----------------------------------+
+| ENDS_WITH('document.pdf', '.pdf') | ENDS_WITH('image.jpg', '.png') |
++------------------------------------+----------------------------------+
+| 1 | 0 |
++------------------------------------+----------------------------------+
+```
+
+7. Многобайтовые символы UTF-8
+```sql
+SELECT ENDS_WITH('hello ṭṛì ḍḍumai', 'ḍḍumai'), ENDS_WITH('hello ṭṛì ḍḍumai', 'ṭṛì');
+```
+```text
++------------------------------------------+---------------------------------------+
+| ENDS_WITH('hello ṭṛì ḍḍumai', 'ḍḍumai') | ENDS_WITH('hello ṭṛì ḍḍumai', 'ṭṛì') |
++------------------------------------------+---------------------------------------+
+| 1 | 0 |
++------------------------------------------+---------------------------------------+
+```
+
+8. Проверка пути URL
+```sql
+SELECT ENDS_WITH('https://example.com/api', '/api'), ENDS_WITH('https://example.com/', '.html');
+```
+```text
++--------------------------------------------+---------------------------------------------+
+| ENDS_WITH('https://example.com/api', '/api') | ENDS_WITH('https://example.com/', '.html') |
++--------------------------------------------+---------------------------------------------+
+| 1 | 0 |
++--------------------------------------------+---------------------------------------------+
+```
+
+9. Суффикс строки из цифр
+```sql
+SELECT ENDS_WITH('123456789', '789'), ENDS_WITH('123456789', '456');
+```
+```text
++--------------------------------+--------------------------------+
+| ENDS_WITH('123456789', '789') | ENDS_WITH('123456789', '456') |
++--------------------------------+--------------------------------+
+| 1 | 0 |
++--------------------------------+--------------------------------+
+```
+
+10. Проверка домена электронной почты
+```sql
+SELECT ENDS_WITH('user@gmail.com', '.com'), ENDS_WITH('admin@company.org', '.com');
+```
+```text
++------------------------------------+--------------------------------------+
+| ENDS_WITH('user@gmail.com', '.com') | ENDS_WITH('admin@company.org', '.com') |
++------------------------------------+--------------------------------------+
+| 1 | 0 |
++------------------------------------+--------------------------------------+
+```
diff --git a/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/string-functions/export-set.md b/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/string-functions/export-set.md
new file mode 100644
index 000000000000..e8fa359ee808
--- /dev/null
+++ b/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/string-functions/export-set.md
@@ -0,0 +1,161 @@
+---
+{
+ "title": "EXPORT-SET",
+ "language": "ru",
+ "description": "EXPORTSET используется для преобразования каждого бита целого числа в заданную строку и объединения этих строк в результирующую строку. Для каждого бита в bits, равного 1,"
+}
+---
+
+## Описание {#description}
+
+Функция `EXPORT_SET` преобразует каждый бит целого числа в заданную строку и объединяет эти строки в результирующую строку. Для каждого бита в `bits`, равного 1, в соответствующей позиции результата выводится строка `on`; для каждого бита, равного 0, выводится строка `off`. Биты проверяются справа налево (то есть от младшего бита к старшему), но объединяются в результирующую строку слева направо. Биты разделяются строкой `separator` (по умолчанию запятой `,`).
+
+Количество отображаемых битов определяется параметром `number_of_bits` и по умолчанию составляет 64 бита. Если параметр не указан или выходит за допустимый диапазон (больше 64), автоматически используется 64 бита.
+
+Эта функция работает аналогично [функции EXPORT_SET](https://dev.mysql.com/doc/refman/8.4/en/string-functions.html#function_export-set) в MySQL.
+
+## Синтаксис {#syntax}
+
+```sql
+EXPORT_SET(bits, on, off[, separator[, number_of_bits]])
+```
+
+## Параметры {#parameters}
+
+| Параметр | Описание |
+|-------------------|-------------|
+| `bits` | Целое число типа LARGEINT, используемое для преобразования. Если значение меньше -2^63, оно обрабатывается как -2^63. Если оно больше 2^64 - 1, оно обрабатывается как 2^63 - 1. |
+| `on` | Строка, отображаемая, когда бит равен 1 |
+| `off` | Строка, отображаемая, когда бит равен 0 |
+| `separator` | Необязательный параметр: строка для разделения битов, по умолчанию ',' |
+| `number_of_bits` | Необязательный параметр: количество битов, отображаемых в результате; поддерживается целочисленный тип INT. Значение по умолчанию: 64. Если значение выходит за пределы диапазона [0, 64], автоматически используется значение по умолчанию. |
+
+## Возвращаемое значение {#return-value}
+
+Возвращает строку. Каждый бит в `bits` обрабатывается в порядке от младшего к старшему: если он равен 1, он заменяется на `on`; если равен 0, на `off`. Полученные строки объединяются в том же порядке. Биты разделяются строкой `separator`, а итоговый результат содержит `number_of_bits` битов.
+
+Если `number_of_bits` выходит за пределы диапазона [-2^31, 2^31 - 1] или любой параметр функции равен NULL, возвращается NULL.
+## Пример {#example}
+
+<!-- setup-sql
+CREATE TABLE test_export_set (`bits` BIGINT, `on` VARCHAR(20), `off` VARCHAR(20), `sep` VARCHAR(20), `num_of_b` INT) DISTRIBUTED BY HASH(`bits`) BUCKETS 1 PROPERTIES("replication_num"="1");
+INSERT INTO test_export_set VALUES (-1,'1','0',',',50),(-2,'1','0','',64),(5,'Y','N',',',5),(5,'1','0','',64),(5,'','0','',65),(6,'1','','',63),(19284249819,'1','0',',',64),(9,'apache','doris','|123|',64),(NULL,'1','0',',',5),(5,NULL,'0','',5),(5,'1',NULL,',',10),(5,'1','0',NULL,10),(5,'1','0',',',NULL);
+-->
+
+```sql
+SELECT EXPORT_SET(-2, '1', '0');
+```
+```text
++---------------------------------------------------------------------------------------------------------------------------------+
+| EXPORT_SET(-2, '1', '0') |
++---------------------------------------------------------------------------------------------------------------------------------+
+| 0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1 |
++---------------------------------------------------------------------------------------------------------------------------------+
+```
+
+```sql
+SELECT EXPORT_SET(5, '1', '0', '||', 5);
+```
+```text
++----------------------------------+
+| EXPORT_SET(5, '1', '0', '||', 5) |
++----------------------------------+
+| 1||0||1||0||0 |
++----------------------------------+
+```
+
+```sql
+SELECT `bits`, `on`, `off`, `sep`, `num_of_b`
+FROM `test_export_set`;
+```
+```text
++-------------+--------+-------+-------+----------+
+| bits | on | off | sep | num_of_b |
++-------------+--------+-------+-------+----------+
+| -1 | 1 | 0 | , | 50 |
+| -2 | 1 | 0 | | 64 |
+| 5 | Y | N | , | 5 |
+| 5 | 1 | 0 | | 64 |
+| 5 | | 0 | | 65 |
+| 6 | 1 | | | 63 |
+| 19284249819 | 1 | 0 | , | 64 |
+| 9 | apache | doris | |123| | 64 |
+| NULL | 1 | 0 | , | 5 |
+| 5 | NULL | 0 | | 5 |
+| 5 | 1 | NULL | , | 10 |
+| 5 | 1 | 0 | NULL | 10 |
+| 5 | 1 | 0 | , | NULL |
++-------------+--------+-------+-------+----------+
+```
+
+```sql
+SELECT EXPORT_SET(`bits`, `on`, `off`, `sep`, `num_of_b`)
+FROM `test_export_set`;
+```
+```text
++-------------+--------+-------+-------+----------+--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- [...]
+| bits | on | off | sep | num_of_b | ans [...]
++-------------+--------+-------+-------+----------+--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- [...]
+| -1 | 1 | 0 | , | 50 | 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1 [...]
+| -2 | 1 | 0 | | 64 | 0111111111111111111111111111111111111111111111111111111111111111 [...]
+| 5 | Y | N | , | 5 | Y,N,Y,N,N [...]
+| 5 | 1 | 0 | | 64 | 1010000000000000000000000000000000000000000000000000000000000000 [...]
+| 5 | | 0 | | 65 | 00000000000000000000000000000000000000000000000000000000000000 [...]
+| 6 | 1 | | | 63 | 11 [...]
+| 19284249819 | 1 | 0 | , | 64 | 1,1,0,1,1,0,1,1,0,0,1,1,0,0,1,0,0,1,1,1,0,1,1,0,1,0,1,1,1,1,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 [...]
+| 9 | apache | doris | |123| | 64 | apache|123|doris|123|doris|123|apache|123|doris|123|doris|123|doris|123|doris|123|doris|123|doris|123|doris|123|doris|123|doris|123|doris|123|doris|123|doris|123|doris|123|doris|123|doris|123|doris|123|doris|123|doris|123|doris|123|doris|123|doris|123|doris|123|doris|123|doris|123|doris|123|doris|123|doris|123|doris|123|doris|123|doris|123|doris|123|doris|123|doris|123|doris|123|doris|123|doris|123|doris|123|doris|123|doris|123|doris|12 [...]
+| NULL | 1 | 0 | , | 5 | NULL [...]
+| 5 | NULL | 0 | | 5 | NULL [...]
+| 5 | 1 | NULL | , | 10 | NULL [...]
+| 5 | 1 | 0 | NULL | 10 | NULL [...]
+| 5 | 1 | 0 | , | NULL | NULL [...]
++-------------+--------+-------+-------+----------+--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- [...]
+```
+
+```sql
+-- max value: 2^64 - 1
+SELECT EXPORT_SET(18446744073709551615, '1', '0');
+```
+```text
++---------------------------------------------------------------------------------------------------------------------------------+
+| EXPORT_SET(18446744073709551615, '1', '0') |
++---------------------------------------------------------------------------------------------------------------------------------+
+| 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1 |
++---------------------------------------------------------------------------------------------------------------------------------+
+```
+
+```sql
+-- 2^64 out of bound, the bits will be set to 2^63 - 1
+SELECT EXPORT_SET(18446744073709551616, '1', '0');
+```
+```text
++---------------------------------------------------------------------------------------------------------------------------------+
+| EXPORT_SET(18446744073709551616, '1', '0') |
++---------------------------------------------------------------------------------------------------------------------------------+
+| 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0 |
++---------------------------------------------------------------------------------------------------------------------------------+
+```
+
+```sql
+-- min value: -2^63
+SELECT EXPORT_SET(-9223372036854775808, '1', '0');
+```
+```text
++---------------------------------------------------------------------------------------------------------------------------------+
+| EXPORT_SET(-9223372036854775808, '1', '0') |
++---------------------------------------------------------------------------------------------------------------------------------+
+| 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1 |
++---------------------------------------------------------------------------------------------------------------------------------+
+```
+
+```sql
+-- out of bound, the bits will be set to -2^63
+SELECT EXPORT_SET(-184467440737095516161, '1', '0');
+```
+```text
++---------------------------------------------------------------------------------------------------------------------------------+
+| EXPORT_SET(-184467440737095516161, '1', '0') |
++---------------------------------------------------------------------------------------------------------------------------------+
+| 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1 |
++---------------------------------------------------------------------------------------------------------------------------------+
+```
diff --git a/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/string-functions/extract-url-parameter.md b/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/string-functions/extract-url-parameter.md
new file mode 100644
index 000000000000..f752012395e5
--- /dev/null
+++ b/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/string-functions/extract-url-parameter.md
@@ -0,0 +1,48 @@
+---
+{
+ "title": "EXTRACT_URL_PARAMETER",
+ "language": "ru",
+ "description": "Возвращает значение параметра name в URL, если такой параметр есть, или пустую строку в противном случае."
+}
+---
+
+## Описание {#description}
+
+Возвращает значение параметра `name` в URL, если такой параметр есть, или пустую строку в противном случае.
+
+Если параметров с таким именем несколько, возвращается значение первого из них.
+
+Функция предполагает, что имя параметра закодировано в URL точно так же, как и в переданном аргументе.
+
+Чтобы получить другие части URL, можно использовать [parse_url](parse-url.md)
+
+## Синтаксис {#syntax}
+
+```sql
+EXTRACT_URL_PARAMETER ( <url> , <name> )
+```
+
+## Параметры {#parameters}
+
+| Параметры | Описание |
+|------------|---------------|
+| `<url>` | Строка URL, из которой нужно получить значение параметра |
+| `<name>` | Имя параметра, значение которого нужно получить |
+
+## Возвращаемое значение {#return-value}
+
+Значение параметра `<name>` в `<url>`
+
+## Пример {#example}
+
+```sql
+SELECT EXTRACT_URL_PARAMETER("http://doris.apache.org?k1=aa&k2=bb&test=cc#999", "k2")
+```
+
+```text
++--------------------------------------------------------------------------------+
+| extract_url_parameter('http://doris.apache.org?k1=aa&k2=bb&test=cc#999', 'k2') |
++--------------------------------------------------------------------------------+
+| bb |
++--------------------------------------------------------------------------------+
+```
diff --git a/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/string-functions/find-in-set.md b/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/string-functions/find-in-set.md
new file mode 100644
index 000000000000..551c55fcd114
--- /dev/null
+++ b/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/string-functions/find-in-set.md
@@ -0,0 +1,163 @@
+---
+{
+ "title": "FIND_IN_SET",
+ "language": "ru",
+ "description": "Возвращает позицию первого вхождения строки str в списке строк strlist, разделённых запятыми (отсчёт начинается с 1)."
+}
+---
+
+## Описание {#description}
+
+Возвращает позицию первого вхождения строки str в списке строк strlist, разделённых запятыми (отсчёт начинается с 1). Эта функция реализована в режиме совместимости с MySQL и используется для поиска определённых строк в списках значений, разделённых запятыми.
+
+## Синтаксис {#syntax}
+
+```sql
+FIND_IN_SET(<str>, <strlist>)
+```
+
+## Параметры {#parameters}
+
+| Параметр | Описание |
+|-------------|----------|
+| `<str>` | Искомая строка. Тип: VARCHAR |
+| `<strlist>` | Список строк, разделённых запятыми, в котором выполняется поиск str. Тип: VARCHAR |
+
+## Возвращаемое значение {#return-value}
+
+Возвращает значение типа INT, обозначающее позицию str в strlist (отсчёт начинается с 1).
+
+Правила поиска:
+- Точное совпадение: позиция возвращается только в том случае, если str в точности совпадает с подстрокой в strlist
+- Отсчёт позиций начинается с 1
+- Возвращается позиция первого совпадения
+
+Особые случаи:
+- Если str является пустой строкой, возвращается 0
+- Если strlist является пустой строкой, возвращается 0
+- Если совпадение не найдено, возвращается 0
+- Если любой из параметров равен NULL, возвращается NULL
+- Если str содержит запятую, корректное сопоставление невозможно (поскольку запятая служит разделителем)
+- При сопоставлении учитывается регистр
+
+## Примеры {#examples}
+
+1. Базовый поиск
+```sql
+SELECT FIND_IN_SET('b', 'a,b,c');
+```
+```text
++---------------------------+
+| FIND_IN_SET('b', 'a,b,c') |
++---------------------------+
+| 2 |
++---------------------------+
+```
+
+2. Поиск первого элемента
+```sql
+SELECT FIND_IN_SET('apple', 'apple,banana,cherry');
+```
+```text
++------------------------------------------+
+| FIND_IN_SET('apple', 'apple,banana,cherry') |
++------------------------------------------+
+| 1 |
++------------------------------------------+
+```
+
+3. Поиск последнего элемента
+```sql
+SELECT FIND_IN_SET('cherry', 'apple,banana,cherry');
+```
+```text
++-------------------------------------------+
+| FIND_IN_SET('cherry', 'apple,banana,cherry') |
++-------------------------------------------+
+| 3 |
++-------------------------------------------+
+```
+
+4. Совпадение не найдено
+```sql
+SELECT FIND_IN_SET('orange', 'apple,banana,cherry');
+```
+```text
++--------------------------------------------+
+| FIND_IN_SET('orange', 'apple,banana,cherry') |
++--------------------------------------------+
+| 0 |
++--------------------------------------------+
+```
+
+5. Обработка значений NULL
+```sql
+SELECT FIND_IN_SET(NULL, 'a,b,c'), FIND_IN_SET('b', NULL);
+```
+```text
++---------------------------+-------------------------+
+| FIND_IN_SET(NULL, 'a,b,c') | FIND_IN_SET('b', NULL) |
++---------------------------+-------------------------+
+| NULL | NULL |
++---------------------------+-------------------------+
+```
+
+6. Обработка пустых строк
+```sql
+SELECT FIND_IN_SET('', 'a,b,c'), FIND_IN_SET('a', '');
+```
+```text
++-------------------------+-----------------------+
+| FIND_IN_SET('', 'a,b,c') | FIND_IN_SET('a', '') |
++-------------------------+-----------------------+
+| 0 | 0 |
++-------------------------+-----------------------+
+```
+
+7. Строка, содержащая запятую (корректное сопоставление невозможно)
+```sql
+SELECT FIND_IN_SET('a,b', 'a,b,c,d');
+```
+```text
++------------------------------+
+| FIND_IN_SET('a,b', 'a,b,c,d') |
++------------------------------+
+| 0 |
++------------------------------+
+```
+
+8. Сопоставление с учётом регистра
+```sql
+SELECT FIND_IN_SET('B', 'a,b,c'), FIND_IN_SET('b', 'A,B,C');
+```
+```text
++---------------------------+---------------------------+
+| FIND_IN_SET('B', 'a,b,c') | FIND_IN_SET('b', 'A,B,C') |
++---------------------------+---------------------------+
+| 0 | 0 |
++---------------------------+---------------------------+
+```
+
+9. Частичное совпадение не считается успешным
+```sql
+SELECT FIND_IN_SET('ap', 'apple,banana,cherry');
+```
+```text
++---------------------------------------+
+| FIND_IN_SET('ap', 'apple,banana,cherry') |
++---------------------------------------+
+| 0 |
++---------------------------------------+
+```
+
+10. Поиск числовой строки
+```sql
+SELECT FIND_IN_SET('2', '1,2,3,10,20');
+```
+```text
++--------------------------------+
+| FIND_IN_SET('2', '1,2,3,10,20') |
++--------------------------------+
+| 2 |
++--------------------------------+
+```
diff --git a/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/string-functions/first-significant-subdomain.md b/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/string-functions/first-significant-subdomain.md
new file mode 100644
index 000000000000..906d588e29e9
--- /dev/null
+++ b/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/string-functions/first-significant-subdomain.md
@@ -0,0 +1,41 @@
+---
+{
+ "title": "FIRST_SIGNIFICANT_SUBDOMAIN",
+ "language": "ru",
+ "description": "Извлекает из URL «первый допустимый поддомен» и возвращает его. Если URL некорректен, возвращается пустая строка."
+}
+---
+
+## Описание {#description}
+
+Извлекает из URL «первый допустимый поддомен» и возвращает его. Если URL некорректен, возвращается пустая строка.
+
+## Синтаксис {#syntax}
+
+```sql
+FIRST_SIGNIFICANT_SUBDOMAIN ( <url> )
+```
+
+## Параметры {#parameters}
+
+| Параметр | Описание |
+|-----------|----------------------|
+| `<url>` | URL, из которого нужно извлечь «первый допустимый поддомен» |
+
+## Возвращаемое значение {#return-value}
+
+Первый допустимый поддомен из `<url>`.
+
+## Пример {#example}
+
+```sql
+SELECT FIRST_SIGNIFICANT_SUBDOMAIN("www.baidu.com"),FIRST_SIGNIFICANT_SUBDOMAIN("www.google.com.cn"),FIRST_SIGNIFICANT_SUBDOMAIN("wwwwwwww")
+```
+
+```text
++----------------------------------------------+--------------------------------------------------+-----------------------------------------+
+| first_significant_subdomain('www.baidu.com') | first_significant_subdomain('www.google.com.cn') | first_significant_subdomain('wwwwwwww') |
++----------------------------------------------+--------------------------------------------------+-----------------------------------------+
+| baidu | google | |
++----------------------------------------------+--------------------------------------------------+-----------------------------------------+
+```
diff --git a/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/string-functions/format-number.md b/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/string-functions/format-number.md
new file mode 100644
index 000000000000..0c8d18954e05
--- /dev/null
+++ b/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/string-functions/format-number.md
@@ -0,0 +1,87 @@
+---
+{
+ "title": "FORMAT_NUMBER",
+ "language": "ru",
+ "description": "Функция FORMAT_NUMBER форматирует числовые значения в виде строк с обозначениями единиц. Поддерживаются следующие единицы: K (тысяча), M (миллион), B (миллиард), T (триллион), Q (квадриллион)."
+}
+---
+
+## Описание {#description}
+
+Функция FORMAT_NUMBER форматирует числовые значения в виде строк с обозначениями единиц. Поддерживаются следующие единицы: K (тысяча), M (миллион), B (миллиард), T (триллион), Q (квадриллион).
+
+## Синтаксис {#syntax}
+
+```sql
+FORMAT_NUMBER(<val>)
+```
+
+## Параметры {#parameters}
+
+| Параметр | Описание |
+| -------- | ----------------------------------------- |
+| `<val>` | Числовое значение для форматирования. Тип: DOUBLE |
+
+## Возвращаемое значение {#return-value}
+
+Возвращает значение типа VARCHAR — отформатированную строку с обозначением единицы.
+
+Особые случаи:
+- Если параметр равен NULL, возвращает NULL
+- Числа меньше 1000 возвращаются без изменений и без обозначения единицы
+- Правила преобразования единиц:
+ - K: тысяча (1,000)
+ - M: миллион (1,000,000)
+ - B: миллиард (1,000,000,000)
+ - T: триллион (1,000,000,000,000)
+ - Q: квадриллион (1,000,000,000,000,000)
+
+## Примеры {#examples}
+
+1. Базовое использование: тысячи (K)
+```sql
+SELECT format_number(1500);
+```
+```text
++---------------------+
+| format_number(1500) |
++---------------------+
+| 1.50K |
++---------------------+
+```
+
+2. Миллионы (M)
+```sql
+SELECT format_number(5000000);
+```
+```text
++------------------------+
+| format_number(5000000) |
++------------------------+
+| 5.00M |
++------------------------+
+```
+
+3. Числа меньше тысячи
+```sql
+SELECT format_number(999);
+```
+```text
++----------------------------------+
+| format_number(cast(999 as DOUBLE))|
++----------------------------------+
+| 999 |
++----------------------------------+
+```
+
+4. Обработка значения NULL
+```sql
+SELECT format_number(NULL);
+```
+```text
++---------------------+
+| format_number(NULL) |
++---------------------+
+| NULL |
++---------------------+
+```
diff --git a/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/string-functions/format.md b/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/string-functions/format.md
new file mode 100644
index 000000000000..833b4e669a65
--- /dev/null
+++ b/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/string-functions/format.md
@@ -0,0 +1,96 @@
+---
+{
+ "title": "FORMAT",
+ "language": "ru",
+ "description": "Функция FORMAT возвращает строку, отформатированную с использованием указанной строки формата и параметров."
+}
+---
+
+## Описание {#description}
+
+Функция FORMAT возвращает строку, отформатированную с использованием указанной строки формата и параметров. Правила форматирования соответствуют [спецификации формата fmt](https://fmt.dev/11.1/syntax/#format-specification-mini-language).
+
+## Синтаксис {#syntax}
+
+```sql
+FORMAT(<format>, <args>[, ...])
+```
+
+## Параметры {#parameters}
+
+| Параметр | Описание |
+| ---------- | ----------------------------------------- |
+| `<format>` | Строка формата, содержащая заполнители. Тип: VARCHAR |
+| `<args>` | Параметры для форматирования (может быть несколько). Тип: ANY |
+
+## Возвращаемое значение {#return-value}
+
+Возвращает значение типа VARCHAR, представляющее результат форматирования согласно строке формата.
+
+Особые случаи:
+- Если хотя бы один параметр равен NULL, возвращается NULL
+- В строке формата в качестве заполнителя используется `{}`
+- Поддерживаются позиционные параметры (например, `{0}`, `{1}`) и именованные параметры
+- Поддерживаются различные настройки форматирования (выравнивание, точность, заполнение и т. д.)
+
+## Примеры {#examples}
+
+1. Базовое использование: форматирование числа с заданной точностью
+```sql
+SELECT format('{:.2}', pi());
+```
+```text
++-----------------------+
+| format('{:.2}', pi()) |
++-----------------------+
+| 3.1 |
++-----------------------+
+```
+
+2. Форматирование нескольких параметров
+```sql
+SELECT format('{0}-{1}', 'hello', 'world');
+```
+```text
++-------------------------------------+
+| format('{0}-{1}', 'hello', 'world') |
++-------------------------------------+
+| hello-world |
++-------------------------------------+
+```
+
+3. Выравнивание и заполнение
+```sql
+SELECT format('{:>10}', 123);
+```
+```text
++-----------------------+
+| format('{:>10}', 123) |
++-----------------------+
+| 123 |
++-----------------------+
+```
+
+4. Обработка значения NULL
+```sql
+SELECT format('{:.2}', NULL);
+```
+```text
++-----------------------+
+| format('{:.2}', NULL) |
++-----------------------+
+| NULL |
++-----------------------+
+```
+
+5. Обработка строк UTF-8
+```sql
+SELECT format('{0}-{1}', 'ṭṛṭṛ', 'ṭṛ');
+```
+```text
++---------------------------------------------+
+| format('{0}-{1}', 'ṭṛṭṛ', 'ṭṛ') |
++---------------------------------------------+
+| ṭṛṭṛ-ṭṛ |
++---------------------------------------------+
+```
diff --git a/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/string-functions/from-base64.md b/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/string-functions/from-base64.md
new file mode 100644
index 000000000000..4a4284987c4e
--- /dev/null
+++ b/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/string-functions/from-base64.md
@@ -0,0 +1,169 @@
+---
+{
+ "title": "FROM_BASE64",
+ "language": "ru",
+ "description": "Функция FROMBASE64 декодирует строку в кодировке Base64, восстанавливая исходную строку."
+}
+---
+
+## Описание {#description}
+
+Функция FROM_BASE64 декодирует строку в кодировке Base64, восстанавливая исходную строку. Она выполняет операцию, обратную TO_BASE64, и соответствует стандарту RFC 4648. Кодировка Base64 обычно используется для передачи двоичных данных в текстовых протоколах, а эта функция позволяет восстановить закодированные данные. Она поддерживает стандартный набор символов Base64 (A-Z, a-z, 0-9, +, /) и символ заполнения (=).
+
+## Синтаксис {#syntax}
+
+```sql
+FROM_BASE64(<str>)
+```
+
+## Параметры {#parameters}
+
+| Параметр | Описание |
+|---------|-----------------|
+| `<str>` | Строка в кодировке Base64, которую нужно декодировать. Тип: VARCHAR |
+
+## Возвращаемое значение {#return-value}
+
+Возвращает значение типа VARCHAR, представляющее исходную строку после декодирования Base64.
+
+Правила декодирования:
+- Принимает стандартный набор символов Base64: A-Z, a-z, 0-9, +, /
+- Поддерживает символ заполнения =
+- Соответствует стандарту RFC 4648
+- Длина входной строки должна быть кратна 4 (за исключением пустой строки)
+- Результат декодирования может содержать непечатаемые символы
+
+Особые случаи:
+- Если входное значение равно NULL, возвращает NULL
+- Если входная строка содержит недопустимые символы Base64 (включая пробельные символы, такие как пробелы и переводы строк), возвращает NULL
+- Если входная строка пустая, возвращает пустую строку
+- Если длина входной строки не кратна 4, возвращает NULL
+- Если заполнение некорректно или формат недопустим, возвращает NULL
+
+:::info Примечание к версии (4.0.8)
+
+В версии 4.0.8 исправлен расчёт размера буфера декодирования для `FROM_BASE64` и определено поведение при некорректных входных данных: если длина входной строки не кратна 4, сразу возвращается NULL. Ранее размер буфера составлял половину длины входной строки, чего было недостаточно, поэтому некорректные входные данные могли приводить к записи за пределами буфера. Расчёт размера буфера кодирования для `TO_BASE64` исправлен в той же версии.
+
+:::
+
+## Примеры {#examples}
+
+1. Базовое декодирование
+```sql
+SELECT FROM_BASE64('MQ=='), FROM_BASE64('QQ==');
+```
+```text
++---------------------+---------------------+
+| FROM_BASE64('MQ==') | FROM_BASE64('QQ==') |
++---------------------+---------------------+
+| 1 | A |
++---------------------+---------------------+
+```
+
+2. Декодирование нескольких символов
+```sql
+SELECT FROM_BASE64('MjM0'), FROM_BASE64('SGVsbG8=');
+```
+```text
++---------------------+-------------------------+
+| FROM_BASE64('MjM0') | FROM_BASE64('SGVsbG8=') |
++---------------------+-------------------------+
+| 234 | Hello |
++---------------------+-------------------------+
+```
+
+3. Обработка значения NULL
+```sql
+SELECT FROM_BASE64(NULL);
+```
+```text
++-------------------+
+| FROM_BASE64(NULL) |
++-------------------+
+| NULL |
++-------------------+
+```
+
+4. Обработка пустой строки
+```sql
+SELECT FROM_BASE64('');
+```
+```text
++-----------------+
+| FROM_BASE64('') |
++-----------------+
+| |
++-----------------+
+```
+
+5. Обработка недопустимых символов
+```sql
+SELECT FROM_BASE64('!!!'), FROM_BASE64('ABC@DEF');
+```
+```text
++--------------------+------------------------+
+| FROM_BASE64('!!!') | FROM_BASE64('ABC@DEF') |
++--------------------+------------------------+
+| NULL | NULL |
++--------------------+------------------------+
+```
+
+6. Более длинные данные
+```sql
+SELECT FROM_BASE64('SGVsbG8gV29ybGQ='), FROM_BASE64('VGhlIHF1aWNrIGJyb3duIGZveA==');
+```
+```text
++---------------------------------+---------------------------------------------+
+| FROM_BASE64('SGVsbG8gV29ybGQ=') | FROM_BASE64('VGhlIHF1aWNrIGJyb3duIGZveA==') |
++---------------------------------+---------------------------------------------+
+| Hello World | The quick brown fox |
++---------------------------------+---------------------------------------------+
+```
+
+7. Многобайтовые данные в UTF-8
+```sql
+SELECT FROM_BASE64('4bmt4bmbw6w='), FROM_BASE64('4biN4biNdW1haSBoZWxsbw==');
+```
+```text
++-----------------------------+-----------------------------------------+
+| FROM_BASE64('4bmt4bmbw6w=') | FROM_BASE64('4biN4biNdW1haSBoZWxsbw==') |
++-----------------------------+-----------------------------------------+
+| ṭṛì | ḍḍumai hello |
++-----------------------------+-----------------------------------------+
+```
+
+8. Адреса электронной почты
+```sql
+SELECT FROM_BASE64('dXNlckBleGFtcGxlLmNvbQ=='), FROM_BASE64('YWRtaW4udGVzdEBjb21wYW55Lm9yZw==');
+```
+```text
++-----------------------------------------+-------------------------------------------------+
+| FROM_BASE64('dXNlckBleGFtcGxlLmNvbQ==') | FROM_BASE64('YWRtaW4udGVzdEBjb21wYW55Lm9yZw==') |
++-----------------------------------------+-------------------------------------------------+
+| user@example.com | admin.test@company.org |
++-----------------------------------------+-------------------------------------------------+
+```
+
+9. Данные JSON
+```sql
+SELECT FROM_BASE64('eyJuYW1lIjoiSm9obiIsImFnZSI6MzB9'), FROM_BASE64('WzEsMiwzLDQsNV0=');
+```
+```text
++-------------------------------------------------+---------------------------------+
+| FROM_BASE64('eyJuYW1lIjoiSm9obiIsImFnZSI6MzB9') | FROM_BASE64('WzEsMiwzLDQsNV0=') |
++-------------------------------------------------+---------------------------------+
+| {"name":"John","age":30} | [1,2,3,4,5] |
++-------------------------------------------------+---------------------------------+
+```
+
+10. Кодирование и обратное декодирование с помощью `TO_BASE64`
+```sql
+SELECT FROM_BASE64(TO_BASE64('Hello')), FROM_BASE64(TO_BASE64('测试'));
+```
+```text
++---------------------------------+----------------------------------+
+| FROM_BASE64(TO_BASE64('Hello')) | FROM_BASE64(TO_BASE64('测试')) |
++---------------------------------+----------------------------------+
+| Hello | 测试 |
++---------------------------------+----------------------------------+
+```
diff --git a/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/string-functions/hamming_distance.md b/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/string-functions/hamming_distance.md
new file mode 100644
index 000000000000..0a820d36ca27
--- /dev/null
+++ b/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/string-functions/hamming_distance.md
@@ -0,0 +1,37 @@
+---
+{
+ "title": "HAMMING_DISTANCE",
+ "language": "ru",
+ "description": "Функция HAMMING_DISTANCE возвращает количество позиций, в которых различаются две строки одинаковой длины."
+}
+---
+
+## Описание {#description}
+Функция `HAMMING_DISTANCE` возвращает количество позиций, в которых различаются две строки одинаковой длины.
+
+Эта функция подсчитывает символы в кодировке UTF-8.
+
+## Синтаксис {#syntax}
+```sql
+HAMMING_DISTANCE(<str1>, <str2>)
+```
+
+## Параметры {#parameters}
+| Параметр | Описание |
+| -- | -- |
+| `<str1>` | Первая строка |
+| `<str2>` | Вторая строка |
+
+## Возвращаемое значение {#return-value}
+Возвращает значение типа BIGINT.
+
+## Примеры {#examples}
+```sql
+SELECT hamming_distance('karolin', 'kathrin'); -- 3
+SELECT hamming_distance('数据库', '数据仓'); -- 1
+```
+
+## Примечания {#notes}
+- Обе строки должны иметь одинаковую длину. В противном случае возвращается ошибка.
+- Поддерживаются символы UTF-8.
+- Если на вход подано значение NULL, возвращается NULL.
diff --git a/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/string-functions/hex.md b/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/string-functions/hex.md
new file mode 100644
index 000000000000..a8b6e4186717
--- /dev/null
+++ b/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/string-functions/hex.md
@@ -0,0 +1,104 @@
+---
+{
+ "title": "HEX",
+ "language": "ru",
+ "description": "Функция HEX преобразует входные параметры в строковое шестнадцатеричное представление."
+}
+---
+
+## Описание {#description}
+
+Функция HEX преобразует входные параметры в строковое шестнадцатеричное представление. Эта функция совместима с MySQL и поддерживает как числовые, так и строковые входные данные, применяя к ним разные правила преобразования.
+
+Если входной параметр — число (типа BIGINT), функция возвращает строковое шестнадцатеричное представление этого числа.
+
+Если входной параметр — строка, функция преобразует каждый символ (побайтово) в два шестнадцатеричных символа, затем объединяет все преобразованные символы в результирующую строку.
+
+## Синтаксис {#syntax}
+
+```sql
+HEX(<expr>)
+```
+
+## Параметры {#parameters}
+
+| Параметр | Описание |
+|-------|--------------|
+| `<expr>` | Входной параметр: число типа BIGINT или строка типа VARCHAR |
+
+## Возвращаемое значение {#return-value}
+
+Возвращает шестнадцатеричное представление входного параметра в виде значения типа VARCHAR.
+
+Правила преобразования:
+- Числовые входные данные: преобразуются в соответствующее шестнадцатеричное значение (в пределах диапазона BIGINT)
+- Строковые входные данные: каждый байт преобразуется в два шестнадцатеричных символа верхнего регистра
+- Отрицательные числа преобразуются с использованием двоичного представления в дополнительном коде
+
+Особые случаи:
+- Если параметр равен NULL, возвращается NULL
+- Число 0 преобразуется в '0'
+- Пустая строка преобразуется в пустую строку
+- Отрицательные числа преобразуются в шестнадцатеричное представление 64-битного дополнительного кода
+
+## Примеры {#examples}
+
+1. Простое преобразование чисел
+```sql
+SELECT HEX(12), HEX(-1);
+```
+```text
++---------+------------------+
+| HEX(12) | HEX(-1) |
++---------+------------------+
+| C | FFFFFFFFFFFFFFFF |
++---------+------------------+
+```
+
+2. Преобразование строк
+```sql
+SELECT HEX('1'), HEX('@'), HEX('12');
+```
+```text
++----------+----------+-----------+
+| HEX('1') | HEX('@') | HEX('12') |
++----------+----------+-----------+
+| 31 | 40 | 3132 |
++----------+----------+-----------+
+```
+
+3. Преобразование больших целых чисел
+```sql
+SELECT HEX(255), HEX(65535), HEX(16777215);
+```
+```text
++----------+------------+----------------+
+| HEX(255) | HEX(65535) | HEX(16777215) |
++----------+------------+----------------+
+| FF | FFFF | FFFFFF |
++----------+------------+----------------+
+```
+
+4. Обработка значения NULL
+```sql
+SELECT HEX(NULL);
+```
+```text
++-----------+
+| HEX(NULL) |
++-----------+
+| NULL |
++-----------+
+```
+
+5. Ноль и пустая строка
+```sql
+SELECT HEX(0), HEX('');
+```
+```text
++--------+--------+
+| HEX(0) | HEX('') |
++--------+--------+
+| 0 | |
++--------+--------+
+```
diff --git a/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/string-functions/initcap.md b/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/string-functions/initcap.md
new file mode 100644
index 000000000000..ce9a99fa7b4a
--- /dev/null
+++ b/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/string-functions/initcap.md
@@ -0,0 +1,90 @@
+---
+{
+ "title": "INITCAP",
+ "language": "ru",
+ "description": "Функция INITCAP переводит первую букву каждого слова в строке в верхний регистр, а остальные буквы в нижний регистр."
+}
+---
+
+## Описание {#description}
+
+Функция INITCAP переводит первую букву каждого слова в строке в верхний регистр, а остальные буквы в нижний регистр. Словом считается последовательность букв и цифр, отделённая от других слов символами, не являющимися буквами или цифрами. Эта функция подходит для форматирования имён, заголовков и других случаев, требующих единообразного оформления регистра.
+
+## Синтаксис {#syntax}
+
+```sql
+INITCAP(<str>)
+```
+
+## Параметры {#parameters}
+
+| Параметр | Описание |
+|---------|-----------|
+| `<str>` | Строка, в которой нужно преобразовать регистр. Тип: VARCHAR |
+
+## Возвращаемое значение {#return-value}
+
+Возвращает преобразованную строку типа VARCHAR.
+
+Правила преобразования:
+- Первая буква каждого слова переводится в верхний регистр
+- Остальные буквы слова переводятся в нижний регистр
+- Слова разделяются символами, не являющимися буквами или цифрами (пробелами, знаками препинания, специальными символами и т. д.)
+- Регистр цифровых символов не изменяется
+- Поддерживается преобразование регистра символов Unicode
+
+Особые случаи:
+- Если параметр равен NULL, возвращается NULL
+- Если строка пустая, возвращается пустая строка
+- Последовательность символов, не являющихся буквами или цифрами, считается одним разделителем
+- Буквы в начале строки переводятся в верхний регистр
+
+## Примеры {#examples}
+
+1. Преобразование первых букв слов в заглавные
+```sql
+SELECT INITCAP('hello world');
+```
+```text
++------------------------+
+| INITCAP('hello world') |
++------------------------+
+| Hello World |
++------------------------+
+```
+
+2. Преобразование строки со смешанным регистром
+```sql
+SELECT INITCAP('hELLo WoRLD');
+```
+```text
++------------------------+
+| INITCAP('hELLo WoRLD') |
++------------------------+
+| Hello World |
++------------------------+
+```
+
+3. Обработка значения NULL
+```sql
+SELECT INITCAP(NULL);
+```
+```text
++---------------+
+| INITCAP(NULL) |
++---------------+
+| NULL |
++---------------+
+```
+
+4. Строка с цифрами и символами
+```sql
+SELECT INITCAP('hello hello.,HELLO123HELlo');
+```
+```text
++---------------------------------------+
+| INITCAP('hello hello.,HELLO123HELlo') |
++---------------------------------------+
+| Hello Hello.,Hello123hello |
++---------------------------------------+
+```
diff --git a/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/string-functions/instr.md b/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/string-functions/instr.md
new file mode 100644
index 000000000000..1d72c4fbf4de
--- /dev/null
+++ b/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/string-functions/instr.md
@@ -0,0 +1,163 @@
+---
+{
+ "title": "INSTR",
+ "language": "ru",
+ "description": "Функция INSTR возвращает позицию первого вхождения подстроки в основной строке; отсчёт позиций начинается с 1."
+}
+---
+
+## Описание {#description}
+
+Функция INSTR возвращает позицию первого вхождения подстроки в основной строке; отсчёт позиций начинается с 1. Это часто используемая функция поиска в строках, которая поддерживает точное сопоставление и учитывает регистр. Функция широко применяется при обработке текста, очистке данных и анализе строк.
+
+## Синтаксис {#syntax}
+
+```sql
+INSTR(<str>, <substr>)
+```
+
+## Параметры {#parameters}
+
+| Параметр | Описание |
+|--------|-----------|
+| `<str>` | Основная строка, в которой выполняется поиск. Тип: VARCHAR |
+| `<substr>` | Искомая подстрока. Тип: VARCHAR |
+
+## Возвращаемое значение {#return-value}
+
+Возвращает значение типа INT, обозначающее позицию первого вхождения подстроки в основной строке.
+
+Правила поиска:
+- Возвращает индекс позиции, отсчитываемый с 1 (а не с 0)
+- Если подстрока не найдена, возвращает 0
+- Поиск учитывает регистр
+- Поддерживает корректное определение позиций для многобайтовых символов UTF-8
+- Предусмотрена особая обработка пустых строк
+
+Особые случаи:
+- Если любой из параметров равен NULL, возвращает NULL
+- Если подстрока является пустой строкой, возвращает 1 (пустая строка «присутствует» в любой позиции)
+- Если основная строка пуста, а подстрока нет, возвращает 0
+- Поддерживает поиск подстрок, содержащих специальные знаки и символы
+
+## Примеры {#examples}
+
+1. Простой поиск символа
+```sql
+SELECT INSTR('abc', 'b'), INSTR('abc', 'd');
+```
+```text
++-------------------+-------------------+
+| INSTR('abc', 'b') | INSTR('abc', 'd') |
++-------------------+-------------------+
+| 2 | 0 |
++-------------------+-------------------+
+```
+
+2. Поиск подстроки
+```sql
+SELECT INSTR('hello world', 'world'), INSTR('hello world', 'WORLD');
+```
+```text
++------------------------------+------------------------------+
+| INSTR('hello world', 'world') | INSTR('hello world', 'WORLD') |
++------------------------------+------------------------------+
+| 7 | 0 |
++------------------------------+------------------------------+
+```
+
+3. Обработка значений NULL
+```sql
+SELECT INSTR(NULL, 'test'), INSTR('test', NULL);
+```
+```text
++---------------------+---------------------+
+| INSTR(NULL, 'test') | INSTR('test', NULL) |
++---------------------+---------------------+
+| NULL | NULL |
++---------------------+---------------------+
+```
+
+4. Обработка пустых строк
+```sql
+SELECT INSTR('hello', ''), INSTR('', 'world');
+```
+```text
++--------------------+---------------------+
+| INSTR('hello', '') | INSTR('', 'world') |
++--------------------+---------------------+
+| 1 | 0 |
++--------------------+---------------------+
+```
+
+5. Повторные вхождения (возвращается первое совпадение)
+```sql
+SELECT INSTR('abcabc', 'abc'), INSTR('banana', 'a');
+```
+```text
++------------------------+----------------------+
+| INSTR('abcabc', 'abc') | INSTR('banana', 'a') |
++------------------------+----------------------+
+| 1 | 2 |
++------------------------+----------------------+
+```
+
+6. Специальные знаки и символы
+```sql
+SELECT INSTR('user@example.com', '@'), INSTR('price: $99.99', '$');
+```
+```text
++--------------------------------+-----------------------------+
+| INSTR('user@example.com', '@') | INSTR('price: $99.99', '$') |
++--------------------------------+-----------------------------+
+| 5 | 8 |
++--------------------------------+-----------------------------+
+```
+
+7. Многобайтовые символы UTF-8
+```sql
+SELECT INSTR('ṭṛì ḍḍumai hello', 'ḍḍumai'), INSTR('ṭṛì ḍḍumai hello', 'hello');
+```
+```text
++--------------------------------------------------+---------------------------------------------+
+| INSTR('ṭṛì ḍḍumai hello', 'ḍḍumai') | INSTR('ṭṛì ḍḍumai hello', 'hello') |
++--------------------------------------------------+---------------------------------------------+
+| 5 | 12 |
++--------------------------------------------------+---------------------------------------------+
+```
+
+8. Строки с числами
+```sql
+SELECT INSTR('123456789', '456'), INSTR('123-456-789', '-');
+```
+```text
++---------------------------+---------------------------+
+| INSTR('123456789', '456') | INSTR('123-456-789', '-') |
++---------------------------+---------------------------+
+| 4 | 4 |
++---------------------------+---------------------------+
+```
+
+9. Поиск подстроки в тексте из нескольких слов
+```sql
+SELECT INSTR('The quick brown fox', 'quick'), INSTR('The quick brown fox', 'slow');
+```
+```text
++---------------------------------------+--------------------------------------+
+| INSTR('The quick brown fox', 'quick') | INSTR('The quick brown fox', 'slow') |
++---------------------------------------+--------------------------------------+
+| 5 | 0 |
++---------------------------------------+--------------------------------------+
+```
+
+10. Поиск в путях и URL
+```sql
+SELECT INSTR('/home/user/file.txt', '/'), INSTR('https://www.example.com', '://');
+```
+```text
++-----------------------------------+-----------------------------------------+
+| INSTR('/home/user/file.txt', '/') | INSTR('https://www.example.com', '://') |
++-----------------------------------+-----------------------------------------+
+| 1 | 6 |
++-----------------------------------+-----------------------------------------+
+```
diff --git a/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/string-functions/int-to-uuid.md b/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/string-functions/int-to-uuid.md
new file mode 100644
index 000000000000..2488f5a4dd50
--- /dev/null
+++ b/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/string-functions/int-to-uuid.md
@@ -0,0 +1,57 @@
+---
+{
+ "title": "INT_TO_UUID",
+ "language": "ru",
+ "description": "Преобразует входное закодированное значение LARGEINT в исходную строку UUID."
+}
+---
+
+## Описание {#description}
+
+Преобразует входное закодированное значение LARGEINT в исходную строку UUID.
+
+Эта функция по-прежнему возвращает строку. Для перехода на нативный [тип UUID](../../../basic-element/sql-data-types/uuid.md) используйте `CAST(INT_TO_UUID(<int128>) AS UUID)`; прямое приведение типов между LARGEINT и UUID не поддерживается.
+
+## Синтаксис {#syntax}
+
+```sql
+INT_TO_UUID(<int128>)
+```
+
+## Параметры {#parameters}
+
+| Параметр | Описание |
+|------------|-----------------|
+| `<int128>` | Закодированное значение LARGEINT |
+
+## Возвращаемое значение {#return-value}
+
+Возвращает исходную строку UUID для параметра `<int128>`.
+
+- Если входное значение равно NULL, возвращает NULL
+
+## Примеры {#examples}
+
+```sql
+SELECT INT_TO_UUID(95721955514869408091759290071393952876)
+```
+
+```text
++-----------------------------------------------------+
+| int_to_uuid(95721955514869408091759290071393952876) |
++-----------------------------------------------------+
+| 6ce4766f-6783-4b30-b357-bba1c7600348 |
++-----------------------------------------------------+
+```
+
+```sql
+SELECT INT_TO_UUID(NULL);
+```
+
+```text
++-------------------+
+| INT_TO_UUID(NULL) |
++-------------------+
+| NULL |
++-------------------+
+```
diff --git a/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/string-functions/is-uuid.md b/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/string-functions/is-uuid.md
new file mode 100644
index 000000000000..7f1e83b4d68e
--- /dev/null
+++ b/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/string-functions/is-uuid.md
@@ -0,0 +1,102 @@
+---
+{
+ "title": "IS_UUID",
+ "language": "ru",
+ "description": "Если параметр представляет собой корректный UUID, возвращает 1. Если UUID некорректен, возвращает 0. Если параметр равен NULL, возвращает NULL."
+}
+---
+
+## Описание {#description}
+
+Если параметр представляет собой корректный UUID, возвращает 1. Если UUID некорректен, возвращает 0. Если параметр равен NULL, возвращает NULL.
+
+UUID считается корректным, если он имеет правильную длину и содержит только допустимые символы (шестнадцатеричные цифры в любом регистре, а также необязательные дефисы и фигурные скобки). Он может быть представлен в одном из следующих трёх форматов:
+```text
+aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee
+aaaaaaaabbbbccccddddeeeeeeeeeeee
+{aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee}
+```
+
+Эта функция использует иные правила проверки текста, чем встроенный [тип UUID](../../../basic-element/sql-data-types/uuid.md): она принимает канонические UUID в фигурных скобках, тогда как встроенный парсер их отклоняет. Для проверки текста, предназначенного для столбца встроенного типа UUID, используйте [TO_UUID_OR_NULL](../uuid-functions/to-uuid-or-null.md) или `TRY_CAST(<str> AS UUID)`.
+
+## Синтаксис {#syntax}
+
+```sql
+IS_UUID ( <str> )
+```
+
+## Параметры {#parameters}
+| Параметр | Описание |
+|------------|-----------------|
+| `<str>` | Строка |
+
+
+## Возвращаемое значение {#return-value}
+
+Если `<str>` представляет собой корректный UUID, возвращает 1; в противном случае возвращает 0.
+
+Особые случаи:
+- Если параметр равен NULL, возвращает NULL.
+
+## Примеры {#examples}
+
+
+```sql
+select is_uuid("88a06b4a-732c-48bd-9984-fecb81285cc1");
+```
+
+```text
++-------------------------------------------------+
+| is_uuid("88a06b4a-732c-48bd-9984-fecb81285cc1") |
++-------------------------------------------------+
+| 1 |
++-------------------------------------------------+
+```
+
+```sql
+select is_uuid("{88a06b4a-732c-48bd-9984-fecb81285cc1}");
+```
+
+```text
++-------------------------------------------------+
+| is_uuid("88a06b4a-732c-48bd-9984-fecb81285cc1") |
++-------------------------------------------------+
+| 1 |
++-------------------------------------------------+
+```
+
+```sql
+select is_uuid("88a06b4a732c48bd9984fecb81285cc1");
+```
+
+```text
++---------------------------------------------+
+| is_uuid("88a06b4a732c48bd9984fecb81285cc1") |
++---------------------------------------------+
+| 1 |
++---------------------------------------------+
+```
+
+```sql
+select is_uuid("{88a06b4a732c48bd9984fecb81285cc1}");
+```
+
+```text
++-----------------------------------------------+
+| is_uuid("{88a06b4a732c48bd9984fecb81285cc1}") |
++-----------------------------------------------+
+| 0 |
++-----------------------------------------------+
+```
+
+```sql
+select is_uuid(NULL);
+```
+
+```text
++---------------+
+| is_uuid(NULL) |
++---------------+
+| NULL |
++---------------+
+```
diff --git a/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/string-functions/is-valid-utf8.md b/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/string-functions/is-valid-utf8.md
new file mode 100644
index 000000000000..a1db8cbc2b32
--- /dev/null
+++ b/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/string-functions/is-valid-utf8.md
@@ -0,0 +1,146 @@
+---
+{
+ "title": "IS_VALID_UTF8",
+ "language": "ru",
+ "description": "Функция IS_VALID_UTF8 проверяет, содержит ли строка корректные данные в кодировке UTF-8. Возвращает true, если строка содержит корректные данные в кодировке UTF-8, и false в противном случае."
+}
+---
+
+## Описание {#description}
+
+Функция IS_VALID_UTF8 проверяет, содержит ли строка корректные данные в кодировке UTF-8. Она проверяет каждую последовательность байтов во входных данных и возвращает `true`, если все последовательности соответствуют стандарту кодировки UTF-8, или `false`, если обнаружена хотя бы одна недопустимая последовательность байтов.
+
+Это полезно при работе с данными, импортированными из внешних источников (файлов, сетевых потоков и т. д.), которые могут содержать двоичные данные или содержимое с некорректной кодировкой, когда необходимо проверить целостность данных перед выполнением операций со строками.
+
+## Псевдоним {#alias}
+
+- `ISVALIDUTF8()`
+
+## Синтаксис {#syntax}
+
+```sql
+IS_VALID_UTF8(<str>)
+```
+
+## Параметры {#parameters}
+
+| Параметр | Описание |
+|-----------|-------------|
+| `<str>` | Строка для проверки. Тип: VARCHAR или STRING |
+
+## Возвращаемое значение {#return-value}
+
+Возвращает значение типа BOOLEAN.
+
+- Возвращает `true`, если строка содержит корректные данные в кодировке UTF-8.
+- Возвращает `false`, если строка содержит хотя бы одну недопустимую последовательность байтов UTF-8.
+
+Особые случаи:
+- Если параметр равен NULL, возвращает NULL.
+- Пустая строка считается корректной строкой UTF-8, возвращает `true`.
+
+## Примеры {#examples}
+
+1. Корректные строки ASCII
+
+```sql
+SELECT IS_VALID_UTF8('hello');
+```
+
+```text
++------------------------+
+| is_valid_utf8('hello') |
++------------------------+
+| 1 |
++------------------------+
+```
+
+2. Корректные многобайтовые символы UTF-8 (китайские иероглифы)
+
+```sql
+SELECT IS_VALID_UTF8('Hello, 世界');
+```
+
+```text
++-----------------------------+
+| is_valid_utf8('Hello, 世界') |
++-----------------------------+
+| 1 |
++-----------------------------+
+```
+
+3. Пустая строка
+
+```sql
+SELECT IS_VALID_UTF8('');
+```
+
+```text
++--------------------+
+| is_valid_utf8('') |
++--------------------+
+| 1 |
++--------------------+
+```
+
+4. Недопустимые байты UTF-8 (полученные с помощью UNHEX)
+
+```sql
+SELECT IS_VALID_UTF8(UNHEX('C0AF'));
+```
+
+```text
++------------------------------+
+| is_valid_utf8(unhex('C0AF')) |
++------------------------------+
+| 0 |
++------------------------------+
+```
+
+5. Обработка значения NULL
+
+```sql
+SELECT IS_VALID_UTF8(NULL);
+```
+
+```text
++---------------------+
+| is_valid_utf8(NULL) |
++---------------------+
+| NULL |
++---------------------+
+```
+
+6. Использование с данными таблицы
+
+```sql
+CREATE TABLE test_utf8 (
+ id INT,
+ val VARCHAR(200)
+) DISTRIBUTED BY HASH(id) BUCKETS 1
+PROPERTIES ("replication_num" = "1");
+
+INSERT INTO test_utf8 VALUES
+(1, 'hello'),
+(2, ''),
+(3, 'Hello, 世界'),
+(4, NULL);
+
+INSERT INTO test_utf8 VALUES (5, UNHEX('C0AF'));
+INSERT INTO test_utf8 VALUES (6, UNHEX('FF'));
+
+SELECT id, IS_VALID_UTF8(val) FROM test_utf8 ORDER BY id;
+```
+
+```text
++------+--------------------+
+| id | is_valid_utf8(val) |
++------+--------------------+
+| 1 | 1 |
+| 2 | 1 |
+| 3 | 1 |
+| 4 | NULL |
+| 5 | 0 |
+| 6 | 0 |
++------+--------------------+
+```
diff --git a/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/string-functions/lcase.md b/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/string-functions/lcase.md
new file mode 100644
index 000000000000..dd2e7dc12c5c
--- /dev/null
+++ b/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/string-functions/lcase.md
@@ -0,0 +1,76 @@
+---
+{
+ "title": "LCASE/LOWER",
+ "language": "ru",
+ "description": "Функция LCASE (псевдоним LOWER) преобразует все прописные буквы в строке в строчные."
+}
+---
+
+## Описание {#description}
+
+Функция LCASE (псевдоним LOWER) преобразует все прописные буквы в строке в строчные.
+
+## Синтаксис {#syntax}
+
+```sql
+LCASE(<str>)
+LOWER(<str>)
+```
+
+## Параметры {#parameters}
+
+| Параметр | Описание |
+|---------|--------------|
+| `<str>` | Строка для преобразования в нижний регистр. Тип: VARCHAR |
+
+## Возвращаемое значение {#return-value}
+
+Возвращает значение типа VARCHAR — строку после преобразования в нижний регистр.
+
+Правила преобразования:
+- Все прописные буквы в строке преобразуются в соответствующие строчные буквы
+- Символы, не являющиеся буквами (цифры, знаки, пробелы и т. д.), остаются без изменений
+- Буквы, которые уже являются строчными, остаются без изменений
+
+Особые случаи:
+- Если параметр равен NULL, возвращается NULL
+- Если строка пустая, возвращается пустая строка
+- Если строка не содержит прописных букв, возвращается исходная строка
+
+## Примеры {#examples}
+
+1. Простое преобразование английских букв
+```sql
+SELECT LOWER('AbC123'), LCASE('AbC123');
+```
+```text
++-----------------+-----------------+
+| LOWER('AbC123') | LCASE('AbC123') |
++-----------------+-----------------+
+| abc123 | abc123 |
++-----------------+-----------------+
+```
+
+2. Обработка строки с разными типами символов
+```sql
+SELECT LOWER('Hello World!'), LCASE('TEST@123');
+```
+```text
++----------------------+------------------+
+| LOWER('Hello World!') | LCASE('TEST@123') |
++----------------------+------------------+
+| hello world! | test@123 |
++----------------------+------------------+
+```
+
+3. Обработка значения NULL
+```sql
+SELECT LOWER(NULL), LCASE(NULL);
+```
+```text
++-------------+-------------+
+| LOWER(NULL) | LCASE(NULL) |
++-------------+-------------+
+| NULL | NULL |
++-------------+-------------+
+```
diff --git a/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/string-functions/length.md b/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/string-functions/length.md
new file mode 100644
index 000000000000..2d156158f9b3
--- /dev/null
+++ b/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/string-functions/length.md
@@ -0,0 +1,151 @@
+---
+{
+ "title": "LENGTH",
+ "language": "ru",
+ "description": "Функция LENGTH возвращает длину строки в байтах. Эта функция вычисляет количество байтов, которое занимает строка в кодировке UTF-8, а не количество символов."
+}
+---
+
+## Описание {#description}
+
+Функция LENGTH возвращает длину строки в байтах. Эта функция вычисляет количество байтов, которое занимает строка в кодировке UTF-8, а не количество символов.
+
+**Обратите внимание на отличие от CHAR_LENGTH:**
+- `LENGTH()` возвращает количество байтов
+- `CHAR_LENGTH()` и `CHARACTER_LENGTH()` возвращают количество символов
+- Для символов ASCII количество байтов равно количеству символов
+- Для многобайтовых символов (например, китайских иероглифов и эмодзи) количество байтов обычно превышает количество символов
+
+## Псевдоним {#alias}
+- `OCTET_LENGTH()`
+
+## Синтаксис {#syntax}
+
+```sql
+LENGTH(<str>)
+```
+
+## Параметры {#parameters}
+
+| Параметр | Описание |
+|---------|---------------|
+| `<str>` | Строка, длину которой в байтах требуется вычислить. Тип: VARCHAR |
+
+## Возвращаемое значение {#return-value}
+
+Возвращает значение типа INT, представляющее длину строки в байтах.
+
+Особые случаи:
+- Если параметр равен NULL, возвращает NULL
+- Для пустой строки возвращает 0
+- Результат представляет собой количество байтов в кодировке UTF-8
+
+## Примеры {#examples}
+
+1. Символы ASCII (количество байтов = количество символов)
+```sql
+SELECT LENGTH('abc'), CHAR_LENGTH('abc');
+```
+```text
++---------------+--------------------+
+| LENGTH('abc') | CHAR_LENGTH('abc') |
++---------------+--------------------+
+| 3 | 3 |
++---------------+--------------------+
+```
+
+2. Китайские иероглифы (количество байтов > количество символов)
+```sql
+SELECT LENGTH('中国'), CHAR_LENGTH('中国');
+```
+```text
++------------------+---------------------+
+| LENGTH('中国') | CHAR_LENGTH('中国') |
++------------------+---------------------+
+| 6 | 2 |
++------------------+---------------------+
+```
+
+3. Обработка значения NULL
+```sql
+SELECT LENGTH(NULL);
+```
+```text
++--------------+
+| LENGTH(NULL) |
++--------------+
+| NULL |
++--------------+
+```
+
+4. Пустая строка
+```sql
+SELECT LENGTH('');
+```
+```text
++------------+
+| LENGTH('') |
++------------+
+| 0 |
++------------+
+```
+
+5. Сочетание символов разных типов
+```sql
+SELECT LENGTH('Hello世界'), CHAR_LENGTH('Hello世界');
+```
+```text
++-----------------------+----------------------------+
+| LENGTH('Hello世界') | CHAR_LENGTH('Hello世界') |
++-----------------------+----------------------------+
+| 11 | 7 |
++-----------------------+----------------------------+
+```
+
+6. Экранированные символы и пробелы ASCII
+```sql
+SELECT LENGTH('\t\n\r'), LENGTH(' ');
+```
+```text
++------------------+--------------+
+| LENGTH('\t\n\r') | LENGTH(' ') |
++------------------+--------------+
+| 3 | 2 |
++------------------+--------------+
+```
+
+7. Многобайтовые символы UTF-8: сравнение длины в байтах и количества символов
+```sql
+SELECT LENGTH('ṭṛì'), CHAR_LENGTH('ṭṛì');
+```
+```text
++--------------------+-------------------------+
+| LENGTH('ṭṛì') | CHAR_LENGTH('ṭṛì') |
++--------------------+-------------------------+
+| 8 | 3 |
++--------------------+-------------------------+
+```
+
+8. Эмодзи (обычно 4 байта на глиф)
+```sql
+SELECT LENGTH('😀😁'), CHAR_LENGTH('😀😁');
+```
+```text
++--------------------+-------------------------+
+| LENGTH('😀😁') | CHAR_LENGTH('😀😁') |
++--------------------+-------------------------+
+| 8 | 2 |
++--------------------+-------------------------+
+```
+
+9. Строки из цифр
+```sql
+SELECT LENGTH('12345'), CHAR_LENGTH('12345');
+```
+```text
++-----------------+----------------------+
+| LENGTH('12345') | CHAR_LENGTH('12345') |
++-----------------+----------------------+
+| 5 | 5 |
++-----------------+----------------------+
+```
diff --git a/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/string-functions/levenshtein.md b/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/string-functions/levenshtein.md
new file mode 100644
index 000000000000..60bd152d067e
--- /dev/null
+++ b/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/string-functions/levenshtein.md
@@ -0,0 +1,156 @@
+---
+{
+ "title": "LEVENSHTEIN",
+ "language": "ru",
+ "description": "Функция LEVENSHTEIN вычисляет расстояние Левенштейна между двумя строками."
+}
+---
+
+## Описание {#description}
+
+Функция `LEVENSHTEIN` вычисляет [расстояние Левенштейна](https://en.wikipedia.org/wiki/Edit_distance) между двумя строками.
+
+Расстояние Левенштейна — это минимальное количество операций редактирования отдельных символов, необходимых для преобразования одной строки в другую. Поддерживаются следующие операции редактирования:
+
+- Вставка символа
+- Удаление символа
+- Замена символа
+
+Функция вычисляет расстояние по символам UTF-8, а не по байтам. Поэтому многобайтовые символы, например китайские иероглифы, учитываются как один символ каждый.
+
+## Псевдонимы {#alias}
+
+- `LEVENSHTEIN_DISTANCE`
+- `EDIT_DISTANCE`
+
+## Синтаксис {#syntax}
+
+```sql
+LEVENSHTEIN(<str1>, <str2>)
+LEVENSHTEIN_DISTANCE(<str1>, <str2>)
+EDIT_DISTANCE(<str1>, <str2>)
+```
+
+## Параметры {#parameters}
+
+| Параметр | Описание |
+| -- | -- |
+| `<str1>` | Первая строка. Тип: VARCHAR |
+| `<str2>` | Вторая строка. Тип: VARCHAR |
+
+## Возвращаемое значение {#return-value}
+
+Возвращает значение типа INT, представляющее расстояние Левенштейна между двумя строками.
+
+Особые случаи:
+
+- Если хотя бы один аргумент равен NULL, возвращает NULL.
+- Если строки совпадают, возвращает 0.
+- Если одна строка пустая, возвращает количество символов в другой строке.
+- Функция коммутативна: `LEVENSHTEIN(a, b)` и `LEVENSHTEIN(b, a)` возвращают одинаковый результат.
+
+## Примеры {#examples}
+
+1. Базовое использование
+
+```sql
+SELECT levenshtein('kitten', 'sitting');
+```
+
+```text
++----------------------------------+
+| levenshtein('kitten', 'sitting') |
++----------------------------------+
+| 3 |
++----------------------------------+
+```
+
+`kitten` можно преобразовать в `sitting` за 3 операции: заменить `k` на `s`, заменить `e` на `i` и вставить `g` в конце.
+
+2. Одинаковые строки
+
+```sql
+SELECT levenshtein('abc', 'abc');
+```
+
+```text
++---------------------------+
+| levenshtein('abc', 'abc') |
++---------------------------+
+| 0 |
++---------------------------+
+```
+
+3. Пустая строка
+
+```sql
+SELECT levenshtein('', 'abc'), levenshtein('数据库', '');
+```
+
+```text
++------------------------+------------------------------+
+| levenshtein('', 'abc') | levenshtein('数据库', '') |
++------------------------+------------------------------+
+| 3 | 3 |
++------------------------+------------------------------+
+```
+
+4. Символы UTF-8
+
+```sql
+SELECT levenshtein('你好世界', '你好世间');
+```
+
+```text
++---------------------------------------------+
+| levenshtein('你好世界', '你好世间') |
++---------------------------------------------+
+| 1 |
++---------------------------------------------+
+```
+
+Для замены `界` на `间` требуется 1 операция.
+
+5. Перестановка соседних символов считается двумя операциями
+
+```sql
+SELECT levenshtein('abcd', 'abdc');
+```
+
+```text
++-----------------------------+
+| levenshtein('abcd', 'abdc') |
++-----------------------------+
+| 2 |
++-----------------------------+
+```
+
+При вычислении расстояния Левенштейна перестановка соседних символов не считается одной операцией, поэтому расстояние между `abcd` и `abdc` равно 2.
+
+6. Использование псевдонимов
+
+```sql
+SELECT levenshtein_distance('abcd', 'abdc'), edit_distance('kitten', 'sitting');
+```
+
+```text
++--------------------------------------+------------------------------------+
+| levenshtein_distance('abcd', 'abdc') | edit_distance('kitten', 'sitting') |
++--------------------------------------+------------------------------------+
+| 2 | 3 |
++--------------------------------------+------------------------------------+
+```
+
+7. Аргументы NULL
+
+```sql
+SELECT levenshtein(NULL, 'abc'), levenshtein('abc', NULL);
+```
+
+```text
++--------------------------+--------------------------+
+| levenshtein(NULL, 'abc') | levenshtein('abc', NULL) |
++--------------------------+--------------------------+
+| NULL | NULL |
++--------------------------+--------------------------+
+```
diff --git a/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/string-functions/locate.md b/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/string-functions/locate.md
new file mode 100644
index 000000000000..e00e1e875de1
--- /dev/null
+++ b/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/string-functions/locate.md
@@ -0,0 +1,165 @@
+---
+{
+ "title": "LOCATE",
+ "language": "ru",
+ "description": "Функция LOCATE возвращает позицию первого вхождения подстроки substr в строке str (отсчёт начинается с 1)."
+}
+---
+
+## Описание {#description}
+
+Функция LOCATE возвращает позицию первого вхождения подстроки substr в строке str (отсчёт начинается с 1). Если указан необязательный третий параметр pos, поиск начинается с указанной позиции в строке str. Эта функция совместима с MySQL и часто используется для поиска совпадений в строках и определения их позиций.
+
+## Синтаксис {#syntax}
+
+```sql
+LOCATE(<substr>, <str> [, <pos>])
+```
+
+## Параметры {#parameters}
+
+| Параметр | Описание |
+|----------|-----------------|
+| `<substr>` | Искомая подстрока. Тип: VARCHAR |
+| `<str>` | Исходная строка, в которой выполняется поиск. Тип: VARCHAR |
+| `<pos>` | Необязательный параметр, задающий начальную позицию поиска (отсчёт с 1). Тип: INT |
+
+## Возвращаемое значение {#return-value}
+
+Возвращает значение типа INT, представляющее позицию первого вхождения substr в str (отсчёт с 1).
+
+Правила поиска:
+- Отсчёт позиций начинается с 1 (а не с 0)
+- Возвращается позиция первого совпадения
+- Если указан pos, поиск начинается с этой позиции, но возвращаемая позиция по-прежнему отсчитывается от начала строки
+- Поиск выполняется с учётом регистра
+
+Особые случаи:
+- Если совпадение не найдено, возвращается 0
+- Если любой из параметров равен NULL, возвращается NULL
+- Если substr является пустой строкой, возвращается 1 (или значение pos, если pos указан и pos > 1)
+- Если str является пустой строкой, а substr нет, возвращается 0
+- Если pos меньше 1, возвращается 0
+- Если pos больше длины str, возвращается 0
+
+## Примеры {#examples}
+
+1. Базовый поиск
+```sql
+SELECT LOCATE('bar', 'foobarbar'), LOCATE('xbar', 'foobar'), LOCATE('bar', 'foobarbar', 5);
+```
+```text
++----------------------------+--------------------------+-------------------------------+
+| LOCATE('bar', 'foobarbar') | LOCATE('xbar', 'foobar') | LOCATE('bar', 'foobarbar', 5) |
++----------------------------+--------------------------+-------------------------------+
+| 4 | 0 | 7 |
++----------------------------+--------------------------+-------------------------------+
+```
+
+2. Поиск первого символа
+```sql
+SELECT LOCATE('f', 'foobar'), LOCATE('r', 'foobar');
+```
+```text
++-----------------------+-----------------------+
+| LOCATE('f', 'foobar') | LOCATE('r', 'foobar') |
++-----------------------+-----------------------+
+| 1 | 6 |
++-----------------------+-----------------------+
+```
+
+3. Совпадение не найдено
+```sql
+SELECT LOCATE('xyz', 'foobar'), LOCATE('FOO', 'foobar');
+```
+```text
++-------------------------+-------------------------+
+| LOCATE('xyz', 'foobar') | LOCATE('FOO', 'foobar') |
++-------------------------+-------------------------+
+| 0 | 0 |
++-------------------------+-------------------------+
+```
+
+4. Обработка NULL
+```sql
+SELECT LOCATE(NULL, 'foobar'), LOCATE('foo', NULL), LOCATE(NULL, NULL);
+```
+```text
++------------------------+---------------------+--------------------+
+| LOCATE(NULL, 'foobar') | LOCATE('foo', NULL) | LOCATE(NULL, NULL) |
++------------------------+---------------------+--------------------+
+| NULL | NULL | NULL |
++------------------------+---------------------+--------------------+
+```
+
+5. Обработка пустых строк
+```sql
+SELECT LOCATE('', 'foobar'), LOCATE('foo', ''), LOCATE('', '');
+```
+```text
++----------------------+-------------------+----------------+
+| LOCATE('', 'foobar') | LOCATE('foo', '') | LOCATE('', '') |
++----------------------+-------------------+----------------+
+| 1 | 0 | 1 |
++----------------------+-------------------+----------------+
+```
+
+6. Указание начальной позиции
+```sql
+SELECT LOCATE('o', 'foobar', 1), LOCATE('o', 'foobar', 2), LOCATE('o', 'foobar', 4);
+```
+```text
++--------------------------+--------------------------+--------------------------+
+| LOCATE('o', 'foobar', 1) | LOCATE('o', 'foobar', 2) | LOCATE('o', 'foobar', 4) |
++--------------------------+--------------------------+--------------------------+
+| 2 | 2 | 0 |
++--------------------------+--------------------------+--------------------------+
+```
+
+7. Граничные значения аргумента позиции
+```sql
+SELECT LOCATE('foo', 'foobar', 0), LOCATE('foo', 'foobar', -1), LOCATE('foo', 'foobar', 10);
+```
+```text
++----------------------------+-----------------------------+-----------------------------+
+| LOCATE('foo', 'foobar', 0) | LOCATE('foo', 'foobar', -1) | LOCATE('foo', 'foobar', 10) |
++----------------------------+-----------------------------+-----------------------------+
+| 0 | 0 | 0 |
++----------------------------+-----------------------------+-----------------------------+
+```
+
+8. Поиск подстроки в UTF-8
+```sql
+SELECT LOCATE('ṛì', 'ṭṛì ḍḍumai'), LOCATE('ḍḍu', 'ṭṛì ḍḍumai');
+```
+```text
++----------------------------------------+------------------------------------------+
+| LOCATE('ṛì', 'ṭṛì ḍḍumai') | LOCATE('ḍḍu', 'ṭṛì ḍḍumai') |
++----------------------------------------+------------------------------------------+
+| 2 | 5 |
++----------------------------------------+------------------------------------------+
+```
+
+9. Учёт регистра
+```sql
+SELECT LOCATE('BAR', 'foobar'), LOCATE('Bar', 'foobar'), LOCATE('bar', 'fooBAR');
+```
+```text
++-------------------------+-------------------------+-------------------------+
+| LOCATE('BAR', 'foobar') | LOCATE('Bar', 'foobar') | LOCATE('bar', 'fooBAR') |
++-------------------------+-------------------------+-------------------------+
+| 0 | 0 | 0 |
++-------------------------+-------------------------+-------------------------+
+```
+
+10. Пустая подстрока с аргументом позиции
+```sql
+SELECT LOCATE('', 'foobar', 3), LOCATE('', 'foobar', 7), LOCATE('', '', 1);
+```
+```text
++-------------------------+-------------------------+-------------------+
+| LOCATE('', 'foobar', 3) | LOCATE('', 'foobar', 7) | LOCATE('', '', 1) |
++-------------------------+-------------------------+-------------------+
+| 3 | 0 | 1 |
++-------------------------+-------------------------+-------------------+
+```
diff --git a/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/string-functions/lpad.md b/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/string-functions/lpad.md
new file mode 100644
index 000000000000..381bd14c5a88
--- /dev/null
+++ b/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/string-functions/lpad.md
@@ -0,0 +1,151 @@
+---
+{
+ "title": "LPAD",
+ "language": "ru",
+ "description": "Функция LPAD (Left Padding) дополняет строку слева указанными символами до заданной длины."
+}
+---
+
+## Описание {#description}
+
+Функция LPAD (Left Padding) дополняет строку слева указанными символами до заданной длины. Если заданная длина меньше длины исходной строки, строка усекается.
+
+## Синтаксис {#syntax}
+
+```sql
+LPAD(<str>, <len>, <pad>)
+```
+
+## Параметры {#parameters}
+
+| Параметр | Описание |
+|---------|------------------------------|
+| `<str>` | Исходная строка, которую нужно дополнить. Тип: VARCHAR |
+| `<len>` | Целевая длина строки в символах (не в байтах). Тип: INT |
+| `<pad>` | Строка, используемая для дополнения. Тип: VARCHAR |
+
+## Возвращаемое значение {#return-value}
+
+Возвращает значение типа VARCHAR, представляющее дополненную или усечённую строку.
+
+Правила дополнения:
+- Если len > длина исходной строки: строка pad многократно добавляется слева, пока общая длина не достигнет len
+- Если len = длина исходной строки: возвращается исходная строка
+- Если len < длина исходной строки: строка усекается, возвращаются только первые len символов
+- Длина рассчитывается в символах, поддерживаются многобайтовые символы UTF-8
+
+Особые случаи:
+- Если любой из параметров равен NULL, возвращается NULL
+- Если pad является пустой строкой и len > длина str, возвращается пустая строка
+- Если len равен 0, возвращается пустая строка
+- Если len отрицателен, возвращается NULL
+
+## Примеры {#examples}
+
+1. Простое дополнение слева
+```sql
+SELECT LPAD('hi', 5, 'xy'), LPAD('hello', 8, '*');
+```
+```text
++---------------------+-----------------------+
+| LPAD('hi', 5, 'xy') | LPAD('hello', 8, '*') |
++---------------------+-----------------------+
+| xyxhi | ***hello |
++---------------------+-----------------------+
+```
+
+2. Усечение строки
+```sql
+SELECT LPAD('hi', 1, 'xy'), LPAD('hello world', 5, 'x');
+```
+```text
++---------------------+------------------------------+
+| LPAD('hi', 1, 'xy') | LPAD('hello world', 5, 'x') |
++---------------------+------------------------------+
+| h | hello |
++---------------------+------------------------------+
+```
+
+3. Обработка значений NULL
+```sql
+SELECT LPAD(NULL, 5, 'x'), LPAD('hi', NULL, 'x'), LPAD('hi', 5, NULL);
+```
+```text
++---------------------+------------------------+----------------------+
+| LPAD(NULL, 5, 'x') | LPAD('hi', NULL, 'x') | LPAD('hi', 5, NULL) |
++---------------------+------------------------+----------------------+
+| NULL | NULL | NULL |
++---------------------+------------------------+----------------------+
+```
+
+4. Пустая строка и нулевая длина
+```sql
+SELECT LPAD('', 0, ''), LPAD('hi', 0, 'x'), LPAD('', 5, '*');
+```
+```text
++-----------------+--------------------+------------------+
+| LPAD('', 0, '') | LPAD('hi', 0, 'x') | LPAD('', 5, '*') |
++-----------------+--------------------+------------------+
+| | | ***** |
++-----------------+--------------------+------------------+
+```
+
+5. Пустая строка дополнения
+```sql
+SELECT LPAD('hello', 10, ''), LPAD('hi', 2, '');
+```
+```text
++-----------------------+-------------------+
+| LPAD('hello', 10, '') | LPAD('hi', 2, '') |
++-----------------------+-------------------+
+| | hi |
++-----------------------+-------------------+
+```
+
+6. Более длинная строка дополнения (повторяется до достижения длины len)
+```sql
+SELECT LPAD('123', 10, 'abc'), LPAD('X', 7, 'HELLO');
+```
+```text
++------------------------+-----------------------+
+| LPAD('123', 10, 'abc') | LPAD('X', 7, 'HELLO') |
++------------------------+-----------------------+
+| abcabca123 | HELLOHX |
++------------------------+-----------------------+
+```
+
+7. Дополнение многобайтовыми символами UTF-8
+```sql
+SELECT LPAD('hello', 10, 'ṭṛì'), LPAD('ḍḍumai', 3, 'x');
+```
+```text
++-------------------------------+----------------------------+
+| LPAD('hello', 10, 'ṭṛì') | LPAD('ḍḍumai', 3, 'x') |
++-------------------------------+----------------------------+
+| ṭṛìṭṛhello | ḍḍu |
++-------------------------------+----------------------------+
+```
+
+8. Дополнение числовых строк нулями
+```sql
+SELECT LPAD('42', 6, '0'), LPAD('1234', 8, '0');
+```
+```text
++--------------------+----------------------+
+| LPAD('42', 6, '0') | LPAD('1234', 8, '0') |
++--------------------+----------------------+
+| 000042 | 00001234 |
++--------------------+----------------------+
+```
+
+9. Отрицательная длина
+```sql
+SELECT LPAD('hello', -1, 'x'), LPAD('test', -5, '*');
+```
+```text
++------------------------+-----------------------+
+| LPAD('hello', -1, 'x') | LPAD('test', -5, '*') |
++------------------------+-----------------------+
+| NULL | NULL |
++------------------------+-----------------------+
+```
diff --git a/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/string-functions/ltrim-in.md b/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/string-functions/ltrim-in.md
new file mode 100644
index 000000000000..e1553beb51c3
--- /dev/null
+++ b/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/string-functions/ltrim-in.md
@@ -0,0 +1,71 @@
+---
+{
+ "title": "LTRIM_IN",
+ "language": "ru",
+ "description": "Функция LTRIMIN удаляет указанные символы из начала строки. Если набор символов не указан,"
+}
+---
+
+## Описание {#description}
+
+Функция LTRIM_IN удаляет указанные символы из начала строки. Если набор символов не указан, по умолчанию удаляются начальные пробелы. Если набор символов указан, из начала строки удаляются все символы, входящие в этот набор (независимо от их порядка в наборе).
+Главная особенность LTRIM_IN заключается в том, что она удаляет любые сочетания символов из указанного набора, тогда как функция LTRIM удаляет символы на основе точного совпадения строк.
+
+## Синтаксис {#syntax}
+
+```sql
+LTRIM_IN(<str> [, <rhs>])
+```
+
+## Параметры {#parameters}
+| Параметр | Описание |
+| --------- | ---------------------------------------------------------------------- |
+| `<str>` | Строка для обработки. Тип: VARCHAR |
+| `<rhs>` | Необязательный параметр, набор символов для удаления. Тип: VARCHAR |
+
+## Возвращаемое значение {#return-value}
+
+Возвращает обработанную строку типа VARCHAR.
+
+Особые случаи:
+- Если str имеет значение NULL, возвращает NULL
+- Если rhs не указан, удаляет все начальные пробелы
+- Если rhs указан, удаляет из начала строки все символы, входящие в rhs, до первого символа, не входящего в rhs
+
+## Примеры {#examples}
+
+1. Удаление начальных пробелов
+```sql
+SELECT ltrim_in(' ab d') str;
+```
+```text
++------+
+| str |
++------+
+| ab d |
++------+
+```
+
+2. Удаление символов из указанного набора
+```sql
+SELECT ltrim_in('ababccaab', 'ab') str;
+```
+```text
++-------+
+| str |
++-------+
+| ccaab |
++-------+
+```
+
+3. Сравнение с функцией LTRIM
+```sql
+SELECT ltrim_in('abcd', 'ae'),ltrim('abcd', 'abe');
+```
+```text
++------------------------+----------------------+
+| ltrim_in('abcd', 'ae') | ltrim('abcd', 'abe') |
++------------------------+----------------------+
+| bcd | abcd |
++------------------------+----------------------+
+```
diff --git a/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/string-functions/ltrim.md b/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/string-functions/ltrim.md
new file mode 100644
index 000000000000..1cbf9f783bfd
--- /dev/null
+++ b/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/string-functions/ltrim.md
@@ -0,0 +1,78 @@
+---
+{
+ "title": "LTRIM",
+ "language": "ru",
+ "description": "Функция LTRIM удаляет подряд идущие пробелы или символы из заданного набора с левой стороны (из начала) строки."
+}
+---
+
+## Описание {#description}
+
+Функция LTRIM удаляет подряд идущие пробелы или символы из заданного набора с левой стороны (из начала) строки. Функция просматривает строку слева и удаляет все подряд идущие целевые символы, пока не встретит символ, не входящий в целевой набор.
+
+## Синтаксис {#syntax}
+
+```sql
+LTRIM(<str> [, <trim_chars>])
+```
+
+## Параметры {#parameters}
+
+| Параметр | Описание |
+|----------------|---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+| `<str>` | Исходная строка, из начала которой удаляются символы. Тип: VARCHAR |
+| `<trim_chars>` | Необязательный параметр, задающий набор удаляемых символов. Если не указан, по умолчанию удаляются пробельные символы. Тип: VARCHAR |
+
+## Возвращаемое значение {#return-value}
+
+Возвращает значение типа VARCHAR — строку после удаления заданных символов с левой стороны.
+
+Правила удаления:
+- Символы удаляются только с левой стороны (из начала) строки
+- Удаляются все подряд идущие символы, входящие в trim_chars
+- Удаление прекращается при обнаружении символа, не входящего в trim_chars
+- Если trim_chars не указан, по умолчанию удаляются пробельные символы (включая пробелы, символы табуляции, перевода строки и т. д.)
+
+Особые случаи:
+- Если любой из параметров равен NULL, возвращается NULL
+- Если str — пустая строка, возвращается пустая строка
+- Если trim_chars — пустая строка, возвращается исходная строка
+- Если вся строка состоит из символов, входящих в trim_chars, возвращается пустая строка
+
+## Примеры {#examples}
+
+1. Удаление пробелов в начале строки
+```sql
+SELECT LTRIM(' ab d');
+```
+```text
++-------------------+
+| LTRIM(' ab d') |
++-------------------+
+| ab d |
++-------------------+
+```
+
+2. Удаление заданных символов
+```sql
+SELECT LTRIM('ababccaab', 'ab');
+```
+```text
++----------------------------+
+| LTRIM('ababccaab', 'ab') |
++----------------------------+
+| ccaab |
++----------------------------+
+```
+
+3. Обработка значений NULL
+```sql
+SELECT LTRIM(NULL), LTRIM('test', NULL);
+```
+```text
++-------------+---------------------+
+| LTRIM(NULL) | LTRIM('test', NULL) |
++-------------+---------------------+
+| NULL | NULL |
++-------------+---------------------+
+```
diff --git a/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/string-functions/make-set.md b/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/string-functions/make-set.md
new file mode 100644
index 000000000000..631c9ede9a6b
--- /dev/null
+++ b/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/string-functions/make-set.md
@@ -0,0 +1,115 @@
+---
+{
+ "title": "MAKE_SET",
+ "language": "ru",
+ "description": "Функция MAKESET выбирает и объединяет строки из нескольких строковых параметров на основе битовой маски (bit)."
+}
+---
+
+## Описание {#description}
+
+Функция MAKE_SET выбирает и объединяет строки из нескольких строковых параметров на основе битовой маски (bit). Возвращает набор строк, разделённых запятыми, в который входят все строки, для которых соответствующий бит равен 1.
+
+Поведение соответствует функции [MAKE_SET](https://dev.mysql.com/doc/refman/8.4/en/string-functions.html#function-make-set) в MySQL.
+
+## Синтаксис {#syntax}
+
+```sql
+MAKE_SET(<bit>, <str1>[, <str2>, ...])
+```
+
+## Параметры {#parameters}
+
+| Параметр | Описание |
+| -------- | ----------------------------------------- |
+| `<bit>` | Значение битовой маски: двоичные биты определяют, какие строки выбрать. Тип: BIGINT |
+| `<str1>`, `<str2>`, ... | Строковые параметры для объединения (переменное число аргументов). Тип: VARCHAR |
+
+## Возвращаемое значение {#return-value}
+
+Возвращает значение типа VARCHAR: набор строк, разделённых запятыми.
+
+Особые случаи:
+- Если `<bit>` равен NULL, возвращается NULL
+- Если строка, соответствующая биту со значением 1, равна NULL, эта строка пропускается
+- Если соответствующий бит выходит за пределы списка параметров, он игнорируется
+- Биты нумеруются справа налево; бит 0 соответствует первому строковому параметру
+- Если `<bit>` равен 0, возвращается пустая строка
+
+## Примеры {#examples}
+
+1. Базовое использование: bit = 3 (двоичное представление 011, выбираются биты 0 и 1)
+```sql
+SELECT make_set(3, 'dog', 'cat', 'bird');
+```
+```text
++-----------------------------------+
+| make_set(3, 'dog', 'cat', 'bird') |
++-----------------------------------+
+| dog,cat |
++-----------------------------------+
+```
+
+2. Пропуск значений NULL: bit = 5 (двоичное представление 101, выбираются биты 0 и 2)
+```sql
+SELECT make_set(5, NULL, 'warm', 'hot');
+```
+```text
++---------------------------------+
+| make_set(5, NULL, 'warm', 'hot') |
++---------------------------------+
+| hot |
++---------------------------------+
+```
+
+3. bit равен 0: строки не выбираются
+```sql
+SELECT make_set(0, 'hello', 'world');
+```
+```text
++--------------------------------+
+| make_set(0, 'hello', 'world') |
++--------------------------------+
+| |
++--------------------------------+
+```
+
+4. Обработка значения NULL
+```sql
+SELECT make_set(NULL, 'a', 'b', 'c');
+```
+```text
++-------------------------------+
+| make_set(NULL, 'a', 'b', 'c') |
++-------------------------------+
+| NULL |
++-------------------------------+
+```
+
+5. Бит выходит за пределы списка параметров: bit = 15 (двоичное представление 1111, выбираются 4 бита, но переданы только 2 параметра)
+```sql
+SELECT make_set(15, 'first', 'second');
+```
+```text
++-------------------------------------+
+| make_set(15, 'first', 'second') |
++-------------------------------------+
+| first,second |
++-------------------------------------+
+```
+
+6. Поддержка специальных символов UTF-8
+```sql
+SELECT make_set(7, 'ṭṛì', 'ḍḍumai', 'test');
+```
+```text
++------------------------------------------+
+| make_set(7, 'ṭṛì', 'ḍḍumai', 'test') |
++------------------------------------------+
+| ṭṛì,ḍḍumai,test |
++------------------------------------------+
+```
+
+### Ключевые слова {#keywords}
+
+ MAKE_SET
diff --git a/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/string-functions/mask-first-n.md b/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/string-functions/mask-first-n.md
new file mode 100644
index 000000000000..68322d9394c3
--- /dev/null
+++ b/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/string-functions/mask-first-n.md
@@ -0,0 +1,166 @@
+---
+{
+ "title": "MASK_FIRST_N",
+ "language": "ru",
+ "description": "Функция MASKFIRSTN используется для маскирования первых N байт строки. Она заменяет прописные буквы на X, строчные буквы на x,"
+}
+---
+
+## Описание {#description}
+
+Функция MASK_FIRST_N используется для маскирования первых N байт строки. В первых N байтах она заменяет прописные буквы на `X`, строчные буквы на `x`, а цифры на `n`.
+
+## Синтаксис {#syntax}
+
+```sql
+MASK_FIRST_N(<str>[, <n>])
+```
+
+## Параметры {#parameters}
+
+| Параметр | Описание |
+| ------- | ----------------------------------------- |
+| `<str>` | Строка для маскирования. Тип: VARCHAR |
+| `<n>` | Количество первых N байт для маскирования (необязательный параметр; по умолчанию маскируется вся строка). Тип: INT |
+
+## Возвращаемое значение {#return-value}
+
+Возвращает строку типа VARCHAR с замаскированными первыми N байтами.
+
+Особые случаи:
+- Если любой из параметров равен NULL, возвращает NULL
+- Символы, не являющиеся буквами или цифрами, остаются без изменений
+- Если `<n>` превышает длину строки, маскирует всю строку
+
+## Примеры {#examples}
+
+1. Базовое использование: маскирование первых 4 байт
+```sql
+SELECT mask_first_n('1234-5678', 4);
+```
+```text
++------------------------------+
+| mask_first_n('1234-5678', 4) |
++------------------------------+
+| nnnn-5678 |
++------------------------------+
+```
+
+2. Без указания n (маскируется вся строка)
+```sql
+SELECT mask_first_n('abc123');
+```
+```text
++-----------------------+
+| mask_first_n('abc123') |
++-----------------------+
+| xxxnnn |
++-----------------------+
+```
+
+3. n превышает длину строки
+```sql
+SELECT mask_first_n('Hello', 100);
+```
+```text
++----------------------------+
+| mask_first_n('Hello', 100) |
++----------------------------+
+| Xxxxx |
++----------------------------+
+```
+
+4. Обработка значения NULL
+```sql
+SELECT mask_first_n(NULL, 5);
+```
+```text
++-----------------------+
+| mask_first_n(NULL, 5) |
++-----------------------+
+| NULL |
++-----------------------+
+```
+
+5. n равен 0 (символы не маскируются)
+```sql
+SELECT mask_first_n('Hello123', 0);
+```
+```text
++-----------------------------+
+| mask_first_n('Hello123', 0) |
++-----------------------------+
+| Hello123 |
++-----------------------------+
+```
+
+6. n превышает длину строки (маскируется вся строка)
+```sql
+SELECT mask_first_n('Test', 100);
+```
+```text
++---------------------------+
+| mask_first_n('Test', 100) |
++---------------------------+
+| Xxxx |
++---------------------------+
+```
+
+7. Маскирование начальной части адреса электронной почты
+```sql
+SELECT mask_first_n('user@example.com', 6);
+```
+```text
++-------------------------------------+
+| mask_first_n('user@example.com', 6) |
++-------------------------------------+
+| xxxx@xxample.com |
++-------------------------------------+
+```
+
+8. Маскирование первых 3 цифр номера телефона
+```sql
+SELECT mask_first_n('13812345678', 3);
+```
+```text
++--------------------------------+
+| mask_first_n('13812345678', 3) |
++--------------------------------+
+| nnn12345678 |
++--------------------------------+
+```
+
+9. Сочетание букв, цифр и специальных символов
+```sql
+SELECT mask_first_n('Abc-123-XYZ', 7);
+```
+```text
++---------------------------------+
+| mask_first_n('Abc-123-XYZ', 7) |
++---------------------------------+
+| Xxx-nnn-XYZ |
++---------------------------------+
+```
+
+10. Обработка символов UTF-8 (побайтовое маскирование)
+```sql
+SELECT mask_first_n('ṭṛWorld123', 7);
+```
+```text
++-----------------------------------+
+| mask_first_n('ṭṛWorld123', 7) |
++-----------------------------------+
+| ṭṛXorld123 |
++-----------------------------------+
+```
+
+```sql
+SELECT mask_first_n('eeeéèêëìí1234');
+```
+```text
++-------------------------------------+
+| mask_first_n('eeeéèêëìí1234') |
++-------------------------------------+
+| xxxéèêëìínnnn |
++-------------------------------------+
+```
diff --git a/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/string-functions/mask-last-n.md b/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/string-functions/mask-last-n.md
new file mode 100644
index 000000000000..2c517ac9010b
--- /dev/null
+++ b/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/string-functions/mask-last-n.md
@@ -0,0 +1,166 @@
+---
+{
+ "title": "MASK_LAST_N",
+ "language": "ru",
+ "description": "Функция MASK_LAST_N используется для маскирования последних N байтов строки. Она заменяет прописные буквы на X, строчные буквы на x,"
+}
+---
+
+## Описание {#description}
+
+Функция MASK_LAST_N используется для маскирования последних N байтов строки. В последних N байтах она заменяет прописные буквы на `X`, строчные буквы на `x`, а цифры на `n`.
+
+## Синтаксис {#syntax}
+
+```sql
+MASK_LAST_N(<str>[, <n>])
+```
+
+## Параметры {#parameters}
+
+| Параметр | Описание |
+| ------- | ----------------------------------------- |
+| `<str>` | Строка для маскирования. Тип: VARCHAR |
+| `<n>` | Количество последних N байтов для маскирования (необязательный параметр; по умолчанию маскируется вся строка). Тип: INT |
+
+## Возвращаемое значение {#return-value}
+
+Возвращает значение типа VARCHAR: строку с замаскированными последними N байтами.
+
+Особые случаи:
+- Если любой из параметров равен NULL, возвращается NULL
+- Символы, не являющиеся буквами или цифрами, остаются без изменений
+- Если `<n>` превышает длину строки, маскируется вся строка
+
+## Примеры {#examples}
+
+1. Базовое использование: маскирование последних 4 байтов
+```sql
+SELECT mask_last_n('1234-5678', 4);
+```
+```text
++-----------------------------+
+| mask_last_n('1234-5678', 4) |
++-----------------------------+
+| 1234-nnnn |
++-----------------------------+
+```
+
+2. Без указания n (маскируется вся строка)
+```sql
+SELECT mask_last_n('abc123');
+```
+```text
++----------------------+
+| mask_last_n('abc123') |
++----------------------+
+| xxxnnn |
++----------------------+
+```
+
+3. n превышает длину строки
+```sql
+SELECT mask_last_n('Hello', 100);
+```
+```text
++---------------------------+
+| mask_last_n('Hello', 100) |
++---------------------------+
+| Xxxxx |
++---------------------------+
+```
+
+4. Обработка значения NULL
+```sql
+SELECT mask_last_n(NULL, 5);
+```
+```text
++----------------------+
+| mask_last_n(NULL, 5) |
++----------------------+
+| NULL |
++----------------------+
+```
+
+5. n равно 0 (ни один символ не маскируется)
+```sql
+SELECT mask_last_n('Hello123', 0);
+```
+```text
++----------------------------+
+| mask_last_n('Hello123', 0) |
++----------------------------+
+| Hello123 |
++----------------------------+
+```
+
+6. n превышает длину строки (маскируется вся строка)
+```sql
+SELECT mask_last_n('Test', 100);
+```
+```text
++--------------------------+
+| mask_last_n('Test', 100) |
++--------------------------+
+| Xxxx |
++--------------------------+
+```
+
+7. Маскирование доменной части адреса электронной почты
+```sql
+SELECT mask_last_n('user@example.com', 11);
+```
+```text
++-------------------------------------+
+| mask_last_n('user@example.com', 11) |
++-------------------------------------+
+| user@xxxxxxx.xxx |
++-------------------------------------+
+```
+
+8. Маскирование последних 4 цифр номера телефона
+```sql
+SELECT mask_last_n('13812345678', 4);
+```
+```text
++-------------------------------+
+| mask_last_n('13812345678', 4) |
++-------------------------------+
+| 1381234nnnn |
++-------------------------------+
+```
+
+9. Сочетание букв, цифр и специальных символов
+```sql
+SELECT mask_last_n('ABC-123-xyz', 7);
+```
+```text
++--------------------------------+
+| mask_last_n('ABC-123-xyz', 7) |
++--------------------------------+
+| ABC-nnn-xxx |
++--------------------------------+
+```
+
+10. Обработка символов UTF-8 (маскирование по байтам)
+```sql
+SELECT mask_last_n('Hello你好123', 9);
+```
+```text
++--------------------------------+
+| mask_last_n('Hello你好123', 9) |
++--------------------------------+
+| Hello你好nnn |
++--------------------------------+
+```
+
+```sql
+SELECT mask_last_n('eeeéèêëìí1234');
+```
+```text
++------------------------------------+
+| mask_last_n('eeeéèêëìí1234') |
++------------------------------------+
+| xxxéèêëìínnnn |
++------------------------------------+
+```
diff --git a/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/string-functions/mask.md b/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/string-functions/mask.md
new file mode 100644
index 000000000000..cb5404602a73
--- /dev/null
+++ b/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/string-functions/mask.md
@@ -0,0 +1,168 @@
+---
+{
+ "title": "MASK",
+ "language": "ru",
+ "description": "Функция MASK используется для маскирования данных с целью защиты конфиденциальной информации. По умолчанию прописные буквы заменяются на X,"
+}
+---
+
+## Описание {#description}
+
+Функция MASK используется для маскирования данных с целью защиты конфиденциальной информации. По умолчанию она заменяет прописные буквы на `X`, строчные буквы на `x`, а цифры на `n`.
+
+## Синтаксис {#syntax}
+
+```sql
+MASK(<str>[, <upper>[, <lower>[, <number>]]])
+```
+
+## Параметры {#parameters}
+
+| Параметр | Описание |
+| ---------- | ----------------------------------------- |
+| `<str>` | Строка для маскирования. Тип: VARCHAR |
+| `<upper>` | Символ для замены прописных букв, по умолчанию `X` (необязательный параметр). Тип: VARCHAR |
+| `<lower>` | Символ для замены строчных букв, по умолчанию `x` (необязательный параметр). Тип: VARCHAR |
+| `<number>` | Символ для замены цифр, по умолчанию `n` (необязательный параметр). Тип: VARCHAR |
+
+## Возвращаемое значение {#return-value}
+
+Возвращает строку типа VARCHAR, в которой буквы и цифры заменены.
+
+Особые случаи:
+- Если какой-либо параметр равен NULL, возвращает NULL
+- Символы, не являющиеся буквами или цифрами, остаются без изменений
+- Если параметры, задающие символы замены, содержат несколько символов, используется только первый символ
+
+## Примеры {#examples}
+
+1. Базовое использование: правила замены по умолчанию
+```sql
+SELECT mask('abc123XYZ');
+```
+```text
++-------------------+
+| mask('abc123XYZ') |
++-------------------+
+| xxxnnnXXX |
++-------------------+
+```
+
+2. Пользовательские символы замены
+```sql
+SELECT mask('abc123XYZ', '*', '#', '$');
+```
+```text
++----------------------------------+
+| mask('abc123XYZ', '*', '#', '$') |
++----------------------------------+
+| ###$$$*** |
++----------------------------------+
+```
+
+3. Специальные символы остаются без изменений
+```sql
+SELECT mask('Hello-123!');
+```
+```text
++--------------------+
+| mask('Hello-123!') |
++--------------------+
+| Xxxxx-nnn! |
++--------------------+
+```
+
+4. Обработка значения NULL
+```sql
+SELECT mask(NULL);
+```
+```text
++------------+
+| mask(NULL) |
++------------+
+| NULL |
++------------+
+```
+
+5. Строка, состоящая только из цифр
+```sql
+SELECT mask('1234567890');
+```
+```text
++--------------------+
+| mask('1234567890') |
++--------------------+
+| nnnnnnnnnn |
++--------------------+
+```
+
+6. Строка, состоящая только из букв
+```sql
+SELECT mask('AbCdEfGh');
+```
+```text
++------------------+
+| mask('AbCdEfGh') |
++------------------+
+| XxXxXxXx |
++------------------+
+```
+
+7. Обработка пустой строки
+```sql
+SELECT mask('');
+```
+```text
++----------+
+| mask('') |
++----------+
+| |
++----------+
+```
+
+8. Замена одним символом (при указании нескольких используется первый)
+```sql
+SELECT mask('Test123', 'ABC', 'xyz', '999');
+```
+```text
++--------------------------------------+
+| mask('Test123', 'ABC', 'xyz', '999') |
++--------------------------------------+
+| Axxx999 |
++--------------------------------------+
+```
+
+9. Маскирование номера кредитной карты
+```sql
+SELECT mask('1234-5678-9012-3456');
+```
+```text
++-----------------------------+
+| mask('1234-5678-9012-3456') |
++-----------------------------+
+| nnnn-nnnn-nnnn-nnnn |
++-----------------------------+
+```
+
+10. Маскирование адреса электронной почты
+```sql
+SELECT mask('user@example.com');
+```
+```text
++--------------------------+
+| mask('user@example.com') |
++--------------------------+
+| xxxx@xxxxxxx.xxx |
++--------------------------+
+```
+
+```sql
+SELECT mask('eeeéèêëìí1234');
+```
+```text
++-----------------------------+
+| mask('eeeéèêëìí1234') |
++-----------------------------+
+| xxxéèêëìínnnn |
++-----------------------------+
+```
diff --git a/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/string-functions/multi-match-any.md b/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/string-functions/multi-match-any.md
new file mode 100644
index 000000000000..8a4817b55c5f
--- /dev/null
+++ b/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/string-functions/multi-match-any.md
@@ -0,0 +1,74 @@
+---
+{
+ "title": "MULTI_MATCH_ANY",
+ "language": "ru",
+ "description": "Проверяет, соответствует ли строка хотя бы одному регулярному выражению из массива."
+}
+---
+
+<a id="multi_match_any"></a>
+
+## Описание {#description}
+
+Проверяет, соответствует ли `<haystack>` хотя бы одному регулярному выражению из `<patterns>`. По умолчанию сопоставление выполняется с учётом регистра. Возвращает `0` вместо `NULL`, если любой из аргументов равен `NULL`.
+
+## Синтаксис {#syntax}
+
+```sql
+MULTI_MATCH_ANY(<haystack>, <patterns>)
+```
+
+## Параметры {#parameters}
+
+| Параметр | Описание |
+| --- | --- |
+| `<haystack>` | Входная строка типа `STRING`. |
+| `<patterns>` | Регулярные выражения типа `ARRAY<STRING>`. Элементы массива шаблонов должны быть строками, отличными от NULL. |
+
+## Возвращаемое значение {#return-value}
+
+Возвращает `TINYINT`: `1`, если найдено соответствие хотя бы одному выражению, иначе `0`. Возвращает `0` для пустого массива шаблонов, а также если любой из аргументов равен `NULL`.
+
+Эта функция использует движок регулярных выражений Hyperscan/VectorScan. Некорректные или неподдерживаемые шаблоны приводят к ошибке. Константную входную строку нельзя использовать вместе с неконстантным столбцом массивов шаблонов; такое сочетание приводит к ошибке аргументов.
+
+## Пример {#example}
+
+```sql
+SELECT multi_match_any('Hello, World!', ['hello', '!', 'world']) AS matched;
+```
+
+```text
+1
+```
+
+```sql
+SELECT multi_match_any('abc', ['A', 'bcd']) AS matched;
+```
+
+```text
+0
+```
+
+Регулярные выражения выполняют сопоставление с шаблоном, а не поиск буквальной подстроки:
+
+```sql
+SELECT multi_match_any('abc123', ['[0-9]+', '^xyz']) AS matched;
+```
+
+```text
+1
+```
+
+```sql
+SELECT multi_match_any('abc', CAST([] AS ARRAY<STRING>)) AS empty_patterns,
+ multi_match_any(CAST(NULL AS STRING), ['a']) AS null_text,
+ multi_match_any('abc', CAST(NULL AS ARRAY<STRING>)) AS null_patterns;
+```
+
+```text
+0 0 0
+```
+
+## Ключевые слова {#keywords}
+
+MULTI_MATCH, MATCH, ANY
diff --git a/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/string-functions/multi-search-all-positions.md b/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/string-functions/multi-search-all-positions.md
new file mode 100644
index 000000000000..61aeccd93aa6
--- /dev/null
+++ b/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/string-functions/multi-search-all-positions.md
@@ -0,0 +1,117 @@
+---
+{
+ "title": "MULTI_SEARCH_ALL_POSITIONS",
+ "language": "ru",
+ "description": "Функция MULTISEARCHALLPOSITIONS выполняет пакетный поиск нескольких подстрок в строке."
+}
+---
+
+## Описание {#description}
+
+Функция MULTI_SEARCH_ALL_POSITIONS выполняет пакетный поиск нескольких подстрок в строке. Возвращает массив с позицией первого вхождения каждой подстроки. Поиск выполняется с учётом регистра.
+
+## Синтаксис {#syntax}
+
+```sql
+MULTI_SEARCH_ALL_POSITIONS(<haystack>, <needles>)
+```
+
+## Параметры {#parameters}
+
+| Параметр | Описание |
+| ------------ | ----------------------------------------- |
+| `<haystack>` | Строка, в которой выполняется поиск. Тип: VARCHAR |
+| `<needles>` | Массив подстрок для поиска. Тип: ARRAY<VARCHAR> |
+
+## Возвращаемое значение {#return-value}
+
+Возвращает значение типа ARRAY<INT>, где i-й элемент массива представляет позицию первого вхождения i-й подстроки из `<needles>` в `<haystack>`.
+
+Особые случаи:
+- Отсчёт позиций начинается с 1
+- Если подстрока не найдена, для соответствующей позиции возвращается 0
+- Поиск выполняется с учётом регистра
+- Если `<haystack>` имеет значение NULL, возвращается массив нулей той же длины, что и `<needles>`
+- Если `<needles>` имеет значение NULL, возвращается пустой массив `[]`, в том числе когда оба параметра имеют значение NULL
+- Возвращается позиция в байтах, а не позиция n-го символа
+
+## Примеры {#examples}
+
+1. Базовое использование: поиск нескольких подстрок
+```sql
+SELECT multi_search_all_positions('Hello, World!', ['Hello', 'World']);
+```
+```text
++----------------------------------------------------------+
+| multi_search_all_positions('Hello, World!', ['Hello', 'World']) |
++----------------------------------------------------------+
+| [1, 8] |
++----------------------------------------------------------+
+```
+
+2. Поиск с учётом регистра: подстроки в нижнем регистре не найдены
+```sql
+SELECT multi_search_all_positions('Hello, World!', ['hello', '!', 'world']);
+```
+```text
++----------------------------------------------------------------------+
+| multi_search_all_positions('Hello, World!', ['hello', '!', 'world']) |
++----------------------------------------------------------------------+
+| [0, 13, 0] |
++----------------------------------------------------------------------+
+```
+
+3. Смешанный поиск: найдена часть подстрок
+```sql
+SELECT multi_search_all_positions('Hello, World!', ['Hello', '!', 'xyz']);
+```
+```text
++--------------------------------------------------------------------+
+| multi_search_all_positions('Hello, World!', ['Hello', '!', 'xyz']) |
++--------------------------------------------------------------------+
+| [1, 13, 0] |
++--------------------------------------------------------------------+
+```
+
+4. Пустой массив
+```sql
+SELECT multi_search_all_positions('Hello', []);
+```
+```text
++------------------------------------------+
+| multi_search_all_positions('Hello', []) |
++------------------------------------------+
+| [] |
++------------------------------------------+
+```
+
+5. Поддержка специальных символов UTF-8
+```sql
+SELECT multi_search_all_positions('ṭṛì ḍḍumai Hello', ['ṭṛì', 'Hello', 'test']);
+```
+```text
++----------------------------------------------------------------------------------------+
+| multi_search_all_positions('ṭṛì ḍḍumai Hello', ['ṭṛì', 'Hello', 'test']) |
++----------------------------------------------------------------------------------------+
+| [1, 21, 0] |
++----------------------------------------------------------------------------------------+
+```
+
+Входные значения NULL:
+
+```sql
+SELECT multi_search_all_positions(NULL, ['a', 'b']) AS null_haystack,
+ multi_search_all_positions('a', NULL) AS null_needles,
+ multi_search_all_positions(NULL, NULL) AS both_null;
+```
+```text
++---------------+--------------+-----------+
+| null_haystack | null_needles | both_null |
++---------------+--------------+-----------+
+| [0, 0] | [] | [] |
++---------------+--------------+-----------+
+```
+
+### Ключевые слова {#keywords}
+
+ MULTI_SEARCH,SEARCH,POSITIONS
diff --git a/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/string-functions/ngram-search.md b/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/string-functions/ngram-search.md
new file mode 100644
index 000000000000..73d2964335ec
--- /dev/null
+++ b/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/string-functions/ngram-search.md
@@ -0,0 +1,105 @@
+---
+{
+ "title": "NGRAM_SEARCH",
+ "language": "ru",
+ "description": "Функция NGRAM_SEARCH вычисляет сходство двух строк по N-gram. Значение сходства находится в диапазоне от 0 до 1: чем оно выше, тем больше похожи строки."
+}
+---
+
+## Описание {#description}
+
+Функция NGRAM_SEARCH вычисляет сходство двух строк по N-gram. Значение сходства находится в диапазоне от 0 до 1: чем оно выше, тем больше похожи строки.
+
+N-gram разбивает строку на множество последовательностей из N подряд идущих символов. Формула вычисления сходства: `2 * |intersection| / (|set1| + |set2|)`
+
+Поддерживаются только символы ASCII.
+
+## Синтаксис {#syntax}
+
+```sql
+NGRAM_SEARCH(<text>, <pattern>, <gram_num>)
+```
+
+## Параметры {#parameters}
+
+| Параметр | Описание |
+| ------------ | ----------------------------------------- |
+| `<text>` | Текстовая строка для сравнения. Тип: VARCHAR |
+| `<pattern>` | Строка-шаблон (должна быть константой). Тип: VARCHAR |
+| `<gram_num>` | Значение N для N-gram. Должно быть положительной целочисленной константой. Тип: INT. |
+
+## Возвращаемое значение {#return-value}
+
+Возвращает сходство двух строк по N-gram в виде значения типа DOUBLE (от 0 до 1).
+
+Особые случаи:
+- Возвращает NULL, если `<text>` или `<pattern>` равен NULL. `<gram_num>` должен быть положительной целочисленной константой и не может быть NULL
+- Если длина строки меньше `<gram_num>`, возвращается 0
+- `<pattern>` и `<gram_num>` должны быть константами. В ветке Doris 4.1 начиная с версии 4.1.5 недопустимые значения `<gram_num>`, такие как 0, отрицательное число или нецелочисленная константа, явно вызывают ошибку
+- Сходство, равное 1, не обязательно означает, что строки полностью идентичны
+
+<a id="examples"></a>
+
+## Пример {#example}
+
+1. Базовое использование: вычисление сходства
+```sql
+SELECT ngram_search('123456789', '12345', 3);
+```
+```text
++---------------------------------------+
+| ngram_search('123456789', '12345', 3) |
++---------------------------------------+
+| 0.6 |
++---------------------------------------+
+```
+
+2. Пример высокого сходства
+```sql
+SELECT ngram_search('abababab', 'babababa', 2);
+```
+```text
++-----------------------------------------+
+| ngram_search('abababab', 'babababa', 2) |
++-----------------------------------------+
+| 1 |
++-----------------------------------------+
+```
+
+3. Если строка слишком короткая, возвращается 0
+```sql
+SELECT ngram_search('ab', 'abc', 3);
+```
+```text
++----------------------------------+
+| ngram_search('ab', 'abc', 3) |
++----------------------------------+
+| 0 |
++----------------------------------+
+```
+
+4. Обработка значения NULL
+```sql
+SELECT ngram_search(NULL, 'test', 2);
+```
+```text
++--------------------------------+
+| ngram_search(NULL, 'test', 2) |
++--------------------------------+
+| NULL |
++--------------------------------+
+```
+
+Недопустимое значение gram_num вызывает ошибку:
+
+```sql
+SELECT NGRAM_SEARCH('abc', 'abc', 0);
+```
+
+```text
+ngram_search(text,pattern,gram_num): gram_num must be a positive constant.
+```
+
+### Ключевые слова {#keywords}
+
+ NGRAM_SEARCH,NGRAM,SEARCH
diff --git a/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/string-functions/overlay.md b/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/string-functions/overlay.md
new file mode 100644
index 000000000000..61513c307ab4
--- /dev/null
+++ b/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/string-functions/overlay.md
@@ -0,0 +1,102 @@
+---
+{
+ "title": "OVERLAY",
+ "language": "ru",
+ "description": "Функция OVERLAY используется для замены подстроки заданной длины в указанной позиции строки. Начиная с указанной позиции,"
+}
+---
+
+## Описание {#description}
+
+Функция OVERLAY используется для замены подстроки заданной длины в указанной позиции строки. Начиная с указанной позиции, она заменяет заданное количество символов новой строкой. Эта функция корректно работает с многобайтовыми символами.
+
+Поведение этой функции соответствует поведению [функции INSERT](https://dev.mysql.com/doc/refman/8.4/en/string-functions.html#function_insert) в MySQL.
+
+## Псевдоним {#alias}
+
+- INSERT
+
+## Синтаксис {#syntax}
+
+```sql
+OVERLAY(<str>, <pos>, <len>, <newstr>)
+```
+
+## Параметры {#parameters}
+
+| Параметр | Описание |
+| ---------- | ----------------------------------------- |
+| `<str>` | Исходная строка, которую нужно изменить. Тип: VARCHAR |
+| `<pos>` | Начальная позиция замены (нумерация с 1). Тип: INT |
+| `<len>` | Количество символов для замены. Тип: INT |
+| `<newstr>` | Новая строка для замены. Тип: VARCHAR |
+
+## Возвращаемое значение {#return-value}
+
+Возвращает новую строку типа VARCHAR после замены.
+
+Особые случаи:
+- Если любой из параметров равен NULL, возвращает NULL
+- Если `<pos>` меньше 1 или превышает длину строки, замена не выполняется и возвращается исходная строка
+- Если `<len>` меньше 0 или превышает оставшуюся длину, замена выполняется от `<pos>` до конца строки
+
+## Примеры {#examples}
+
+1. Базовое использование: замена средней части строки
+```sql
+SELECT overlay('Quadratic', 3, 4, 'What');
+```
+```text
++------------------------------------+
+| overlay('Quadratic', 3, 4, 'What') |
++------------------------------------+
+| QuWhattic |
++------------------------------------+
+```
+
+2. Отрицательная длина: замена до конца строки
+```sql
+SELECT overlay('Quadratic', 2, -1, 'Hi');
+```
+```text
++-----------------------------------+
+| overlay('Quadratic', 2, -1, 'Hi') |
++-----------------------------------+
+| QHi |
++-----------------------------------+
+```
+
+3. Позиция за пределами строки: замена не выполняется
+```sql
+SELECT overlay('Hello', 10, 2, 'X');
+```
+```text
++-------------------------------+
+| overlay('Hello', 10, 2, 'X') |
++-------------------------------+
+| Hello |
++-------------------------------+
+```
+
+4. Обработка значения NULL
+```sql
+SELECT overlay('Hello', NULL, 2, 'X');
+```
+```text
++--------------------------------+
+| overlay('Hello', NULL, 2, 'X') |
++--------------------------------+
+| NULL |
++--------------------------------+
+```
+
+```sql
+SELECT INSERT('🎉🎊🎈', 2, 1, '🎁');
+```
+```text
++--------------------------------------+
+| INSERT('🎉🎊🎈', 2, 1, '🎁') |
++--------------------------------------+
+| 🎉🎁🎈 |
++--------------------------------------+
+```
diff --git a/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/string-functions/overview.md b/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/string-functions/overview.md
new file mode 100644
index 000000000000..b53148ad49ad
--- /dev/null
+++ b/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/string-functions/overview.md
@@ -0,0 +1,126 @@
+---
+{
+ "title": "Обзор строковых функций",
+ "language": "ru",
+ "description": "Строковые функции представляют собой встроенные функции для обработки строковых данных и выполнения операций с ними. Они позволяют выполнять различные операции со строками,"
+}
+---
+
+# Обзор строковых функций {#string-functions-overview}
+
+Строковые функции представляют собой встроенные функции для обработки строковых данных и выполнения операций с ними. Они позволяют выполнять различные операции со строками, такие как объединение, разбиение, замена, поиск и т. д.
+
+## Поддержка кодировки UTF-8 {#utf-8-encoding-support}
+
+UTF-8 представляет собой кодировку символов переменной длины, которая позволяет представить почти все используемые в мире символы, включая кириллицу, греческие буквы, китайские иероглифы, эмодзи и многое другое.
+
+Строковые функции Doris поддерживают кодировку UTF-8, если явно не указано иное.
+
+Например, функция `substring` корректно обрабатывает строки в кодировке UTF-8:
+
+### Символы ASCII {#ascii-characters}
+
+```sql
+mysql> SELECT substring('abc1', 2);
++----------------------+
+| substring('abc1', 2) |
++----------------------+
+| bc1 |
++----------------------+
+```
+
+### Греческие буквы {#greek-letters}
+
+```sql
+mysql> SELECT substring('αλφαβητον', 2, 4);
++---------------------------------------+
+| substring('αλφαβητον', 2, 4) |
++---------------------------------------+
+| λφαβ |
++---------------------------------------+
+1 row in set (0.01 sec)
+```
+
+### Китайские иероглифы {#chinese-characters}
+
+```sql
+mysql> SELECT substring('你好，世界', 2, 2);
++------------------------------------+
+| substring('你好，世界', 2, 2) |
++------------------------------------+
+| 好， |
++------------------------------------+
+```
+
+### Эмодзи {#emojis}
+
+```sql
+mysql> SELECT substring('😊😊a😊 World!', 2, 3);
++-----------------------------------------+
+| substring('😊😊a😊 World!', 2, 3) |
++-----------------------------------------+
+| 😊a😊 |
++-----------------------------------------+
+```
+
+## Особенности производительности {#performance-considerations}
+
+Поскольку символы в кодировке UTF-8 имеют переменную длину, это может влиять на производительность. Некоторые функции доступны в вариантах для ASCII и UTF-8, между которыми можно выбирать.
+
+Например:
+- Функция `length` возвращает длину строки в байтах
+- Функция `char_length` возвращает количество символов в строке
+
+```sql
+mysql> select length('你好');
++------------------+
+| length('你好') |
++------------------+
+| 6 |
++------------------+
+
+mysql> select length('αλφαβητον');
++------------------------------+
+| length('αλφαβητον') |
++------------------------------+
+| 18 |
++------------------------------+
+
+mysql> select char_length('你好');
++-----------------------+
+| char_length('你好') |
++-----------------------+
+| 2 |
++-----------------------+
+
+mysql> select char_length('αλφαβητον');
++-----------------------------------+
+| char_length('αλφαβητον') |
++-----------------------------------+
+| 9 |
++-----------------------------------+
+```
+
+## Особые замечания {#special-notes}
+
+Если строковая функция не поддерживает кодировку UTF-8, это явно указано в документации. Например, функция `NGRAM_SEARCH` поддерживает только строки в кодировке ASCII.
+
+```sql
+mysql> select ngram_search('abcab' , 'ab' , 2);
++----------------------------------+
+| ngram_search('abcab' , 'ab' , 2) |
++----------------------------------+
+| 0.5 |
++----------------------------------+
+```
+
+Для символов, не входящих в ASCII, `NGRAM_SEARCH` также выполняется, но результаты могут не соответствовать ожиданиям.
+
+```sql
+mysql> select ngram_search('αβγαβ' , 'αβ' , 2);
++-----------------------------------------+
+| ngram_search('αβγαβ' , 'αβ' , 2) |
++-----------------------------------------+
+| 0.6666666666666666 |
++-----------------------------------------+
+```
diff --git a/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/string-functions/parse-data-size.md b/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/string-functions/parse-data-size.md
new file mode 100644
index 000000000000..3f2e50d03d01
--- /dev/null
+++ b/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/string-functions/parse-data-size.md
@@ -0,0 +1,134 @@
+---
+{
+ "title": "PARSE_DATA_SIZE",
+ "language": "ru",
+ "description": "Функция PARSE_DATA_SIZE разбирает строку с единицами измерения объёма данных (например, \"1.5GB\") и преобразует её в числовое значение в байтах."
+}
+---
+
+## Описание {#description}
+
+Функция PARSE_DATA_SIZE разбирает строку с единицами измерения объёма данных (например, "1.5GB") и преобразует её в числовое значение в байтах.
+
+## Синтаксис {#syntax}
+
+```sql
+PARSE_DATA_SIZE(<str>)
+```
+
+## Параметры {#parameters}
+
+| Параметр | Описание |
+| -------- | ----------------------------------------- |
+| `<str>` | Строка с размером данных и единицей измерения (например, "100MB", "2.5GB"). Тип: VARCHAR |
+
+## Возвращаемое значение {#return-value}
+
+Возвращает значение типа LARGEINT, представляющее размер в байтах после преобразования.
+
+Особые случаи:
+- Поддерживаемые единицы измерения (регистр учитывается; используйте именно эти обозначения): B, kB, MB, GB, TB, PB, EB, ZB, YB
+- Для единиц измерения используется основание 1024 (например, 1kB = 1024B)
+- Поддерживаются десятичные дроби (например, "2.5MB")
+- Если формат параметра некорректен, возвращается ошибка
+- Если параметр равен NULL, возвращается NULL. В ветке Doris 4.1 начиная с версии 4.1.5 строки со значением NULL в столбцах, допускающих такие значения, пропускаются до разбора строкового содержимого
+
+**Таблица поддерживаемых единиц измерения:**
+
+| Единица измерения | Название | Байты |
+|------|------|-------|
+| B | Байты | 1 |
+| kB | Килобайты | 1024 |
+| MB | Мегабайты | 1024² |
+| GB | Гигабайты | 1024³ |
+| TB | Терабайты | 1024⁴ |
+| PB | Петабайты | 1024⁵ |
+| EB | Эксабайты | 1024⁶ |
+
+<a id="examples"></a>
+
+## Примеры {#example}
+
+1. Базовое использование: разбор значения в байтах
+```sql
+SELECT parse_data_size('1024B');
+```
+```text
++--------------------------+
+| parse_data_size('1024B') |
++--------------------------+
+| 1024 |
++--------------------------+
+```
+
+2. Разбор значения в килобайтах
+```sql
+SELECT parse_data_size('1kB');
+```
+```text
++------------------------+
+| parse_data_size('1kB') |
++------------------------+
+| 1024 |
++------------------------+
+```
+
+3. Разбор дробного значения в мегабайтах
+```sql
+SELECT parse_data_size('2.5MB');
+```
+```text
++--------------------------+
+| parse_data_size('2.5MB') |
++--------------------------+
+| 2621440 |
++--------------------------+
+```
+
+4. Разбор значения в гигабайтах
+```sql
+SELECT parse_data_size('1GB');
+```
+```text
++------------------------+
+| parse_data_size('1GB') |
++------------------------+
+| 1073741824 |
++------------------------+
+```
+
+5. Разбор значения в терабайтах
+```sql
+SELECT parse_data_size('1TB');
+```
+```text
++------------------------+
+| parse_data_size('1TB') |
++------------------------+
+| 1099511627776 |
++------------------------+
+```
+
+6. Неподдерживаемая единица измерения: ошибка
+```sql
+SELECT parse_data_size('1iB');
+```
+```text
+ERROR 1105 (HY000): errCode = 2, detailMessage = (10.16.10.3)[INVALID_ARGUMENT]Invalid Input argument "1iB" of function parse_data_size
+```
+
+7. Входное значение NULL
+```sql
+SELECT parse_data_size(NULL);
+```
+```text
++-----------------------+
+| parse_data_size(NULL) |
++-----------------------+
+| NULL |
++-----------------------+
+```
+
+### Ключевые слова {#keywords}
+
+ PARSE_DATA_SIZE
diff --git a/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/string-functions/parse-url.md b/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/string-functions/parse-url.md
new file mode 100644
index 000000000000..611521b93676
--- /dev/null
+++ b/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/string-functions/parse-url.md
@@ -0,0 +1,61 @@
+---
+{
+ "title": "PARSE_URL",
+ "language": "ru",
+ "description": "Функция PARSE_URL предназначена для разбора строк URL и извлечения из них различных компонентов, таких как протоколы, хосты, пути, параметры запроса,"
+}
+---
+
+## Описание {#description}
+
+Функция PARSE_URL предназначена для разбора строк URL и извлечения из них различных компонентов, таких как протоколы, хосты, пути, параметры запроса и т. д.
+
+## Синтаксис {#syntax}
+
+```sql
+PARSE_URL( <url>, <name> )
+```
+
+## Параметры {#parameters}
+
+| Параметр | Описание |
+|----------|--------------------------------------------------------------------------------------------------|
+| `<url>` | URL, который необходимо разобрать |
+| `<name>` | Компонент, который необходимо извлечь. Допустимые значения: `PROTOCOL`, `HOST`, `PATH`, `REF`, `AUTHORITY`, `FILE`, `USERINFO`, `PORT`, `QUERY` (без учёта регистра). |
+
+## Возвращаемое значение {#return-value}
+
+Возвращает указанный компонент `<url>`. Особые случаи:
+
+- Если хотя бы один параметр равен NULL, возвращается NULL.
+- Если в качестве `<name>` передано недопустимое значение, возникает ошибка.
+
+## Примеры {#examples}
+
+```sql
+SELECT parse_url ('https://doris.apache.org/', 'HOST');
+```
+
+```text
++------------------------------------------------+
+| parse_url('https://doris.apache.org/', 'HOST') |
++------------------------------------------------+
+| doris.apache.org |
++------------------------------------------------+
+```
+
+```sql
+SELECT parse_url ('https://doris.apache.org/', null);
+```
+
+```text
++----------------------------------------------+
+| parse_url('https://doris.apache.org/', NULL) |
++----------------------------------------------+
+| NULL |
++----------------------------------------------+
+```
+
+## См. также {#see-also}
+
+Чтобы извлечь определённый параметр из QUERY, используйте [extract_url_parameter](./extract-url-parameter.md).
diff --git a/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/string-functions/position.md b/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/string-functions/position.md
new file mode 100644
index 000000000000..a6109e6f7a6d
--- /dev/null
+++ b/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/string-functions/position.md
@@ -0,0 +1,165 @@
+---
+{
+ "title": "POSITION",
+ "language": "ru",
+ "description": "Функция POSITION находит позицию подстроки в основной строке. Отсчёт позиций начинается с 1."
+}
+---
+
+## Описание {#description}
+
+Функция POSITION находит позицию подстроки в основной строке. Отсчёт позиций начинается с 1.
+
+## Синтаксис {#syntax}
+
+```sql
+POSITION(<substr> IN <str>)
+
+POSITION(<substr>, <str> [, <pos>])
+```
+
+## Параметры {#parameters}
+
+| Параметр | Описание |
+| -------- | ----------------------------------------------- |
+| `substr` | Подстрока для поиска. Тип: VARCHAR |
+| `str` | Основная строка, в которой выполняется поиск. Тип: VARCHAR |
+| `pos` | Необязательный параметр, задающий начальную позицию (отсчёт с 1). Если указан, поиск начинается с этой позиции |
+
+## Возвращаемое значение {#return-value}
+
+Возвращает значение типа INT, обозначающее позицию первого вхождения подстроки в основную строку.
+
+Правила поиска:
+- Возвращает индекс позиции, отсчёт которого начинается с 1
+- Если подстрока не найдена, возвращает 0
+- Если указана начальная позиция, поиск начинается с этой позиции
+- Поиск выполняется с учётом регистра
+
+Особые случаи:
+- Если любой из параметров равен NULL, возвращает NULL
+- Если подстрока является пустой строкой, возвращает 1 (или начальную позицию)
+- Если начальная позиция превышает длину строки, возвращает 0
+- Если начальная позиция отрицательная, поиск выполняется с начала строки
+
+## Примеры {#examples}
+
+1. Базовый поиск (две формы синтаксиса)
+```sql
+SELECT POSITION('bar' IN 'foobarbar'), POSITION('bar', 'foobarbar');
+```
+```text
++----------------------------------+--------------------------------+
+| POSITION('bar' IN 'foobarbar') | POSITION('bar', 'foobarbar') |
++----------------------------------+--------------------------------+
+| 4 | 4 |
++----------------------------------+--------------------------------+
+```
+
+2. Поиск с указанием начальной позиции
+```sql
+SELECT POSITION('bar', 'foobarbar', 5), POSITION('xbar', 'foobar');
+```
+```text
++-----------------------------------+----------------------------------+
+| POSITION('bar', 'foobarbar', 5) | POSITION('xbar', 'foobar') |
++-----------------------------------+----------------------------------+
+| 7 | 0 |
++-----------------------------------+----------------------------------+
+```
+
+3. Обработка значений NULL
+```sql
+SELECT POSITION('test' IN NULL), POSITION(NULL, 'test');
+```
+```text
++--------------------------+------------------------+
+| POSITION('test' IN NULL) | POSITION(NULL, 'test') |
++--------------------------+------------------------+
+| NULL | NULL |
++--------------------------+------------------------+
+```
+
+4. Обработка пустых строк
+```sql
+SELECT POSITION('' IN 'hello'), POSITION('world' IN '');
+```
+```text
++------------------------+------------------------+
+| POSITION('' IN 'hello') | POSITION('world' IN '') |
++------------------------+------------------------+
+| 1 | 0 |
++------------------------+------------------------+
+```
+
+5. Поиск с учётом регистра
+```sql
+SELECT POSITION('World' IN 'Hello World'), POSITION('world' IN 'Hello World');
+```
+```text
++----------------------------------+----------------------------------+
+| POSITION('World' IN 'Hello World') | POSITION('world' IN 'Hello World') |
++----------------------------------+----------------------------------+
+| 7 | 0 |
++----------------------------------+----------------------------------+
+```
+
+6. Поиск с разных позиций
+```sql
+SELECT POSITION('a', 'banana', 1), POSITION('a', 'banana', 3);
+```
+```text
++-----------------------------+-----------------------------+
+| POSITION('a', 'banana', 1) | POSITION('a', 'banana', 3) |
++-----------------------------+-----------------------------+
+| 2 | 4 |
++-----------------------------+-----------------------------+
+```
+
+7. Многобайтовые символы UTF-8
+```sql
+SELECT POSITION('ḍḍumai' IN 'ṭṛì ḍḍumai hello'), POSITION('hello', 'ṭṛì ḍḍumai hello', 8);
+```
+```text
++-------------------------------------------------------+---------------------------------------------------+
+| POSITION('ḍḍumai' IN 'ṭṛì ḍḍumai hello') | POSITION('hello', 'ṭṛì ḍḍumai hello', 8) |
++-------------------------------------------------------+---------------------------------------------------+
+| 5 | 12 |
++-------------------------------------------------------+---------------------------------------------------+
+```
+
+8. Поиск специальных символов
+```sql
+SELECT POSITION('@' IN 'user@domain.com'), POSITION('.', 'user@domain.com', 10);
+```
+```text
++----------------------------------+--------------------------------------+
+| POSITION('@' IN 'user@domain.com') | POSITION('.', 'user@domain.com', 10) |
++----------------------------------+--------------------------------------+
+| 5 | 12 |
++----------------------------------+--------------------------------------+
+```
+
+9. Начальная позиция за пределами строки
+```sql
+SELECT POSITION('test', 'hello world', 20), POSITION('test', 'hello world', 0);
+```
+```text
++--------------------------------------+-------------------------------------+
+| POSITION('test', 'hello world', 20) | POSITION('test', 'hello world', 0) |
++--------------------------------------+-------------------------------------+
+| 0 | 0 |
++--------------------------------------+-------------------------------------+
+```
+
+10. Поиск в строках с числами и символами
+```sql
+SELECT POSITION('123' IN '456123789'), POSITION('-', 'phone: 123-456-7890', 11);
+```
+```text
++------------------------------+-------------------------------------------+
+| POSITION('123' IN '456123789') | POSITION('-', 'phone: 123-456-7890', 11) |
++------------------------------+-------------------------------------------+
+| 4 | 11 |
++------------------------------+-------------------------------------------+
+```
diff --git a/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/string-functions/protocol.md b/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/string-functions/protocol.md
new file mode 100644
index 000000000000..51363678b0fb
--- /dev/null
+++ b/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/string-functions/protocol.md
@@ -0,0 +1,59 @@
+---
+{
+ "title": "PROTOCOL",
+ "language": "ru",
+ "description": "Функция PROTOCOL используется главным образом для извлечения протокола из строки URL."
+}
+---
+
+## Описание {#description}
+
+Функция PROTOCOL используется главным образом для извлечения протокола из строки URL.
+
+## Синтаксис {#syntax}
+
+```sql
+PROTOCOL( <url> )
+```
+
+## Параметры {#parameters}
+
+| Параметр | Описание |
+|---------|------------|
+| `<url>` | URL для разбора |
+
+## Возвращаемое значение {#return-value}
+
+Возвращает протокол из <url>. Особые случаи:
+
+- Если хотя бы один из параметров равен NULL, возвращается NULL.
+
+## Примеры {#examples}
+
+```sql
+SELECT protocol('https://doris.apache.org/');
+```
+
+```text
++---------------------------------------+
+| protocol('https://doris.apache.org/') |
++---------------------------------------+
+| https |
++---------------------------------------+
+```
+
+```sql
+SELECT protocol(null);
+```
+
+```text
++----------------+
+| protocol(NULL) |
++----------------+
+| NULL |
++----------------+
+```
+
+## См. также {#see-also}
+
+Для извлечения других частей URL можно использовать [parse_url](./parse-url.md).
diff --git a/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/string-functions/quote.md b/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/string-functions/quote.md
new file mode 100644
index 000000000000..b973c486039a
--- /dev/null
+++ b/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/string-functions/quote.md
@@ -0,0 +1,106 @@
+---
+{
+ "title": "QUOTE",
+ "language": "ru",
+ "description": "Функция QUOTE заключает строку в одинарные кавычки и экранирует специальные символы внутри неё, чтобы строку можно было безопасно использовать в операторах SQL."
+}
+---
+
+## Описание {#description}
+
+Функция QUOTE заключает строку в одинарные кавычки и экранирует специальные символы внутри неё, чтобы строку можно было безопасно использовать в операторах SQL.
+
+## Синтаксис {#syntax}
+
+```sql
+QUOTE(<str>)
+```
+
+## Параметры {#parameters}
+
+| Параметр | Описание |
+| ------- | ----------------------------------------- |
+| `<str>` | Входная строка, которую нужно заключить в кавычки. Тип: VARCHAR |
+
+## Возвращаемое значение {#return-value}
+
+Возвращает значение типа VARCHAR: строку, заключённую в одинарные кавычки, с экранированными специальными символами.
+
+Особые случаи:
+- Если входное значение равно NULL, возвращает строку 'NULL' (без кавычек)
+- Одинарные кавычки `'` экранируются как `\'`
+- Обратные косые черты `\` экранируются как `\\`
+- Для пустой строки возвращает `''`
+
+## Примеры {#examples}
+
+1. Заключение обычной строки в кавычки
+```sql
+SELECT quote('hello');
+```
+```text
++----------------+
+| quote('hello') |
++----------------+
+| 'hello' |
++----------------+
+```
+
+2. Строка с одинарными кавычками (будут экранированы)
+```sql
+SELECT quote("It's a test");
+```
+```text
++----------------------+
+| quote("It's a test") |
++----------------------+
+| 'It\'s a test' |
++----------------------+
+```
+
+3. Обработка значения NULL
+```sql
+SELECT quote(NULL);
+```
+```text
++-------------+
+| quote(NULL) |
++-------------+
+| NULL |
++-------------+
+```
+
+4. Обработка пустой строки
+```sql
+SELECT quote('');
+```
+```text
++-----------+
+| quote('') |
++-----------+
+| '' |
++-----------+
+```
+
+5. Символ обратной косой черты
+```sql
+SELECT quote('aaa\\');
+```
+```text
++----------------+
+| quote('aaa\\') |
++----------------+
+| 'aaa\' |
++----------------+
+```
+
+```sql
+SELECT quote('aaa\cccb');
+```
+```text
++-------------------+
+| quote('aaa\cccb') |
++-------------------+
+| 'aaacccb' |
++-------------------+
+```
diff --git a/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/string-functions/random_bytes.md b/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/string-functions/random_bytes.md
new file mode 100644
index 000000000000..bedf4231c486
--- /dev/null
+++ b/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/string-functions/random_bytes.md
@@ -0,0 +1,94 @@
+---
+{
+ "title": "RANDOM_BYTES",
+ "language": "ru",
+ "description": "Функция RANDOMBYTES генерирует случайную последовательность байтов заданной длины. Возвращаемая последовательность байтов представлена в виде шестнадцатеричной строки."
+}
+---
+
+## Описание {#description}
+
+Функция RANDOM_BYTES генерирует случайную последовательность байтов заданной длины. Возвращаемая последовательность байтов представлена в виде шестнадцатеричной строки.
+
+## Синтаксис {#syntax}
+
+```sql
+RANDOM_BYTES(<len>)
+```
+
+## Параметры {#parameters}
+
+| Параметр | Описание |
+| -------- | ----------------------------------------- |
+| `<len>` | Количество случайных байтов для генерации. Тип: INT |
+
+## Возвращаемое значение {#return-value}
+
+Возвращает значение типа VARCHAR: случайную последовательность байтов, закодированную в шестнадцатеричном формате (с префиксом `0x`).
+
+Особые случаи:
+- `<len>` должен быть больше 0, иначе возвращается ошибка
+- Если параметр равен NULL, возвращается NULL
+- Каждый вызов генерирует случайный результат
+
+## Примеры {#examples}
+
+1. Базовое использование: генерация случайной последовательности длиной 8 байт
+```sql
+SELECT random_bytes(8);
+```
+```text
++--------------------+
+| random_bytes(8) |
++--------------------+
+| 0x1a2b3c4d5e6f7089 |
++--------------------+
+```
+
+2. Генерация короткой последовательности
+```sql
+SELECT random_bytes(4);
+```
+```text
++----------------+
+| random_bytes(4) |
++----------------+
+| 0xab12cd34 |
++----------------+
+```
+
+3. Недопустимый параметр: отрицательное число
+```sql
+SELECT random_bytes(-1);
+```
+```text
+ERROR 1105 (HY000): errCode = 2, detailMessage = (10.16.10.3)[INVALID_ARGUMENT]argument -1 of function random_bytes at row 0 was invalid.
+```
+
+4. Обработка значения NULL
+```sql
+SELECT random_bytes(NULL);
+```
+```text
++--------------------+
+| random_bytes(NULL) |
++--------------------+
+| NULL |
++--------------------+
+```
+
+5. Генерация более длинной последовательности (16 байт)
+```sql
+SELECT random_bytes(16);
+```
+```text
++------------------------------------+
+| random_bytes(16) |
++------------------------------------+
+| 0x1a2b3c4d5e6f708192a3b4c5d6e7f809 |
++------------------------------------+
+```
+
+### Ключевые слова {#keywords}
+
+ RANDOM_BYTES
diff --git a/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/string-functions/regexp-count.md b/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/string-functions/regexp-count.md
new file mode 100644
index 000000000000..897a04c2054e
--- /dev/null
+++ b/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/string-functions/regexp-count.md
@@ -0,0 +1,249 @@
+---
+{
+ "title": "REGEXP_COUNT",
+ "language": "ru",
+ "description": "Функция подсчитывает количество символов в строке, соответствующих заданному шаблону регулярного выражения."
+}
+---
+
+<!--
+Licensed to the Apache Software Foundation (ASF) under one
+or more contributor license agreements. See the NOTICE file
+distributed with this work for additional information
+regarding copyright ownership. The ASF licenses this file
+to you under the Apache License, Version 2.0 (the
+"License"); you may not use this file except in compliance
+with the License. You may obtain a copy of the License at
+ http://www.apache.org/licenses/LICENSE-2.0
+Unless required by applicable law or agreed to in writing,
+software distributed under the License is distributed on an
+"AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+KIND, either express or implied. See the License for the
+specific language governing permissions and limitations
+under the License.
+-->
+
+## Описание {#description}
+Функция подсчитывает количество символов в строке, соответствующих заданному шаблону регулярного выражения. На вход подаются заданная пользователем строка и шаблон регулярного выражения. Возвращается общее количество совпадающих символов; если совпадений нет, возвращается 0.
+
+Параметр 'str' имеет тип 'string' и содержит строку, которую пользователь хочет сопоставить с регулярным выражением.
+
+Параметр 'pattern' имеет тип 'string' и содержит регулярное выражение, которое будет использоваться для сопоставления со строкой;
+
+При сопоставлении наборов символов следует использовать стандартные классы символов Utf-8. Это позволяет функциям корректно распознавать и обрабатывать различные символы из разных языков.
+
+Поддерживаемые классы символов: https://github.com/google/re2/wiki/Syntax
+
+## Синтаксис {#syntax}
+
+```sql
+REGEXP_COUNT(<str>, <pattern>)
+```
+
+## Параметры {#parameters}
+
+| Параметр | Описание |
+| -- | -- |
+| `<str>` | Параметр имеет тип 'string' и содержит строку, сопоставляемую с регулярным выражением. |
+| `<pattern>` | Параметр имеет тип 'string' и содержит регулярное выражение, используемое для поиска совпадений в строке. |
+## Возвращаемое значение {#return-value}
+
+- Возвращает количество совпадений с регулярным выражением 'pattern' в строке 'str'; тип результата 'int'. Если совпадающих символов нет, возвращает 0;
+Если pattern имеет значение NULL, str имеет значение NULL или оба имеют значение NULL, возвращает NULL;
+Если pattern содержит недопустимое регулярное выражение, возникает ошибка;
+
+## Примеры {#examples}
+
+Результат сопоставления строки с выражением, содержащим экранированные символы.
+
+```sql
+SELECT regexp_count('a.b:c;d', '[\\\\.:;]');
+```
+
+```text
++--------------------------------------+
+| regexp_count('a.b:c;d', '[\\\\.:;]') |
++--------------------------------------+
+| 3 |
++--------------------------------------+
+```
+
+Результат сопоставления строки с регулярным выражением для обычного символа ':'.
+
+```sql
+SELECT regexp_count('a.b:c;d', ':');
+```
+
+```text
++------------------------------+
+| regexp_count('a.b:c;d', ':') |
++------------------------------+
+| 1 |
++------------------------------+
+```
+Результат сопоставления строки с регулярным выражением, содержащим две квадратные скобки.
+
+```sql
+SELECT regexp_count('Hello, World!', '[[:punct:]]');
+```
+
+```text
++----------------------------------------------+
+| regexp_count('Hello, World!', '[[:punct:]]') |
++----------------------------------------------+
+| 2 |
++----------------------------------------------+
+```
+
+
+Случай, когда pattern имеет значение NULL
+
+```sql
+SELECT regexp_count("abc",NULL);
+```
+```text
++------------------------+
+| regexp_count("abc",NULL) |
++------------------------+
+| NULL |
++------------------------+
+```
+
+
+Случай, когда str имеет значение NULL
+
+```sql
+SELECT regexp_count(NULL,"abc");
+```
+```text
++------------------------+
+| regexp_count(NULL,"abc") |
++------------------------+
+| NULL |
++------------------------+
+```
+
+Оба параметра имеют значение NULL
+
+
+```sql
+SELECT regexp_count(NULL,NULL);
+```
+```text
++------------------------+
+| regexp_count(NULL,NULL) |
++------------------------+
+| NULL |
++------------------------+
+```
+
+Результат сопоставления значений после их вставки в таблицу и последующего чтения из сохранённых строк.
+
+```sql
+
+CREATE TABLE test_table_for_regexp_count (
+ id INT,
+ text_data VARCHAR(500),
+ pattern VARCHAR(100)
+ ) PROPERTIES ("replication_num"="1");
+
+INSERT INTO test_table_for_regexp_count VALUES
+ (1, 'HelloWorld', '[A-Z][a-z]+'),
+ (2, 'apple123', '[a-z]{5}[0-9]'),
+ (3, 'aabbcc', '(aa|bb|cc)'),
+ (4, '123-456-7890', '[0-9][0-9][0-9]'),
+ (5, 'test,data', ','),
+ (6, 'a1b2c3', '[a-z][0-9]'),
+ (7, 'book keeper', 'oo|ee'),
+ (8, 'ababab', '(ab)(ab)(ab)'),
+ (9, 'aabbcc', '(aa|bb|cc)'),
+ (10, 'apple,banana', '[aeiou][a-z]+');
+
+SELECT id, regexp_count(text_data, pattern) as count_result FROM test_table_for_regexp_count ORDER BY id;
+
+```
+
+```text
++------+--------------+
+| id | count_result |
++------+--------------+
+| 1 | 2 |
+| 2 | 1 |
+| 3 | 3 |
+| 4 | 3 |
+| 5 | 1 |
+| 6 | 3 |
+| 7 | 2 |
+| 8 | 1 |
+| 9 | 3 |
+| 10 | 2 |
++------+--------------+
+
+```
+Результат сопоставления значений после их вставки в таблицу и последующего чтения из сохранённых строк, когда регулярное выражение задано константой.
+
+```sql
+CREATE TABLE test_table_for_regexp_count (
+ id INT,
+ text_data VARCHAR(500),
+ pattern VARCHAR(100)
+ ) PROPERTIES ("replication_num"="1");
+
+INSERT INTO test_table_for_regexp_count VALUES
+ (1, 'HelloWorld', '[A-Z][a-z]+'),
+ (2, 'apple123', '[a-z]{5}[0-9]'),
+ (3, 'aabbcc', '(aa|bb|cc)'),
+ (4, '123-456-7890', '[0-9][0-9][0-9]'),
+ (5, 'test,data', ','),
+ (6, 'a1b2c3', '[a-z][0-9]'),
+ (7, 'book keeper', 'oo|ee'),
+ (8, 'ababab', '(ab)(ab)(ab)'),
+ (9, 'aabbcc', '(aa|bb|cc)'),
+ (10, 'apple,banana', '[aeiou][a-z]+');
+
+SELECT id, regexp_count(text_data, 'e') as count_e FROM test_table_for_regexp_count WHERE text_data IS NOT NULL ORDER BY id;
+```
+
+```text
++------+---------+
+| id | count_e |
++------+---------+
+| 1 | 1 |
+| 2 | 1 |
+| 3 | 0 |
+| 4 | 0 |
+| 5 | 1 |
+| 6 | 0 |
+| 7 | 3 |
+| 8 | 0 |
+| 9 | 0 |
+| 10 | 1 |
++------+---------+
+```
+
+Подсчёт совпадений с регулярным выражением для эмодзи
+
+```sql
+SELECT regexp_count('🍔🍟🍕🌍', '🍔|🍟|🍕');
+```
+
+```text
++----------------------------------------------------+
+| regexp_count('🍔🍟🍕🌍', '🍔|🍟|🍕') |
++----------------------------------------------------+
+| 3 |
++----------------------------------------------------+
+```
+
+Если 'pattern' содержит недопустимое регулярное выражение, возникает ошибка
+
+```sql
+
+SELECT regexp_count('Hello, World!', '[[:punct:');
+```
+
+```text
+
+ERROR 1105 (HY000): errCode = 2, detailMessage = (10.16.10.2)[INVALID_ARGUMENT]Could not compile regexp pattern: [[:punct:
+Error: missing ]: [[:punct:
+```
diff --git a/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/string-functions/regexp-extract-all-array.md b/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/string-functions/regexp-extract-all-array.md
new file mode 100644
index 000000000000..e828b09a2ad4
--- /dev/null
+++ b/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/string-functions/regexp-extract-all-array.md
@@ -0,0 +1,82 @@
+---
+{
+ "title": "REGEXP_EXTRACT_ALL_ARRAY",
+ "language": "ru",
+ "description": "Извлекает все совпадения первой группы захвата в виде массива строк."
+}
+---
+
+<version since="dev">
+
+</version>
+
+## Описание {#description}
+
+Извлекает все непересекающиеся совпадения первой группы захвата в `<pattern>` из `<str>` и возвращает массив строк в порядке совпадений. Возвращает `NULL`, если хотя бы один из аргументов равен `NULL`.
+
+## Синтаксис {#syntax}
+
+```sql
+REGEXP_EXTRACT_ALL_ARRAY(<str>, <pattern>)
+```
+
+## Параметры {#parameters}
+
+| Параметр | Описание |
+| --- | --- |
+| `<str>` | Входная строка типа `STRING`. |
+| `<pattern>` | Регулярное выражение типа `STRING`. Извлекается первая группа захвата; третий аргумент с индексом группы не поддерживается. |
+
+## Возвращаемое значение {#return-value}
+
+Возвращает `ARRAY<STRING>`. Возвращает пустой массив `[]`, если нет совпадений или группы захвата. Возвращает `NULL`, если хотя бы один из аргументов равен `NULL`. Некорректное регулярное выражение вызывает ошибку.
+
+По умолчанию движок использует синтаксис RE2 и учитывает регистр при поиске совпадений. Переменная сеанса `enable_extended_regex` включает расширенные возможности регулярных выражений; см. [REGEXP_EXTRACT_ALL](./regexp-extract-all.md). Эта функция возвращает массив, а `REGEXP_EXTRACT_ALL` возвращает форматированную строку.
+
+## Пример {#example}
+
+```sql
+SELECT regexp_extract_all_array('id=12,id=34', 'id=([0-9]+)') AS result;
+```
+
+```text
+["12", "34"]
+```
+
+Используйте `(?i)` для поиска совпадений без учёта регистра:
+
+```sql
+SELECT regexp_extract_all_array('Hello hello HELLO', '(?i)(hello)') AS result;
+```
+
+```text
+["Hello", "hello", "HELLO"]
+```
+
+```sql
+SELECT regexp_extract_all_array('abc', '([0-9]+)') AS no_match,
+ regexp_extract_all_array('abc', 'abc') AS no_capture_group;
+```
+
+```text
+[] []
+```
+
+```sql
+SELECT regexp_extract_all_array(NULL, '(a)') AS null_input,
+ regexp_extract_all_array('a', NULL) AS null_pattern;
+```
+
+```text
+NULL NULL
+```
+
+Результат можно передать непосредственно в функции для работы с массивами:
+
+```sql
+SELECT array_size(regexp_extract_all_array('a1b2', '([0-9])')) AS matches;
+```
+
+```text
+2
+```
diff --git a/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/string-functions/regexp-extract-all.md b/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/string-functions/regexp-extract-all.md
new file mode 100644
index 000000000000..4d4b7b7c037b
--- /dev/null
+++ b/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/string-functions/regexp-extract-all.md
@@ -0,0 +1,305 @@
+---
+{
+ "title": "REGEXP_EXTRACT_ALL",
+ "language": "ru",
+ "description": "Функция REGEXP_EXTRACT_ALL выполняет сопоставление заданной строки str с регулярным выражением и извлекает все фрагменты, соответствующие первой подгруппе указанного шаблона."
+}
+---
+
+## Описание {#description}
+
+Функция `REGEXP_EXTRACT_ALL` выполняет сопоставление заданной строки `str` с регулярным выражением и извлекает все фрагменты, соответствующие первой подгруппе указанного шаблона `pattern`. Функция возвращает строку, представляющую совпавшую часть шаблона, причём шаблон должен точно соответствовать фрагменту входной строки `str`. Если совпадений нет или шаблон не содержит подгрупп, возвращается пустая строка.
+
+При сопоставлении наборов символов следует использовать стандартные классы символов Utf-8. Это позволяет функциям корректно распознавать и обрабатывать символы различных языков.
+
+Если 'pattern' не является допустимым регулярным выражением, возникает ошибка;
+
+Классы символов, поддерживаемые по умолчанию: https://github.com/google/re2/wiki/Syntax
+
+Doris позволяет включить расширенные возможности регулярных выражений, такие как проверки окружения нулевой ширины, с помощью переменной сеанса `enable_extended_regex` (по умолчанию `false`).
+
+Поддерживаемые типы сопоставления символов при значении переменной сеанса `enable_extended_regex`, равном `true`: https://www.boost.org/doc/libs/latest/libs/regex/doc/html/boost_regex/syntax/perl_syntax.html
+
+## Синтаксис {#syntax}
+
+```sql
+REGEXP_EXTRACT_ALL(<str>, <pattern>)
+```
+
+## Параметры {#parameters}
+
+| Параметр | Описание |
+| --- | --- |
+| `<str>` | Параметр типа String. Задаёт входную строку, для которой выполняется сопоставление с регулярным выражением. Это может быть строковый литерал или ссылка на столбец таблицы, содержащий строковые данные.|
+| `<pattern>` | Этот параметр также имеет тип String. Задаёт шаблон регулярного выражения для сопоставления с входной строкой <str>. Шаблон может включать различные конструкции регулярных выражений, такие как классы символов, квантификаторы и подгруппы.|
+
+## Возвращаемое значение {#return-value}
+
+Возвращает `NULL`, если хотя бы один из аргументов равен `NULL`.
+
+Функция возвращает строку, представляющую часть входной строки, которая соответствует первой подгруппе указанного регулярного выражения. Тип возвращаемого значения — String. Если совпадений нет или шаблон не содержит подгрупп, возвращается пустая строка.
+
+Вариант функции, возвращающий массив, описан в разделе [REGEXP_EXTRACT_ALL_ARRAY](./regexp-extract-all-array.md).
+
+**Поведение по умолчанию**:
+
+| Настройка по умолчанию | Поведение |
+| ------------------------------------ | ----------------------------------------------------------------------------------------- |
+| `.` соответствует переводу строки | `.` по умолчанию может соответствовать `\n` (переводу строки). |
+| С учётом регистра | Сопоставление выполняется с учётом регистра. |
+| `^`/`$` соответствуют границам всей строки | `^` соответствует только началу строки, а `$` — только её концу, а не началу и концу отдельных строк текста. |
+| Жадные квантификаторы | `*`, `+` и другие квантификаторы по умолчанию захватывают как можно больше символов. |
+| UTF-8 | Строки обрабатываются в кодировке UTF-8. |
+
+**Модификаторы шаблона**:
+
+Поведение по умолчанию можно изменить, добавив к `pattern` префикс `(?flags)`. Несколько модификаторов можно объединить, например `(?im)`; префикс `-` отключает соответствующий параметр, например `(?-s)`.
+
+Модификаторы шаблона действуют только при использовании стандартного движка регулярных выражений. Если включён `enable_extended_regex=true` и используются проверки нулевой ширины (например, `(?<=...)`, `(?=...)`), запрос обрабатывается движком Boost.Regex, и модификаторы могут работать не так, как ожидается. Рекомендуется не сочетать их.
+
+| Флаг | Значение |
+| ------- | ---------------------------------------------------------------------------- |
+| `(?i)` | Сопоставление без учёта регистра |
+| `(?-i)` | Сопоставление с учётом регистра (по умолчанию) |
+| `(?s)` | `.` соответствует переводу строки (включено по умолчанию) |
+| `(?-s)` | `.` **не** соответствует переводу строки |
+| `(?m)` | Многострочный режим: `^` соответствует началу каждой строки, а `$` — концу каждой строки |
+| `(?-m)` | Однострочный режим: `^`/`$` соответствуют границам всей строки (по умолчанию) |
+| `(?U)` | Нежадные квантификаторы: `*`, `+` и другие захватывают как можно меньше символов |
+| `(?-U)` | Жадные квантификаторы (по умолчанию): `*`, `+` и другие захватывают как можно больше символов |
+
+## Пример {#example}
+
+Простое сопоставление строчных букв вокруг 'C'. В этом примере шаблон ([[:lower:]]+)C([[:lower:]]+) соответствует фрагменту строки, в котором за одной или несколькими строчными буквами следует 'C', а затем ещё одна или несколько строчных букв. Первая подгруппа ([[:lower:]]+) перед 'C' соответствует 'b', поэтому результат — ['b'].
+
+```sql
+SELECT regexp_extract_all('AbCdE', '([[:lower:]]+)C([[:lower:]]+)');
+```
+
+```text
++--------------------------------------------------------------+
+| regexp_extract_all('AbCdE', '([[:lower:]]+)C([[:lower:]]+)') |
++--------------------------------------------------------------+
+| ['b'] |
++--------------------------------------------------------------+
+```
+
+ Несколько совпадений в строке. Здесь шаблон соответствует двум фрагментам строки. В первом совпадении первая подгруппа соответствует 'b', а во втором — 'f'. Поэтому результат — ['b', 'f'].
+
+```sql
+SELECT regexp_extract_all('AbCdEfCg', '([[:lower:]]+)C([[:lower:]]+)');
+```
+
+```text
++-----------------------------------------------------------------+
+| regexp_extract_all('AbCdEfCg', '([[:lower:]]+)C([[:lower:]]+)') |
++-----------------------------------------------------------------+
+| ['b','f'] |
++-----------------------------------------------------------------+
+```
+
+Извлечение ключей из пар «ключ — значение». Шаблон соответствует парам «ключ — значение» в строке. Первая подгруппа захватывает ключи, поэтому результат — ['abc', 'def', 'ghi'].
+
+```sql
+SELECT regexp_extract_all('abc=111, def=222, ghi=333','("[^"]+"|\\w+)=("[^"]+"|\\w+)');
+```
+
+```text
++--------------------------------------------------------------------------------+
+| regexp_extract_all('abc=111, def=222, ghi=333', '("[^"]+"|\w+)=("[^"]+"|\w+)') |
++--------------------------------------------------------------------------------+
+| ['abc','def','ghi'] |
++--------------------------------------------------------------------------------+
+```
+Сопоставление китайских иероглифов. В шаблоне (\p{Han}+)(.+) первая подгруппа (\p{Han}+) соответствует одному или нескольким китайским иероглифам, поэтому результат — ['这是一段中文'].
+
+```sql
+select regexp_extract_all('这是一段中文 This is a passage in English 1234567', '(\\p{Han}+)(.+)');
+```
+
+```text
++------------------------------------------------------------------------------------------------+
+| regexp_extract_all('这是一段中文 This is a passage in English 1234567', '(\p{Han}+)(.+)') |
++------------------------------------------------------------------------------------------------+
+| ['这是一段中文'] |
++------------------------------------------------------------------------------------------------+
+```
+
+Вставка данных и использование REGEXP_EXTRACT_ALL
+
+```sql
+
+CREATE TABLE test_regexp_extract_all (
+ id INT,
+ text_content VARCHAR(255),
+ pattern VARCHAR(255)
+) PROPERTIES ("replication_num"="1");
+
+
+INSERT INTO test_regexp_extract_all VALUES
+(1, 'apple1, banana2, cherry3', '([a-zA-Z]+)\\d'),
+(2, 'red#123, blue#456, green#789', '([a-zA-Z]+)#\\d+'),
+(3, 'hello@example.com, world@test.net', '([a-zA-Z]+)@');
+
+
+SELECT id, regexp_extract_all(text_content, pattern) AS extracted_data
+FROM test_regexp_extract_all;
+```
+```text
++------+----------------------+
+| id | extracted_data |
++------+----------------------+
+| 1 | ['apple', 'banana', 'cherry'] |
+| 2 | ['red', 'blue', 'green'] |
+| 3 | ['hello', 'world'] |
++------+----------------------+
+```
+
+Если совпадений нет, возвращается пустая строка
+
+```sql
+SELECT REGEXP_EXTRACT_ALL('ABC', '(\\d+)');
+```
+```text
++-------------------------------------+
+| REGEXP_EXTRACT_ALL('ABC', '(\\d+)') |
++-------------------------------------+
+| |
++-------------------------------------+
+```
+
+
+Сопоставление эмодзи
+```sql
+SELECT REGEXP_EXTRACT_ALL('👩💻,👨🚀', '(💻|🚀)');
+```
+
+```text
++--------------------------------------------------------------+
+| REGEXP_EXTRACT_ALL('👩💻,👨🚀', '(💻|🚀)') |
++--------------------------------------------------------------+
+| ['💻','🚀'] |
++--------------------------------------------------------------+
+```
+
+
+Если 'Str' равен NULL, возвращается NULL
+
+```sql
+SELECT regexp_extract_all(NULL, '([a-z]+)');
+```
+
+```text
++--------------------------------------+
+| regexp_extract_all(NULL, '([a-z]+)') |
++--------------------------------------+
+| NULL |
++--------------------------------------+
+```
+
+Если 'pattern' равен NULL, возвращается NULL
+
+```sql
+SELECT regexp_extract_all('Hello World', NULL);
+```
+
+```text
++-----------------------------------------+
+| regexp_extract_all('Hello World', NULL) |
++-----------------------------------------+
+| NULL |
++-----------------------------------------+
+```
+
+Если все параметры равны NULL, возвращается NULL
+
+```sql
+SELECT regexp_extract_all(NULL,NULL);
+```
+
+```text
++-------------------------------+
+| regexp_extract_all(NULL,NULL) |
++-------------------------------+
+| NULL |
++-------------------------------+
+```
+
+Если `pattern` не является допустимым регулярным выражением, возникает ошибка;
+
+```sql
+SELECT regexp_extract_all('hello (world) 123', '([[:alpha:]+');
+```
+
+```text
+ERROR 1105 (HY000): errCode = 2, detailMessage = (10.16.10.2)[INVALID_ARGUMENT]Could not compile regexp pattern: ([[:alpha:]+
+Error: missing ]: [[:alpha:]+
+```
+
+Расширенные регулярные выражения
+```sql
+SELECT REGEXP_EXTRACT_ALL('ID:AA-1,ID:BB-2,ID:CC-3', '(?<=ID:)([A-Z]{2}-\\d)');
+```
+
+```text
+ERROR 1105 (HY000): errCode = 2, detailMessage = (127.0.0.1)[INVALID_ARGUMENT]Invalid regex pattern: (?<=ID:)([A-Z]{2}-\d). Error: invalid perl operator: (?<
+```
+
+```sql
+SET enable_extended_regex = true;
+SELECT REGEXP_EXTRACT_ALL('ID:AA-1,ID:BB-2,ID:CC-3', '(?<=ID:)([A-Z]{2}-\\d)');
+```
+```text
++-------------------------------------------------------------------------+
+| REGEXP_EXTRACT_ALL('ID:AA-1,ID:BB-2,ID:CC-3', '(?<=ID:)([A-Z]{2}-\\d)') |
++-------------------------------------------------------------------------+
+| ['AA-1','BB-2','CC-3'] |
++-------------------------------------------------------------------------+
+```
+
+Модификаторы шаблона
+
+Сопоставление без учёта регистра: `(?i)` позволяет игнорировать регистр при сопоставлении
+
+```sql
+SELECT REGEXP_EXTRACT_ALL('Hello hello HELLO', '(hello)') AS case_sensitive,
+ REGEXP_EXTRACT_ALL('Hello hello HELLO', '(?i)(hello)') AS case_insensitive;
+```
+
+```text
++----------------+---------------------------+
+| case_sensitive | case_insensitive |
++----------------+---------------------------+
+| ['hello'] | ['Hello','hello','HELLO'] |
++----------------+---------------------------+
+```
+
+Многострочный режим: `(?m)` позволяет `^` и `$` соответствовать началу и концу каждой строки
+
+```sql
+SELECT REGEXP_EXTRACT_ALL('foo\nbar\nbaz', '^([a-z]+)') AS single_line,
+ REGEXP_EXTRACT_ALL('foo\nbar\nbaz', '(?m)^([a-z]+)') AS multi_line;
+```
+
+```text
++-------------+---------------------+
+| single_line | multi_line |
++-------------+---------------------+
+| ['foo'] | ['foo','bar','baz'] |
++-------------+---------------------+
+```
+
+Жадные и нежадные квантификаторы: `(?U)` заставляет квантификаторы захватывать как можно меньше символов
+
+```sql
+SELECT REGEXP_EXTRACT_ALL('aXbXcXd', '(a.*X)') AS greedy,
+ REGEXP_EXTRACT_ALL('aXbXcXd', '(?U)(a.*X)') AS non_greedy;
+```
+
+```text
++----------+------------+
+| greedy | non_greedy |
++----------+------------+
+| ['aXbXcX'] | ['aX'] |
++----------+------------+
+```
diff --git a/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/string-functions/regexp-extract-or-null.md b/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/string-functions/regexp-extract-or-null.md
new file mode 100644
index 000000000000..ca722c277371
--- /dev/null
+++ b/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/string-functions/regexp-extract-or-null.md
@@ -0,0 +1,342 @@
+---
+{
+ "title": "REGEXP_EXTRACT_OR_NULL",
+ "language": "ru",
+ "description": "Извлекает из текстовой строки первую подстроку, соответствующую заданному шаблону регулярного выражения,"
+}
+---
+
+## Описание {#description}
+
+Извлекает из текстовой строки первую подстроку, соответствующую заданному шаблону регулярного выражения, а затем извлекает из неё определённую группу по индексу группы в выражении.
+
+При сопоставлении наборов символов следует использовать стандартные классы символов Utf-8. Это позволяет функциям корректно распознавать и обрабатывать символы разных языков.
+:::info
+Поддерживается начиная с Apache Doris 3.0.2
+:::
+
+Если 'pattern' не является допустимым регулярным выражением, возникает ошибка
+
+Классы символов, поддерживаемые по умолчанию: https://github.com/google/re2/wiki/Syntax
+
+Doris поддерживает включение расширенных возможностей регулярных выражений, таких как проверки нулевой ширины с просмотром вперёд и назад, с помощью переменной сеанса `enable_extended_regex` (по умолчанию `false`).
+
+Типы сопоставления символов, поддерживаемые при установке переменной сеанса `enable_extended_regex` в `true`: https://www.boost.org/doc/libs/latest/libs/regex/doc/html/boost_regex/syntax/perl_syntax.html
+
+## Синтаксис {#syntax}
+
+```sql
+REGEXP_EXTRACT_OR_NULL(<str>, <pattern>, <pos>)
+```
+
+## Параметры {#parameters}
+
+| Параметр | Описание |
+| -- | -- |
+| `<str>` | Строковый параметр. Задаёт текстовую строку, в которой выполняется поиск совпадений с регулярным выражением. Строка может содержать любую комбинацию символов; функция ищет в ней подстроки, соответствующие <pattern>. |
+| `<pattern>` |Строковый параметр. Задаёт целевой шаблон регулярного выражения. Шаблон может включать различные метасимволы регулярных выражений и классы символов, которые точно определяют правила сопоставления подстроки |
+| `<pos>` | Целочисленный параметр. Задаёт индекс группы выражения, которую нужно извлечь. Индексация начинается с 1. Если <pos> равен 0, возвращается вся первая подстрока, соответствующая шаблону. Если <pos> отрицателен или превышает число групп в шаблоне, функция возвращает NULL. |
+
+## Возвращаемое значение {#return-value}
+
+Возвращает значение строкового типа, содержащее фрагмент, соответствующий `<pattern>`.
+
+ Если входной параметр `<pos>` равен 0, возвращается вся первая совпавшая подстрока.
+ Если входной параметр `<pos>` недопустим (отрицателен или превышает число групп выражения), возвращается NULL.
+ Если совпадение с регулярным выражением не найдено, возвращается NULL.
+ Если `<pos>` < 0, возвращается NULL;
+ Если `pos` больше длины `<str>`, возвращается NULL;
+
+**Поведение по умолчанию**:
+
+| Настройка по умолчанию | Поведение |
+| ------------------------------------ | ----------------------------------------------------------------------------------------- |
+| `.` соответствует символу новой строки | `.` по умолчанию может соответствовать `\n` (символу новой строки). |
+| С учётом регистра | Сопоставление выполняется с учётом регистра. |
+| `^`/`$` соответствуют границам всей строки | `^` соответствует только началу строки, `$` соответствует только её концу, а не началу и концу отдельных строк. |
+| Жадные квантификаторы | `*`, `+` и другие по умолчанию захватывают как можно больше символов. |
+| UTF-8 | Строки обрабатываются как UTF-8. |
+
+**Модификаторы шаблона**:
+
+Поведение по умолчанию можно изменить, добавив перед `pattern` префикс `(?flags)`. Можно сочетать несколько модификаторов, например `(?im)`; префикс `-` отключает соответствующий параметр, например `(?-s)`.
+
+Модификаторы шаблона действуют только при использовании движка регулярных выражений по умолчанию. Если включён `enable_extended_regex=true` и используются проверки нулевой ширины (например, `(?<=...)`, `(?=...)`), запрос обрабатывается движком Boost.Regex, и поведение модификаторов может отличаться от ожидаемого. Рекомендуется не сочетать их.
+
+| Флаг | Значение |
+| ------- | ---------------------------------------------------------------------------- |
+| `(?i)` | Сопоставление без учёта регистра |
+| `(?-i)` | Сопоставление с учётом регистра (по умолчанию) |
+| `(?s)` | `.` соответствует символу новой строки (включено по умолчанию) |
+| `(?-s)` | `.` **не** соответствует символу новой строки |
+| `(?m)` | Многострочный режим: `^` соответствует началу каждой строки, `$` соответствует концу каждой строки |
+| `(?-m)` | Однострочный режим: `^`/`$` соответствуют границам всей строки (по умолчанию) |
+| `(?U)` | Нежадные квантификаторы: `*`, `+` и другие захватывают как можно меньше символов |
+| `(?-U)` | Жадные квантификаторы (по умолчанию): `*`, `+` и другие захватывают как можно больше символов |
+
+## Пример {#example}
+
+Извлечение определённой группы из совпадения. Пояснение: регулярное выражение ([[:lower:]]+)C([[:lower:]]+) ищет последовательности из одной или нескольких строчных букв, разделённые символом 'C'. Группа с индексом 1 соответствует первой последовательности строчных букв, поэтому возвращается 'b'.
+
+```sql
+SELECT REGEXP_EXTRACT_OR_NULL('123AbCdExCx', '([[:lower:]]+)C([[:lower:]]+)', 1);
+```
+
+```text
++---------------------------------------------------------------------------+
+| REGEXP_EXTRACT_OR_NULL('123AbCdExCx', '([[:lower:]]+)C([[:lower:]]+)', 1) |
++---------------------------------------------------------------------------+
+| b |
++---------------------------------------------------------------------------+
+```
+
+Возврат всей совпавшей подстроки. Если <pos> равен 0, возвращается вся первая подстрока, соответствующая шаблону.
+
+```sql
+SELECT REGEXP_EXTRACT_OR_NULL('123AbCdExCx', '([[:lower:]]+)C([[:lower:]]+)', 0);
+```
+
+```text
++---------------------------------------------------------------------------+
+| REGEXP_EXTRACT_OR_NULL('123AbCdExCx', '([[:lower:]]+)C([[:lower:]]+)', 0) |
++---------------------------------------------------------------------------+
+| bCd |
++---------------------------------------------------------------------------+
+```
+
+Недопустимый индекс группы. Поскольку шаблон содержит только 2 группы, индекс 5 выходит за допустимые границы, поэтому возвращается NULL.
+
+```sql
+SELECT REGEXP_EXTRACT_OR_NULL('123AbCdExCx', '([[:lower:]]+)C([[:lower:]]+)', 5);
+```
+
+```text
++---------------------------------------------------------------------------+
+| REGEXP_EXTRACT_OR_NULL('123AbCdExCx', '([[:lower:]]+)C([[:lower:]]+)', 5) |
++---------------------------------------------------------------------------+
+| NULL |
++---------------------------------------------------------------------------+
+```
+Регулярное выражение без совпадений. В строке 'AbCdE' нет фрагмента, полностью соответствующего шаблону
+
+```sql
+SELECT REGEXP_EXTRACT_OR_NULL('AbCdE', '([[:lower:]]+)C([[:upper:]]+)', 1);
+```
+
+```text
++---------------------------------------------------------------------+
+| REGEXP_EXTRACT_OR_NULL('AbCdE', '([[:lower:]]+)C([[:upper:]]+)', 1) |
++---------------------------------------------------------------------+
+| NULL |
++---------------------------------------------------------------------+
+```
+
+Сопоставление китайских символов. Шаблон (\p{Han}+)(.+) сначала сопоставляется с одним или несколькими китайскими символами, а затем с любыми оставшимися символами. Группа с индексом 2 соответствует некитайской части строки, следующей за китайскими символами.
+
+```sql
+select REGEXP_EXTRACT_OR_NULL('这是一段中文 This is a passage in English 1234567', '(\\p{Han}+)(.+)', 2);
+```
+
+```text
++---------------------------------------------------------------------------------------------------------+
+| REGEXP_EXTRACT_OR_NULL('这是一段中文 This is a passage in English 1234567', '(\\p{Han}+)(.+)', 2) |
++---------------------------------------------------------------------------------------------------------+
+| This is a passage in English 1234567 |
++---------------------------------------------------------------------------------------------------------+
+```
+
+Вставка данных в таблицу и извлечение подстрок
+```sql
+
+CREATE TABLE test_regexp_extract_or_null (
+ id INT,
+ text_column VARCHAR(255),
+ pattern_column VARCHAR(255),
+ position_column INT
+) PROPERTIES ("replication_num"="1");
+
+INSERT INTO test_regexp_extract_or_null VALUES
+(1, 'abc123def', '([a-z]+)([0-9]+)([a-z]+)', 2),
+(2, 'Hello World', '([A-Z][a-z]+) ([A-Z][a-z]+)', 0),
+(3, '123-456-789', '([0-9]{3})-([0-9]{3})-([0-9]{3})', 3),
+(4, 'example@example.com', '([a-z]+)@([a-z]+)\\.([a-z]+)', 1),
+(5, '测试文本 test text', '(\\p{Han}+) (.+)', 1);
+
+SELECT id, REGEXP_EXTRACT_OR_NULL(text_column, pattern_column, position_column) AS extracted_result
+FROM test_regexp_extract_or_null
+ORDER BY id;
+
+```
+```text
++------+-----------------+
+| id | extracted_result|
++------+-----------------+
+| 1 | 123 |
+| 2 | Hello World |
+| 3 | 789 |
+| 4 | example |
+| 5 | 测试文本 |
++------+-----------------+
+```
+
+Пример с эмодзи
+
+```sql
+SELECT regexp_extract_or_null('😀😊😎', '😀|😊|😎',0);
+```
+
+```text
++------------------------------------------------------------+
+| regexp_extract_or_null('😀😊😎', '😀|😊|😎',0) |
++------------------------------------------------------------+
+| 😀 |
++------------------------------------------------------------+
+```
+
+Если 'str' равен NULL, возвращается NULL
+
+```sql
+SELECT REGEXP_EXTRACT_OR_NULL(NULL, '([a-z]+)', 1);
+```
+
+```text
++---------------------------------------------+
+| REGEXP_EXTRACT_OR_NULL(NULL, '([a-z]+)', 1) |
++---------------------------------------------+
+| NULL |
++---------------------------------------------+
+```
+
+Если 'pattern' равен NULL, возвращается NULL
+
+```sql
+SELECT REGEXP_EXTRACT_OR_NULL('Hello World', NULL, 1);
+```
+
+```text
++------------------------------------------------+
+| REGEXP_EXTRACT_OR_NULL('Hello World', NULL, 1) |
++------------------------------------------------+
+| NULL |
++------------------------------------------------+
+```
+
+Если 'pos' равен NULL, возвращается NULL
+
+```sql
+SELECT REGEXP_EXTRACT_OR_NULL('Hello World', '([a-z]+)', NULL);
+```
+
+```text
++---------------------------------------------------------+
+| REGEXP_EXTRACT_OR_NULL('Hello World', '([a-z]+)', NULL) |
++---------------------------------------------------------+
+| NULL |
++---------------------------------------------------------+
+```
+
+Если все параметры равны NULL, возвращается NULL;
+
+```sql
+SELECT REGEXP_EXTRACT_OR_NULL(NULL,NULL,NULL);
+```
+
+```text
++----------------------------------------+
+| REGEXP_EXTRACT_OR_NULL(NULL,NULL,NULL) |
++----------------------------------------+
+| NULL |
++----------------------------------------+
+```
+
+Если `pattern` не является допустимым регулярным выражением, возникает ошибка;
+
+```sql
+mysql> SELECT REGEXP_EXTRACT_OR_NULL('123AbCdExCx', '([[:lower:]]+)C([[]ower:]]+)', 1);
+```
+
+```text
+ERROR 1105 (HY000): errCode = 2, detailMessage = (10.16.10.2)[INVALID_ARGUMENT]Could not compile regexp pattern: ([[:lower:]]+)C([[:lower:]+)
+Error: missing ]: [[:lower:]+)
+```
+
+Расширенные регулярные выражения
+```sql
+SELECT regexp_extract_or_null('foo123bar', '(?<=foo)(\\d+)(?=bar)', 1);
+-- ERROR 1105 (HY000): errCode = 2, detailMessage = (127.0.0.1)[INVALID_ARGUMENT]Invalid regex pattern: (?<=foo)(\d+)(?=bar). Error: invalid perl operator: (?<
+```
+
+```sql
+SET enable_extended_regex = true;
+SELECT regexp_extract_or_null('foo123bar', '(?<=foo)(\\d+)(?=bar)', 1);
+```
+```text
++-----------------------------------------------------------------+
+| regexp_extract_or_null('foo123bar', '(?<=foo)(\\d+)(?=bar)', 1) |
++-----------------------------------------------------------------+
+| 123 |
++-----------------------------------------------------------------+
+```
+
+Модификаторы шаблона
+
+Сопоставление без учёта регистра: `(?i)` позволяет игнорировать регистр при сопоставлении
+
+```sql
+SELECT REGEXP_EXTRACT_OR_NULL('Hello World', '(hello)', 1) AS case_sensitive,
+ REGEXP_EXTRACT_OR_NULL('Hello World', '(?i)(hello)', 1) AS case_insensitive;
+```
+
+```text
++----------------+------------------+
+| case_sensitive | case_insensitive |
++----------------+------------------+
+| NULL | Hello |
++----------------+------------------+
+```
+
+`.` по умолчанию соответствует символу новой строки; используйте `(?-s)`, чтобы исключить сопоставление `.` с символом новой строки
+
+```sql
+SELECT REGEXP_EXTRACT_OR_NULL('foo\nbar', '^(.+)$', 1) AS dot_match_nl,
+ REGEXP_EXTRACT_OR_NULL('foo\nbar', '(?-s)^(.+)$', 1) AS dot_not_match_nl;
+```
+
+```text
++--------------+------------------+
+| dot_match_nl | dot_not_match_nl |
++--------------+------------------+
+| foo
+bar | NULL |
++--------------+------------------+
+```
+
+Многострочный режим: `(?m)` позволяет `^` и `$` соответствовать началу и концу каждой строки
+
+```sql
+SELECT REGEXP_EXTRACT_OR_NULL('foo\nbar', '^(bar)', 1) AS single_line,
+ REGEXP_EXTRACT_OR_NULL('foo\nbar', '(?m)^(bar)', 1) AS multi_line;
+```
+
+```text
++-------------+------------+
+| single_line | multi_line |
++-------------+------------+
+| NULL | bar |
++-------------+------------+
+```
+
+Жадное и нежадное сопоставление: `(?U)` заставляет квантификаторы захватывать как можно меньше символов
+
+```sql
+SELECT REGEXP_EXTRACT_OR_NULL('aXbXc', '(a.*X)', 1) AS greedy,
+ REGEXP_EXTRACT_OR_NULL('aXbXc', '(?U)(a.*X)', 1) AS non_greedy;
+```
+
+```text
++--------+------------+
+| greedy | non_greedy |
++--------+------------+
+| aXbX | aX |
++--------+------------+
+```
diff --git a/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/string-functions/regexp-extract.md b/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/string-functions/regexp-extract.md
new file mode 100644
index 000000000000..adbb0d294817
--- /dev/null
+++ b/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/string-functions/regexp-extract.md
@@ -0,0 +1,295 @@
+---
+{
+ "title": "REGEXP_EXTRACT",
+ "language": "ru",
+ "description": "Эта функция выполняет поиск по регулярному выражению в заданной строке STR и извлекает POS-ю совпавшую часть, соответствующую указанному шаблону."
+}
+---
+
+## Описание {#description}
+Эта функция выполняет поиск по регулярному выражению в заданной строке `STR` и извлекает `POS`-ю совпавшую часть, соответствующую указанному шаблону. Чтобы функция вернула результат, шаблон должен точно совпадать с некоторой частью строки `STR`.
+
+Если совпадений нет, возвращается пустая строка.
+При сопоставлении наборов символов следует использовать стандартные классы символов Utf-8. Это позволяет функциям правильно распознавать и обрабатывать символы разных языков.
+
+Параметр `str` имеет тип 'string' и задаёт строку, в которой выполняется поиск по регулярному выражению.
+Параметр `pattern` имеет тип 'string' и задаёт искомое регулярное выражение.
+Параметр `pos` имеет тип 'integer' и задаёт позицию в строке, с которой начинается поиск совпадения с регулярным выражением. Отсчёт позиций начинается с 1; этот параметр обязателен.
+
+Если `pattern` содержит недопустимое регулярное выражение, возникает ошибка.
+
+Классы символов, поддерживаемые по умолчанию: https://github.com/google/re2/wiki/Syntax
+
+Doris позволяет включить расширенные возможности регулярных выражений, например проверки окружения нулевой ширины (look-around), с помощью переменной сеанса `enable_extended_regex` (значение по умолчанию: `false`).
+
+Типы сопоставления символов, поддерживаемые при установке переменной сеанса `enable_extended_regex` в `true`: https://www.boost.org/doc/libs/latest/libs/regex/doc/html/boost_regex/syntax/perl_syntax.html
+
+## Синтаксис {#syntax}
+```sql
+REGEXP_EXTRACT(<str>, <pattern>, <pos>)
+```
+## Параметры {#parameters}
+
+| Параметр | Описание |
+| -- | -- |
+| `<str>` | Столбец, в котором нужно выполнить поиск по регулярному выражению. Имеет тип 'string'.|
+| `<pattern>` | Искомое регулярное выражение. Имеет тип 'string'.|
+| `<pos>` | Параметр, задающий позицию в строке, с которой начинается поиск совпадения с регулярным выражением. Это целое число, обозначающее позицию символа в строке (начиная с 1). Параметр `pos` обязателен. |
+
+## Возвращаемое значение {#return-value}
+
+Часть строки, соответствующая шаблону. Имеет тип Varchar. Если совпадений нет, возвращается пустая строка.
+
+**Поведение по умолчанию**:
+
+| Настройка по умолчанию | Поведение |
+| ------------------------------------ | ----------------------------------------------------------------------------------------- |
+| `.` соответствует символу новой строки | По умолчанию `.` может соответствовать `\n` (символу новой строки). |
+| Учёт регистра | Поиск совпадений выполняется с учётом регистра. |
+| `^`/`$` соответствуют границам всей строки | `^` соответствует только началу строки, `$` соответствует только её концу, а не началу или концу отдельных строк. |
+| Жадные квантификаторы | По умолчанию `*`, `+` и другие квантификаторы захватывают как можно больше символов. |
+| UTF-8 | Строки обрабатываются в кодировке UTF-8. |
+
+**Модификаторы шаблона**:
+
+Изменить поведение по умолчанию можно, добавив в начало `pattern` модификатор `(?flags)`. Можно объединять несколько модификаторов, например `(?im)`; префикс `-` отключает соответствующий параметр, например `(?-s)`.
+
+Модификаторы шаблона действуют только при использовании стандартного движка регулярных выражений. Если включён `enable_extended_regex=true` и используются проверки нулевой ширины (например, `(?<=...)`, `(?=...)`), запрос обрабатывается движком Boost.Regex, и модификаторы могут вести себя не так, как ожидается. Рекомендуется не сочетать эти возможности.
+
+| Флаг | Значение |
+| ------- | ---------------------------------------------------------------------------- |
+| `(?i)` | Поиск совпадений без учёта регистра |
+| `(?-i)` | Поиск с учётом регистра (по умолчанию) |
+| `(?s)` | `.` соответствует символу новой строки (включено по умолчанию) |
+| `(?-s)` | `.` **не** соответствует символу новой строки |
+| `(?m)` | Многострочный режим: `^` соответствует началу каждой строки, `$` соответствует концу каждой строки |
+| `(?-m)` | Однострочный режим: `^`/`$` соответствуют границам всей строки (по умолчанию) |
+| `(?U)` | Нежадные квантификаторы: `*`, `+` и другие захватывают как можно меньше символов |
+| `(?-U)` | Жадные квантификаторы (по умолчанию): `*`, `+` и другие захватывают как можно больше символов |
+
+## Пример {#example}
+
+Извлечение первой совпавшей части. В этом примере регулярное выражение ([[:lower:]]+)C([[:lower:]]+) соответствует фрагменту строки, в котором после одной или нескольких строчных букв следует 'C', а затем одна или несколько строчных букв. Первая захватывающая группа ([[:lower:]]+) перед 'C' соответствует 'b', поэтому результатом будет 'b'.
+
+```sql
+mysql> SELECT regexp_extract('AbCdE', '([[:lower:]]+)C([[:lower:]]+)', 1);
++-------------------------------------------------------------+
+| regexp_extract('AbCdE', '([[:lower:]]+)C([[:lower:]]+)', 1) |
++-------------------------------------------------------------+
+| b |
++-------------------------------------------------------------+
+```
+Извлечение второй совпавшей части. Здесь вторая захватывающая группа ([[:lower:]]+) после 'C' соответствует 'd', поэтому результатом будет 'd'.
+
+```sql
+mysql> SELECT regexp_extract('AbCdE', '([[:lower:]]+)C([[:lower:]]+)', 2);
++-------------------------------------------------------------+
+| regexp_extract('AbCdE', '([[:lower:]]+)C([[:lower:]]+)', 2) |
++-------------------------------------------------------------+
+| d |
++-------------------------------------------------------------+
+```
+Поиск китайских символов. Шаблон (\p{Han}+)(.+) сначала сопоставляется с одним или несколькими китайскими символами (\p{Han}+), а затем с оставшейся частью строки ((.+)). Вторая захватывающая группа соответствует части строки без китайских символов, поэтому результатом будет 'This is a passage in English 1234567'.
+
+```sql
+mysql> select regexp_extract('这是一段中文 This is a passage in English 1234567', '(\\p{Han}+)(.+)', 2);
++-----------------------------------------------------------------------------------------------+
+| regexp_extract('这是一段中文 This is a passage in English 1234567', '(\p{Han}+)(.+)', 2) |
++-----------------------------------------------------------------------------------------------+
+| This is a passage in English 1234567 |
++-----------------------------------------------------------------------------------------------+
+```
+
+Вставка значений переменных и поиск совпадений. В этом примере данные вставляются в таблицу, а затем функция REGEXP_EXTRACT извлекает совпавшие части сохранённых строк на основе сохранённых шаблонов и позиций.
+
+```sql
+
+CREATE TABLE test_table_for_regexp_extract (
+ id INT,
+ text_data VARCHAR(500),
+ pattern VARCHAR(100),
+ pos INT
+ ) PROPERTIES ("replication_num"="1");
+
+INSERT INTO test_table_for_regexp_extract VALUES
+ (1, 'AbCdE', '([[:lower:]]+)C([[:lower:]]+)', 1),
+ (2, 'AbCdE', '([[:lower:]]+)C([[:lower:]]+)', 2),
+ (3, '这是一段中文 This is a passage in English 1234567', '(\\p{Han}+)(.+)', 2);
+
+SELECT id, regexp_extract(text_data, pattern, pos) as extract_result FROM test_table_for_regexp_extract ORDER BY id;
+
+```
+```text
++------+----------------+
+| id | extract_result |
++------+----------------+
+| 1 | b |
+| 2 | d |
+| 3 | This is a passage in English 1234567 |
++------+----------------+
+```
+
+Проверка с шаблоном, для которого нет совпадений. Поскольку шаблон ([[:digit:]]+) (одна или несколько цифр) не соответствует ни одной части строки 'AbCdE', возвращается пустая строка.
+
+```sql
+SELECT regexp_extract('AbCdE', '([[:digit:]]+)', 1);
+```
+
+```text
++------------------------------------------------+
+| regexp_extract('AbCdE', '([[:digit:]]+)', 1) |
++------------------------------------------------+
+| |
++------------------------------------------------+
+```
+Пример с эмодзи
+
+```sql
+SELECT regexp_extract('Text 😊 More 😀', '😊|😀',0);
+
+```
+
+```text
++------------------------------------------------------+
+| regexp_extract('Text 😊 More 😀', '😊|😀',0) |
++------------------------------------------------------+
+| 😊 |
++------------------------------------------------------+
+
+```
+
+Если 'str' имеет значение NULL, возвращается NULL
+
+```sql
+mysql> SELECT REGEXP_EXTRACT(NULL, '([a-z]+)', 1);
++-------------------------------------+
+| REGEXP_EXTRACT(NULL, '([a-z]+)', 1) |
++-------------------------------------+
+| NULL |
++-------------------------------------+
+```
+
+Если 'pattern' имеет значение NULL, возвращается NULL
+
+```sql
+mysql> SELECT REGEXP_EXTRACT('Hello World', NULL, 1);
++----------------------------------------+
+| REGEXP_EXTRACT('Hello World', NULL, 1) |
++----------------------------------------+
+| NULL |
++----------------------------------------+
+```
+
+Если 'pos' имеет значение NULL, возвращается NULL
+
+```sql
+mysql> SELECT REGEXP_EXTRACT('Hello World', '([a-z]+)', NULL);
++-------------------------------------------------+
+| REGEXP_EXTRACT('Hello World', '([a-z]+)', NULL) |
++-------------------------------------------------+
+| NULL |
++-------------------------------------------------+
+```
+
+Если все параметры имеют значение NULL, возвращается NULL
+
+```sql
+mysql> SELECT REGEXP_EXTRACT(NULL, NULL, NULL);
++----------------------------------+
+| REGEXP_EXTRACT(NULL, NULL, NULL) |
++----------------------------------+
+| NULL |
++----------------------------------+
+```
+
+Если `pattern` содержит недопустимое регулярное выражение, возникает ошибка.
+
+```sql
+SELECT regexp_extract('AbCdE', '([[:digit:]]+', 1);
+```
+
+```text
+ERROR 1105 (HY000): errCode = 2, detailMessage = (10.16.10.2)[INVALID_ARGUMENT]Could not compile regexp pattern: ([[:digit:]]+
+Error: missing ): ([[:digit:]]+
+```
+
+Расширенные регулярные выражения
+```sql
+SELECT regexp_extract('foo123bar456baz', '(?<=foo)(\\d+)(?=bar)', 1);
+-- ERROR 1105 (HY000): errCode = 2, detailMessage = (127.0.0.1)[INVALID_ARGUMENT]Invalid regex pattern: (?<=foo)(\d+)(?=bar). Error: invalid perl operator: (?<
+```
+
+```sql
+SET enable_extended_regex = true;
+SELECT regexp_extract('foo123bar456baz', '(?<=foo)(\\d+)(?=bar)', 1);
+```
+```text
++---------------------------------------------------------------+
+| regexp_extract('foo123bar456baz', '(?<=foo)(\\d+)(?=bar)', 1) |
++---------------------------------------------------------------+
+| 123 |
++---------------------------------------------------------------+
+```
+
+Модификаторы шаблона
+
+Поиск без учёта регистра: `(?i)` позволяет игнорировать регистр при сопоставлении
+
+```sql
+SELECT REGEXP_EXTRACT('Hello World', '(hello)', 1) AS case_sensitive,
+ REGEXP_EXTRACT('Hello World', '(?i)(hello)', 1) AS case_insensitive;
+```
+
+```text
++----------------+------------------+
+| case_sensitive | case_insensitive |
++----------------+------------------+
+| | Hello |
++----------------+------------------+
+```
+
+По умолчанию `.` соответствует символу новой строки; используйте `(?-s)`, чтобы `.` не соответствовал символу новой строки
+
+```sql
+SELECT REGEXP_EXTRACT('foo\nbar', '^(.+)$', 1) AS dot_match_nl,
+ REGEXP_EXTRACT('foo\nbar', '(?-s)^(.+)$', 1) AS dot_not_match_nl;
+```
+
+```text
++--------------+------------------+
+| dot_match_nl | dot_not_match_nl |
++--------------+------------------+
+| foo
+bar | |
++--------------+------------------+
+```
+
+Многострочный режим: `(?m)` позволяет `^` и `$` соответствовать началу и концу каждой строки
+
+```sql
+SELECT REGEXP_EXTRACT('foo\nbar', '^(bar)', 1) AS single_line,
+ REGEXP_EXTRACT('foo\nbar', '(?m)^(bar)', 1) AS multi_line;
+```
+
+```text
++-------------+------------+
+| single_line | multi_line |
++-------------+------------+
+| | bar |
++-------------+------------+
+```
+
+Жадный и нежадный поиск: `(?U)` заставляет квантификаторы захватывать как можно меньше символов
+
+```sql
+SELECT REGEXP_EXTRACT('aXbXc', '(a.*X)', 1) AS greedy,
+ REGEXP_EXTRACT('aXbXc', '(?U)(a.*X)', 1) AS non_greedy;
+```
+
+```text
++--------+------------+
+| greedy | non_greedy |
++--------+------------+
+| aXbX | aX |
++--------+------------+
+```
diff --git a/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/string-functions/regexp-replace-one.md b/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/string-functions/regexp-replace-one.md
new file mode 100644
index 000000000000..13673bc2acbf
--- /dev/null
+++ b/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/string-functions/regexp-replace-one.md
@@ -0,0 +1,185 @@
+---
+{
+ "title": "REGEXP_REPLACE_ONE",
+ "language": "ru",
+ "description": "Функция REGEXP_REPLACE_ONE представляет собой мощный инструмент для поиска совпадений с регулярным выражением в заданной строке."
+}
+---
+
+## Описание {#description}
+
+Функция `REGEXP_REPLACE_ONE` представляет собой мощный инструмент для поиска совпадений с регулярным выражением в заданной строке. Она позволяет найти и заменить первое вхождение определённого шаблона в строке.
+
+При работе с текстовыми данными часто требуется изменять строки по определённым правилам. Регулярные выражения позволяют гибко и эффективно задавать эти правила. Функция принимает строку (`str`), шаблон регулярного выражения (`pattern`) и строку замены (`repl`). Затем она ищет первую часть строки `str`, соответствующую шаблону `pattern`, и заменяет её строкой `repl`.
+
+При сопоставлении наборов символов следует использовать стандартные классы символов Utf-8. Это позволяет функциям правильно распознавать и обрабатывать различные символы разных языков.
+
+Если `pattern` не является допустимым регулярным выражением, возникает ошибка.
+
+Поддерживаемые классы символов: https://github.com/google/re2/wiki/Syntax
+
+## Синтаксис {#syntax}
+
+```sql
+REGEXP_REPLACE_ONE(<str>, <pattern>, <repl>)
+```
+
+## Параметры {#parameters}
+
+| Параметр | Описание |
+| -- | -- |
+| `<str>` | Параметр строкового типа. Задаёт строку, в которой будет выполняться поиск совпадений с регулярным выражением. Это исходная строка, которую требуется изменить.|
+| `<pattern>` | Этот параметр также имеет строковый тип. Он задаёт шаблон регулярного выражения. Функция ищет первое вхождение этого шаблона в строке <str>.|
+| `<repl>` | Этот параметр также имеет строковый тип. Он содержит строку, которая заменит первую часть <str>, соответствующую шаблону <pattern>.|
+
+## Возвращаемое значение {#return-value}
+
+Функция возвращает строку, полученную после замены. Тип возвращаемого значения: Varchar. Если ни одна часть <str> не соответствует шаблону <pattern>, возвращается исходная строка <str>.
+
+## Пример {#example}
+
+Замена первого пробела дефисом
+ Пояснение: в этом примере входная строка <str> имеет значение 'a b c', шаблон регулярного выражения <pattern> представляет собой один пробел ' ', а строка замены <repl> содержит дефис '-'. Функция ищет первое вхождение пробела в строке 'a b c' и заменяет его дефисом. Результат: 'a-b c'.
+
+```sql
+mysql> SELECT regexp_replace_one('a b c', ' ', '-');
+
++-----------------------------------+
+| regexp_replace_one('a b c', ' ', '-') |
++-----------------------------------+
+| a-b c |
++-----------------------------------+
+```
+
+Замена первого совпадения с группой. Здесь входная строка <str> имеет значение 'a b b', а шаблон регулярного выражения <pattern> имеет вид '(b)' и представляет собой захватывающую группу, соответствующую символу 'b'. Строка замены <repl> имеет значение '<\1>', где \1 ссылается на первую захватывающую группу (в данном случае на найденный символ 'b'). Функция находит первое вхождение 'b' в строке 'a b b' и заменяет его на '<b>'. Результат: 'a <b> b'.
+
+
+```sql
+mysql> SELECT regexp_replace_one('a b b', '(b)', '<\\1>');
++----------------------------------------+
+| regexp_replace_one('a b b', '(b)', '<\1>') |
++----------------------------------------+
+| a <b> b |
++----------------------------------------+
+```
+Замена первого китайского иероглифа. Входная строка <str> представляет собой длинную строку, содержащую китайские иероглифы и английский текст. Шаблон регулярного выражения <pattern> имеет вид '\p{Han}' и представляет собой класс символов Unicode, соответствующий любому китайскому иероглифу. Строка замены <repl> имеет значение '123'. Функция ищет первый китайский иероглиф в строке и заменяет его на '123'. Результат: '123是一段中文This is a passage in English 1234567'.
+
+```sql
+mysql> select regexp_replace_one('这是一段中文 This is a passage in English 1234567', '\\p{Han}', '123');
++------------------------------------------------------------------------------------------------+
+| regexp_replace_one('这是一段中文 This is a passage in English 1234567', '\p{Han}', '123') |
++------------------------------------------------------------------------------------------------+
+| 123是一段中文This is a passage in English 1234567 |
++------------------------------------------------------------------------------------------------+
+```
+
+Вставка данных в таблицу и выполнение замены. Сначала создаётся таблица test_table_for_regexp_replace_one с четырьмя столбцами: id (целое число), text_data (строка, в которой будет выполняться замена), pattern (шаблон регулярного выражения для поиска совпадений) и repl (строка замены). Затем в таблицу вставляются десять строк данных с различными значениями для четырёх столбцов. Наконец, выполняется запрос SELECT к таблице. Для каждой строки функция REGEXP_REPLACE_ONE применяется к столбц [...]
+
+```sql
+CREATE TABLE test_table_for_regexp_replace_one (
+ id INT,
+ text_data VARCHAR(500),
+ pattern VARCHAR(100),
+ repl VARCHAR(100)
+ ) PROPERTIES ("replication_num"="1");
+
+INSERT INTO test_table_for_regexp_replace_one VALUES
+ (1, 'Hello World', ' ', '-'),
+ (2, 'apple123', '[0-9]', 'X'),
+ (3, 'aabbcc', '(aa)', 'AA'),
+ (4, '123-456-7890', '[0-9][0-9][0-9]', 'XXX'),
+ (5, 'test,data', ',', ';'),
+ (6, 'a1b2c3', '[a-z][0-9]', 'X'),
+ (7, 'book keeper', 'oo', 'OO'),
+ (8, 'ababab', '(ab)', 'AB'),
+ (9, 'aabbcc', '(bb)', 'BB'),
+ (10, 'apple,banana', '[aeiou]', 'X');
+
+SELECT id, regexp_replace_one(text_data, pattern, repl) as replaced_result FROM test_table_for_regexp_replace_one ORDER BY id;
+```
+
+```text
++------+-----------------+
+| id | replaced_result |
++------+-----------------+
+| 1 | Hello-World |
+| 2 | appleX23 |
+| 3 | AAbbcc |
+| 4 | XXX-456-7890 |
+| 5 | test;data |
+| 6 | Xb2c3 |
+| 7 | BOOk keeper |
+| 8 | ABabab |
+| 9 | aaBBcc |
+| 10 | Xpple,banana |
++------+-----------------+
+```
+
+Пример замены первого эмодзи
+
+```sql
+SELECT regexp_replace_one('😀😊😀', '😀|😊', '[SMILE]');
+```
+
+```text
++------------------------------------------------------------+
+| regexp_replace_one('😀😊😀', '😀|😊', '[SMILE]') |
++------------------------------------------------------------+
+| [SMILE]😊😀 |
++------------------------------------------------------------+
+```
+
+
+Если 'str' имеет значение NULL, возвращается NULL
+```sql
+mysql> SELECT REGEXP_REPLACE_ONE(NULL, ' ', '-');
++------------------------------------+
+| REGEXP_REPLACE_ONE(NULL, ' ', '-') |
++------------------------------------+
+| NULL |
++------------------------------------+
+```
+
+Если 'pattern' имеет значение NULL, возвращается NULL
+
+```sql
+mysql> SELECT REGEXP_REPLACE_ONE('Hello World', NULL, '-');
++----------------------------------------------+
+| REGEXP_REPLACE_ONE('Hello World', NULL, '-') |
++----------------------------------------------+
+| NULL |
++----------------------------------------------+
+```
+Если 'repl' имеет значение NULL, возвращается NULL
+
+```sql
+mysql> SELECT REGEXP_REPLACE_ONE('Hello World', ' ', NULL);
++----------------------------------------------+
+| REGEXP_REPLACE_ONE('Hello World', ' ', NULL) |
++----------------------------------------------+
+| NULL |
++----------------------------------------------+
+```
+
+Если все параметры имеют значение NULL, возвращается NULL
+
+```sql
+mysql> SELECT REGEXP_REPLACE_ONE(NULL, NULL, NULL);
++--------------------------------------+
+| REGEXP_REPLACE_ONE(NULL, NULL, NULL) |
++--------------------------------------+
+| NULL |
++--------------------------------------+
+```
+
+Если `pattern` не является допустимым регулярным выражением, возникает ошибка
+
+```sql
+SELECT regexp_replace_one('a b b', '(b', '<\\1>');
+```
+
+```text
+ERROR 1105 (HY000): errCode = 2, detailMessage = (10.16.10.2)[INVALID_ARGUMENT]Could not compile regexp pattern: (b
+Error: missing ): (b
+
+```
diff --git a/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/string-functions/regexp-replace.md b/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/string-functions/regexp-replace.md
new file mode 100644
index 000000000000..c9959b40b908
--- /dev/null
+++ b/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/string-functions/regexp-replace.md
@@ -0,0 +1,184 @@
+---
+{
+ "title": "REGEXP_REPLACE",
+ "language": "ru",
+ "description": "Сопоставляет строки STR с регулярным выражением, заменяя совпавшую часть новой строкой."
+}
+---
+
+## Описание {#description}
+
+Сопоставляет строки STR с регулярным выражением, заменяя совпавшую часть новой строкой.
+
+При сопоставлении наборов символов следует использовать стандартные классы символов Utf-8. Это позволяет функциям корректно распознавать и обрабатывать различные символы разных языков.
+
+Если `pattern` не является допустимым регулярным выражением, возникает ошибка.
+
+Поддерживаемые классы символов: https://github.com/google/re2/wiki/Syntax
+
+## Синтаксис {#syntax}
+
+```sql
+REGEXP_REPLACE(<str>, <pattern>, <repl>)
+```
+
+## Параметры {#parameters}
+
+| Параметр | Описание |
+| -- | -- |
+| `<str>` | Этот параметр имеет тип Varchar. Он задаёт строку, в которой будет выполняться поиск совпадений с регулярным выражением. Это может быть строковый литерал или столбец таблицы со строковыми значениями.|
+| `<pattern>` | Этот параметр имеет тип Varchar. Он задаёт шаблон регулярного выражения для сопоставления со строкой. Шаблон может включать различные метасимволы и конструкции регулярных выражений для определения сложных правил сопоставления.|
+| `<repl>` | Этот параметр имеет тип Varchar. Он задаёт строку, которая заменит части <str>, совпадающие с <pattern>. Для обращения к захваченным группам в шаблоне можно использовать обратные ссылки, такие как \1, \2 и т. д., где \1 обозначает первую захваченную группу, а \2 обозначает вторую захваченную группу, и так далее.|
+
+## Возвращаемое значение {#return-value}
+
+Функция возвращает строку, полученную после замены. Возвращаемое значение имеет тип Varchar. Если ни одна часть <str> не совпадает с <pattern>, возвращается исходная строка <str>.
+
+## Пример {#example}
+
+Простой пример замены. В этом примере все пробелы в строке 'a b c' заменяются дефисами.
+
+```sql
+mysql> SELECT regexp_replace('a b c', ' ', '-');
++-----------------------------------+
+| regexp_replace('a b c', ' ', '-') |
++-----------------------------------+
+| a-b-c |
++-----------------------------------+
+```
+Использование захваченных групп. Здесь символ 'b' захватывается группой (b) в шаблоне, а затем заменяется на <b> с помощью обратной ссылки \1 в строке замены.
+
+```sql
+mysql> SELECT regexp_replace('a b c', '(b)', '<\\1>');
++----------------------------------------+
+| regexp_replace('a b c', '(b)', '<\1>') |
++----------------------------------------+
+| a <b> c |
++----------------------------------------+
+```
+
+Сопоставление китайских символов. В этом примере все последовательности китайских символов в строке заменяются на '123'.
+
+```sql
+mysql> select regexp_replace('这是一段中文 This is a passage in English 1234567', '\\p{Han}+', '123');
++---------------------------------------------------------------------------------------------+
+| regexp_replace('这是一段中文 This is a passage in English 1234567', '\p{Han}+', '123') |
++---------------------------------------------------------------------------------------------+
+| 123This is a passage in English 1234567 |
++---------------------------------------------------------------------------------------------+
+```
+
+Вставка данных и тестовые примеры. В этом наборе тестовых примеров мы создаём таблицу для хранения исходных строк, шаблонов и строк замены. Затем вставляем различные тестовые данные и выполняем операции REGEXP_REPLACE над исходными строками с соответствующими шаблонами и строками замены. Наконец, извлекаем и выводим строки после замены.
+
+```sql
+-- Create a table to store test data
+CREATE TABLE test_table_for_regexp_replace (
+ id INT,
+ original_text VARCHAR(500),
+ pattern VARCHAR(100),
+ replacement VARCHAR(100)
+ ) PROPERTIES ("replication_num"="1");
+
+-- Insert test data
+INSERT INTO test_table_for_regexp_replace VALUES
+ (1, 'Hello, World!', ',', '-'),
+ (2, 'apple123', '[0-9]', '*'),
+ (3, 'aabbcc', '(aa|bb|cc)', 'XX'),
+ (4, '123-456-7890', '-', ' '),
+ (5, 'test,data', ',', ';'),
+ (6, 'a1b2c3', '[0-9]', '#'),
+ (7, 'book keeper', 'oo|ee', '**'),
+ (8, 'ababab', '(ab)', 'XY'),
+ (9, 'aabbcc', '(aa|bb|cc)', 'ZZ'),
+ (10, 'apple,banana', ',', ' - ');
+
+-- Perform replacement operations on the inserted data
+SELECT id, regexp_replace(original_text, pattern, replacement) as replaced_text FROM test_table_for_regexp_replace ORDER BY id;
+```
+
+```text
++------+------------------+
+| id | replaced_text |
++------+------------------+
+| 1 | Hello- World! |
+| 2 | apple*** |
+| 3 | XXXXYY |
+| 4 | 123 456 7890 |
+| 5 | test;data |
+| 6 | a#b#c# |
+| 7 | b**k k**per |
+| 8 | XYXYXY |
+| 9 | ZZZZYY |
+| 10 | apple - banana |
++------+------------------+
+```
+
+Замена эмодзи
+
+```sql
+SELECT regexp_replace('🌍 Earth 🍔 Food', '🌍|🍔', '*');
+```
+
+```text
++----------------------------------------------------------+
+| regexp_replace('🌍 Earth 🍔 Food', '🌍|🍔', '*') |
++----------------------------------------------------------+
+| * Earth * Food |
++----------------------------------------------------------+
+```
+
+Если 'str' имеет значение NULL, возвращается NULL
+
+```sql
+mysql> SELECT REGEXP_REPLACE(NULL, ' ', '-');
++--------------------------------+
+| REGEXP_REPLACE(NULL, ' ', '-') |
++--------------------------------+
+| NULL |
++--------------------------------+
+```
+
+Если 'pattern' имеет значение NULL, возвращается NULL
+
+```sql
+mysql> SELECT REGEXP_REPLACE('Hello World', NULL, '-');
++------------------------------------------+
+| REGEXP_REPLACE('Hello World', NULL, '-') |
++------------------------------------------+
+| NULL |
++------------------------------------------+
+```
+
+Если 'repl' имеет значение NULL, возвращается NULL
+
+```sql
+mysql> SELECT REGEXP_REPLACE('Hello World', ' ', NULL);
++------------------------------------------+
+| REGEXP_REPLACE('Hello World', ' ', NULL) |
++------------------------------------------+
+| NULL |
++------------------------------------------+
+```
+
+Если все параметры имеют значение NULL, возвращается NULL
+
+```sql
+mysql> SELECT REGEXP_REPLACE(NULL, NULL, NULL);
++----------------------------------+
+| REGEXP_REPLACE(NULL, NULL, NULL) |
++----------------------------------+
+| NULL |
++----------------------------------+
+```
+
+Если `pattern` не является допустимым регулярным выражением, возникает ошибка.
+
+```sql
+SELECT regexp_replace('a b c', '(b', '<\\1>');
+```
+
+```text
+ERROR 1105 (HY000): errCode = 2, detailMessage = (10.16.10.2)[INVALID_ARGUMENT]Could not compile regexp pattern: (b
+Error: missing ): (b
+
+```
diff --git a/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/string-functions/regexp.md b/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/string-functions/regexp.md
new file mode 100644
index 000000000000..51b4d7cba677
--- /dev/null
+++ b/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/string-functions/regexp.md
@@ -0,0 +1,383 @@
+---
+{
+ "title": "REGEXP",
+ "language": "ru",
+ "description": "~ Выполняет сопоставление строки str с регулярным выражением, возвращая true при совпадении и false в противном случае."
+}
+---
+
+## Описание {#description}
+
+Проверяет строку `<str>` на соответствие регулярному выражению и возвращает true при совпадении и false в противном случае. Шаблон не обязан совпадать со всей строкой; для полного совпадения используйте `^` и `$`. Возвращает NULL, если хотя бы один аргумент равен NULL, и сообщает об ошибке, если шаблон некорректен. Строки обрабатываются в кодировке UTF-8; для сопоставления с категориями символов Unicode используйте классы символов, например `\p{Han}`.
+
+Для обычных шаблонов см. [синтаксис RE2](https://github.com/google/re2/wiki/Syntax).
+
+### Движки сопоставления и переменные сеанса {#matching-engines-and-session-variables}
+
+При обычном сопоставлении с помощью `LIKE` и `REGEXP` может использоваться ускорение Hyperscan. Следующие переменные сеанса управляют переходом на другой движок:
+
+| Переменная сеанса | По умолчанию | Поведение |
+| --- | --- | --- |
+| `enable_hyperscan_fallback` | `true` | Поддерживается в серии Doris 4.1 начиная с 4.1.5. Позволяет пути выполнения, на котором действительно используется компиляция в Hyperscan, переходить на RE2 при ошибке компиляции или невозможности выделить рабочую память для сопоставления. При false возвращается соответствующая ошибка. На оптимизации простых шаблонов и пути выполнения, напрямую использующие RE2, не влияет. |
+| `enable_extended_regex` | `false` | Разрешает `REGEXP` пробовать движок Boost.Regex, если RE2 отклоняет шаблон, обеспечивая поддержку расширенного синтаксиса, например look-around. Не расширяет синтаксис RE2 и не добавляет поддержку расширенного синтаксиса в `LIKE`, `MATCH_REGEXP` или `MULTI_MATCH_ANY`. |
+
+В серии Doris 4.1 начиная с 4.1.5 настройка `enable_extended_regex=true` применяется как к константным шаблонам, так и к неконстантным шаблонам, считываемым из столбцов. Если путь выполнения Hyperscan использует `enable_hyperscan_fallback=false`, сбой Hyperscan по-прежнему приводит к ошибке; включение `enable_extended_regex` не позволяет обойти эту ошибку.
+
+В [справочнике переменных сеанса](../../../basic-element/session-variables.md#enable_hyperscan_fallback) приведены значения и область действия `enable_hyperscan_fallback`.
+
+Для расширенных шаблонов см. [синтаксис Perl в Boost.Regex](https://www.boost.org/doc/libs/latest/libs/regex/doc/html/boost_regex/syntax/perl_syntax.html). Дополнительные затраты на сопоставление в Boost.Regex возникают только при использовании этого движка. Сложные шаблоны, использующие backtracking, также могут приводить к ошибке `Failed to match regex expression`.
+
+### Ограничение числа повторений {#repetition-limit}
+
+В серии Doris 4.1 начиная с 4.1.5 для регулярного выражения, переданного в Hyperscan, компиляция в Hyperscan пропускается, если форма `{m}`, `{m,}` или `{m,n}` содержит число больше 50. Например, `a{51}`, `a{51,}` и `a{0,51}` вызывают срабатывание этой проверки, а `a{50}` и `a{0,50}` не вызывают. Проверка текста носит консервативный характер, поэтому она может сработать и для таких форм внутри классов символов или комментариев.
+
+| Путь сопоставления | Поведение при срабатывании проверки |
+| --- | --- |
+| Путь Hyperscan для обычных `LIKE` или `REGEXP` | Пытается перейти на другой движок при `enable_hyperscan_fallback=true`; в противном случае возвращает ошибку. Шаблон по-прежнему должен соответствовать синтаксису и ограничениям числа повторений целевого движка. |
+| Построчное сопоставление для `MATCH_REGEXP` и сопоставление по регулярному выражению с использованием инвертированного индекса | Сразу отклоняет шаблон; не использует `enable_hyperscan_fallback`. |
+| Сопоставление с несколькими шаблонами для `MULTI_MATCH_ANY` | Сразу отклоняет шаблон; не использует `enable_hyperscan_fallback`. |
+
+Если проверка срабатывает без перехода на другой движок, сообщение об ошибке содержит:
+
+```text
+Skip hyperscan compilation because bounded repetition exceeds 50
+```
+
+## Синтаксис {#syntax}
+
+```sql
+REGEXP(<str>, <pattern>)
+<str> [NOT] REGEXP <pattern>
+<str> [NOT] RLIKE <pattern>
+```
+
+## Параметры {#parameters}
+
+| Параметр | Описание |
+| -- | -- |
+| `<str>` | Строковый тип. Строка, для которой проверяется соответствие регулярному выражению; это может быть столбец таблицы или строковый литерал.|
+| `<pattern>` | Строковый тип. Шаблон регулярного выражения, используемый для сопоставления со строкой `<str>`. Регулярные выражения позволяют гибко задавать сложные шаблоны поиска, включая классы символов, квантификаторы и якоря.|
+
+## Возвращаемое значение {#return-value}
+
+Функция REGEXP возвращает значение типа BOOLEAN. Если строка `<str>` соответствует шаблону регулярного выражения `<pattern>`, функция возвращает true (в SQL представляется как 1); в противном случае возвращает false (в SQL представляется как 0). Возвращает NULL, если хотя бы один аргумент равен NULL.
+
+В серии Doris 4.1 начиная с 4.1.5 константные пустые шаблоны ведут себя так же, как шаблоны из столбцов: пустой шаблон соответствует любой строке, отличной от NULL, в том числе пустой строке.
+
+**Поведение по умолчанию**:
+
+| Настройка по умолчанию | Поведение |
+| ------------------------------------ | ----------------------------------------------------------------------------------------- |
+| `.` соответствует символу новой строки | `.` по умолчанию может соответствовать `\n` (символу новой строки). |
+| С учётом регистра | Сопоставление выполняется с учётом регистра. |
+| `^`/`$` соответствуют границам всей строки | `^` соответствует только началу всей строки, а `$` соответствует только её концу, а не началу или концу отдельных строк. |
+| Жадные квантификаторы | `*`, `+` и т. д. по умолчанию захватывают как можно больше символов. |
+| UTF-8 | Строки обрабатываются в кодировке UTF-8. |
+
+**Модификаторы шаблона**:
+
+Чтобы изменить поведение по умолчанию, добавьте в начало `pattern` префикс `(?flags)`. Несколько модификаторов можно объединить, например `(?im)`; префикс `-` отключает соответствующий параметр, например `(?-s)`.
+
+В следующей таблице описаны модификаторы для обычного пути Hyperscan/RE2. Если из-за синтаксиса, например look-around, происходит переход на Boost.Regex, интерпретируйте модификаторы согласно синтаксису Boost.Regex; поведение движков может различаться.
+
+| Флаг | Значение |
+| ------- | ---------------------------------------------------------------------------- |
+| `(?i)` | Сопоставление без учёта регистра |
+| `(?-i)` | С учётом регистра (по умолчанию) |
+| `(?s)` | `.` соответствует символу новой строки (включено по умолчанию) |
+| `(?-s)` | `.` **не** соответствует символу новой строки |
+| `(?m)` | Многострочный режим: `^` соответствует началу каждой строки, `$` соответствует концу каждой строки |
+| `(?-m)` | Однострочный режим: `^`/`$` соответствуют границам всей строки (по умолчанию) |
+| `(?U)` | Нежадные квантификаторы: `*`, `+` и т. д. захватывают как можно меньше символов |
+| `(?-U)` | Жадные квантификаторы (по умолчанию): `*`, `+` и т. д. захватывают как можно больше символов |
+
+<a id="examples"></a>
+
+## Пример {#example}
+
+```sql
+CREATE TABLE test ( k1 VARCHAR(255) ) properties("replication_num"="1");
+
+INSERT INTO test (k1) VALUES ('billie eillish'), ('It\'s ok'), ('billie jean'), ('hello world');
+```
+
+
+```sql
+--- Find all data in the k1 column starting with 'billie'
+SELECT k1 FROM test WHERE k1 REGEXP '^billie' ORDER BY k1;
+```
+
+```text
++----------------+
+| k1 |
++----------------+
+| billie eillish |
+| billie jean |
++----------------+
+```
+
+```sql
+--- Find data in the k1 column ending with 'ok':
+SELECT k1 FROM test WHERE k1 REGEXP 'ok$';
+```
+
+```text
++---------+
+| k1 |
++---------+
+| It's ok |
++---------+
+```
+Пример с китайскими иероглифами
+
+```sql
+select regexp('这是一段中文 This is a passage in English 1234567', '\\p{Han}');
+```
+
+```text
++-----------------------------------------------------------------------------+
+| ('这是一段中文 This is a passage in English 1234567' regexp '\p{Han}') |
++-----------------------------------------------------------------------------+
+| 1 |
++-----------------------------------------------------------------------------+
+```
+
+Вставка данных и проверка простого сопоставления строк
+
+```sql
+CREATE TABLE test_regexp (
+ id INT,
+ name VARCHAR(255)
+) PROPERTIES("replication_num"="1");
+
+INSERT INTO test_regexp (id, name) VALUES
+ (1, 'Alice'),
+ (2, 'Bob'),
+ (3, 'Charlie'),
+ (4, 'David');
+
+-- Find all names starting with 'A'
+SELECT id, name FROM test_regexp WHERE name REGEXP '^A';
+```
+
+```text
++------+-------+
+| id | name |
++------+-------+
+| 1 | Alice |
++------+-------+
+```
+
+Проверка сопоставления специальных символов
+
+```sql
+-- Insert names with special characters
+INSERT INTO test_regexp (id, name) VALUES
+ (5, 'Anna-Maria'),
+ (6, 'John_Doe');
+
+-- Find names containing the '-' character
+SELECT id, name FROM test_regexp WHERE name REGEXP '-';
+```
+```text
++------+------------+
+| id | name |
++------+------------+
+| 5 | Anna-Maria |
++------+------------+
+```
+
+Проверка сопоставления по окончанию строки
+```sql
+-- Find names ending with 'e'
+SELECT id, name FROM test_regexp WHERE name REGEXP 'e$' ORDER BY id;
+```
+
+```text
++------+----------+
+| id | name |
++------+----------+
+| 1 | Alice |
+| 3 | Charlie |
+| 6 | John_Doe |
++------+----------+
+```
+
+Проверка с эмодзи
+
+```sql
+SELECT 'Hello' REGEXP '😀';
+```
+
+```text
++-----------------------+
+| 'Hello' REGEXP '😀' |
++-----------------------+
+| 0 |
++-----------------------+
+```
+
+
+Пустой шаблон соответствует любой строке, отличной от NULL, в том числе пустой строке:
+
+```sql
+SELECT REGEXP('abc', ''), REGEXP('', ''), REGEXP(NULL, '');
+```
+
+```text
+1 1 NULL
+```
+
+Если 'str' имеет значение NULL, возвращается NULL
+
+```sql
+SELECT REGEXP(NULL, '^billie');
+```
+
+```text
++-------------------------+
+| REGEXP(NULL, '^billie') |
++-------------------------+
+| NULL |
++-------------------------+
+```
+
+Если 'pattern' имеет значение NULL, возвращается NULL
+
+```sql
+SELECT REGEXP('billie eillish', NULL);
+```
+
+```text
++--------------------------------+
+| REGEXP('billie eillish', NULL) |
++--------------------------------+
+| NULL |
++--------------------------------+
+```
+
+Если все параметры имеют значение NULL, возвращается NULL
+
+```sql
+SELECT REGEXP(NULL, NULL);
+```
+
+```text
++--------------------+
+| REGEXP(NULL, NULL) |
++--------------------+
+| NULL |
++--------------------+
+```
+
+Если `pattern` содержит недопустимое регулярное выражение, возникает ошибка:
+
+```sql
+SELECT REGEXP('Hello, World!', '([a-z');
+```
+
+```text
+ERROR 1105 (HY000): errCode = 2, detailMessage = (10.16.10.2)[INTERNAL_ERROR]Invalid regex expression: ([a-z
+```
+
+Для сложных шаблонов требуется расширенный синтаксис. Обычный переход на RE2 не обеспечивает поддержку look-around:
+
+```sql
+SET enable_hyperscan_fallback = true;
+SET enable_extended_regex = true;
+SELECT REGEXP('foobar', '(?<=foo)bar');
+```
+
+```text
+1
+```
+
+Неконстантные шаблоны также поддерживают расширенный синтаксис (в серии Doris 4.1 начиная с 4.1.5):
+
+```sql
+CREATE TABLE regexp_patterns (
+ id INT,
+ s VARCHAR(32),
+ p VARCHAR(64)
+) DISTRIBUTED BY HASH(id) BUCKETS 1
+PROPERTIES ("replication_num" = "1");
+
+INSERT INTO regexp_patterns VALUES
+ (1, 'foobar', '(?<=foo)bar'),
+ (2, 'fobar', '(?<=foo)bar'),
+ (3, 'foo123bar', 'foo(?=123)'),
+ (4, 'foo124bar', 'foo(?=123)');
+
+SELECT id, REGEXP(s, p) FROM regexp_patterns ORDER BY id;
+```
+
+```text
+1 1
+2 0
+3 1
+4 0
+```
+
+Перед выполнением приведённых ниже примеров с обычным синтаксисом восстановите настройку сеанса:
+
+```sql
+SET enable_extended_regex = false;
+```
+
+Модификаторы шаблона
+
+Сопоставление без учёта регистра: `(?i)` отключает учёт регистра при сопоставлении
+
+```sql
+SELECT REGEXP('Hello World', 'hello') AS case_sensitive, REGEXP('Hello World', '(?i)hello') AS case_insensitive;
+```
+
+```text
++----------------+------------------+
+| case_sensitive | case_insensitive |
++----------------+------------------+
+| 0 | 1 |
++----------------+------------------+
+```
+
+Символ `.` по умолчанию соответствует символу новой строки; используйте `(?-s)`, чтобы `.` не соответствовал символу новой строки
+
+```sql
+SELECT REGEXP('foo\nbar', '^.+$') AS dot_match_nl, REGEXP('foo\nbar', '(?-s)^.+$') AS dot_not_match_nl;
+```
+
+```text
++--------------+------------------+
+| dot_match_nl | dot_not_match_nl |
++--------------+------------------+
+| 1 | 0 |
++--------------+------------------+
+```
+
+Многострочный режим: `(?m)` заставляет `^` и `$` соответствовать началу и концу каждой строки
+
+```sql
+SELECT REGEXP('foo\nbar', '^bar') AS single_line, REGEXP('foo\nbar', '(?m)^bar') AS multi_line;
+```
+
+```text
++-------------+------------+
+| single_line | multi_line |
++-------------+------------+
+| 0 | 1 |
++-------------+------------+
+```
+
+Жадное и нежадное сопоставление: `(?U)` заставляет квантификаторы захватывать как можно меньше символов
+
+```sql
+SELECT REGEXP_EXTRACT('aXbXc', '(a.*X)', 1) AS greedy, REGEXP_EXTRACT('aXbXc', '(?U)(a.*X)', 1) AS non_greedy;
+```
+
+```text
++--------+------------+
+| greedy | non_greedy |
++--------+------------+
+| aXbX | aX |
++--------+------------+
+```
diff --git a/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/string-functions/repeat.md b/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/string-functions/repeat.md
new file mode 100644
index 000000000000..89d44abab7aa
--- /dev/null
+++ b/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/string-functions/repeat.md
@@ -0,0 +1,162 @@
+---
+{
+ "title": "REPEAT",
+ "language": "ru",
+ "description": "Функция REPEAT повторяет указанную строку заданное число раз, создавая новую строку."
+}
+---
+
+## Описание {#description}
+
+Функция REPEAT повторяет указанную строку заданное число раз, создавая новую строку. Эта функция обычно используется для генерации символов заполнения, создания разделителей или генерации тестовых данных.
+
+## Синтаксис {#syntax}
+
+```sql
+REPEAT(<str>, <count>)
+```
+
+## Параметры {#parameters}
+
+| Параметр | Описание |
+| -- | -- |
+| `<str>` | Исходная строка для повторения. Тип: VARCHAR |
+| `<count>` | Число повторений. Должно быть неотрицательным целым числом. Тип: INT |
+
+## Возвращаемое значение {#return-value}
+
+Возвращает значение типа VARCHAR, содержащее строку, повторённую указанное число раз.
+
+Правила повторения:
+- Если count больше 0, возвращается результат повторения строки str count раз
+- Если count равен 0, возвращается пустая строка
+- Если count меньше 0, возвращается пустая строка
+- Если результирующая строка слишком длинная, на неё могут распространяться ограничения длины строки
+
+Особые случаи:
+- Если любой из параметров равен NULL, возвращается NULL
+- Если str является пустой строкой, возвращается пустая строка независимо от count
+- Если count равен 0, возвращается пустая строка
+- Если count отрицательный, возвращается пустая строка
+
+## Примеры {#examples}
+
+1. Простое повторение символа
+```sql
+SELECT REPEAT('a', 3);
+```
+```text
++----------------+
+| REPEAT('a', 3) |
++----------------+
+| aaa |
++----------------+
+```
+
+2. Повторение строки из нескольких символов
+```sql
+SELECT REPEAT('hello', 2);
+```
+```text
++--------------------+
+| REPEAT('hello', 2) |
++--------------------+
+| hellohello |
++--------------------+
+```
+
+3. Нулевое число повторений
+```sql
+SELECT REPEAT('test', 0);
+```
+```text
++-------------------+
+| REPEAT('test', 0) |
++-------------------+
+| |
++-------------------+
+```
+
+4. Отрицательное число повторений
+```sql
+SELECT REPEAT('a', -1);
+```
+```text
++-----------------+
+| REPEAT('a', -1) |
++-----------------+
+| |
++-----------------+
+```
+
+5. Обработка значений NULL
+```sql
+SELECT REPEAT(NULL, 3), REPEAT('a', NULL);
+```
+```text
++------------------+-------------------+
+| REPEAT(NULL, 3) | REPEAT('a', NULL) |
++------------------+-------------------+
+| NULL | NULL |
++------------------+-------------------+
+```
+
+6. Повторение пустой строки
+```sql
+SELECT REPEAT('', 5);
+```
+```text
++----------------+
+| REPEAT('', 5) |
++----------------+
+| |
++----------------+
+```
+
+7. Повторение специальных символов
+```sql
+SELECT REPEAT('-', 10), REPEAT('*', 5);
+```
+```text
++------------------+-----------------+
+| REPEAT('-', 10) | REPEAT('*', 5) |
++------------------+-----------------+
+| ---------- | ***** |
++------------------+-----------------+
+```
+
+8. Повторение символов UTF-8
+```sql
+SELECT REPEAT('ṭṛì', 3), REPEAT('ḍḍu', 2);
+```
+```text
++-------------------+-------------------+
+| REPEAT('ṭṛì', 3) | REPEAT('ḍḍu', 2) |
++-------------------+-------------------+
+| ṭṛìṭṛìṭṛì | ḍḍuḍḍu |
++-------------------+-------------------+
+```
+
+9. Сочетание цифр и символов
+```sql
+SELECT REPEAT('123', 3), REPEAT('@#', 4);
+```
+```text
++-------------------+------------------+
+| REPEAT('123', 3) | REPEAT('@#', 4) |
++-------------------+------------------+
+| 123123123 | @#@#@#@# |
++-------------------+------------------+
+```
+
+10. Повторение символов UTF-8
+```sql
+SELECT REPEAT('ṭṛìṭṛì', 3);
+```
+```text
++--------------------------------------------------+
+| REPEAT('ṭṛìṭṛì', 3) |
++--------------------------------------------------+
+| ṭṛìṭṛìṭṛìṭṛìṭṛìṭṛì |
++--------------------------------------------------+
+```
diff --git a/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/string-functions/replace-empty.md b/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/string-functions/replace-empty.md
new file mode 100644
index 000000000000..2b86b6c43e75
--- /dev/null
+++ b/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/string-functions/replace-empty.md
@@ -0,0 +1,73 @@
+---
+{
+ "title": "REPLACE_EMPTY",
+ "language": "ru",
+ "description": "Функция REPLACE_EMPTY используется для замены части символов в строке другими символами. В отличие от функции REPLACE,"
+}
+---
+
+## Описание {#description}
+
+Функция REPLACE_EMPTY используется для замены части символов в строке другими символами. В отличие от функции [REPLACE](./replace.md), если `old` является пустой строкой, строка `new` вставляется перед каждым символом строки `str` и в конец строки `str`.
+
+Эта функция предназначена главным образом для совместимости с Presto и Trino, и её поведение полностью совпадает с поведением функции `REPLACE()` в Presto и Trino. Поддерживается начиная с версии 2.1.5.
+
+## Синтаксис {#syntax}
+
+```sql
+REPLACE_EMPTY ( <str>, <old>, <new> )
+```
+
+## Параметры {#parameters}
+
+| Параметр | Описание |
+|---------|---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+| `<str>` | Строка, в которой нужно выполнить замену. |
+| `<old>` | Подстрока, которую нужно заменить. Если `<old>` отсутствует в `<str>`, замена не выполняется. Если `<old>` является пустой строкой, строка `<new>` вставляется перед каждым символом строки str. |
+| `<new>` | Новая подстрока для замены `<old>`. |
+
+## Возвращаемое значение {#return-value}
+
+Возвращает новую строку после замены подстроки. Особые случаи:
+
+- Если какой-либо параметр равен NULL, возвращается NULL.
+- Если `<old>` является пустой строкой, возвращается строка, в которой строка `<new>` вставлена перед каждым символом строки `<str>`.
+
+## Примеры {#examples}
+
+
+```sql
+SELECT replace('hello world', 'world', 'universe');
+```
+
+```text
++---------------------------------------------+
+| replace('hello world', 'world', 'universe') |
++---------------------------------------------+
+| hello universe |
++---------------------------------------------+
+```
+
+```sql
+SELECT replace_empty("abc", '', 'xyz');
+```
+
+```text
++---------------------------------+
+| replace_empty('abc', '', 'xyz') |
++---------------------------------+
+| xyzaxyzbxyzcxyz |
++---------------------------------+
+```
+
+```sql
+SELECT replace_empty("", "", "xyz");
+```
+
+```text
++------------------------------+
+| replace_empty('', '', 'xyz') |
++------------------------------+
+| xyz |
++------------------------------+
+```
diff --git a/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/string-functions/replace.md b/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/string-functions/replace.md
new file mode 100644
index 000000000000..b04558fc0202
--- /dev/null
+++ b/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/string-functions/replace.md
@@ -0,0 +1,107 @@
+---
+{
+ "title": "REPLACE",
+ "language": "ru",
+ "description": "Функция REPLACE используется для замены всех вхождений указанной подстроки в строке новой подстрокой."
+}
+---
+
+## Описание {#description}
+
+Функция REPLACE используется для замены всех вхождений указанной подстроки в строке новой подстрокой. Эта функция заменяет все совпадающие вхождения подстроки в строке, выполняя глобальную операцию замены.
+
+**Отличие от функции REPLACE_EMPTY:**
+- `REPLACE()` заменяет указанную подстроку, включая пустые строки
+- `REPLACE_EMPTY()` специально предназначена для замены пустых значений или пустых строк указанным значением
+
+## Синтаксис {#syntax}
+
+```sql
+REPLACE(<str>, <old>, <new>)
+```
+
+## Параметры {#parameters}
+
+| Параметр | Описание |
+|-----------|-------------|
+| `<str>` | Исходная строка, в которой выполняется замена. Тип: VARCHAR |
+| `<old>` | Подстрока, которую нужно заменить. Если она не найдена в str, замена не выполняется. Тип: VARCHAR |
+| `<new>` | Новая подстрока для замены old. Тип: VARCHAR |
+
+## Возвращаемое значение {#return-value}
+
+Возвращает строку типа VARCHAR, полученную в результате замены.
+
+Правила замены:
+- Заменяются все совпадающие подстроки old в строке
+- Замена выполняется с учётом регистра
+- Если old является пустой строкой, возвращается исходная строка (операция не выполняется)
+- Если new является пустой строкой, все совпадающие подстроки old фактически удаляются
+
+Особые случаи:
+- Если любой из параметров равен NULL, возвращается NULL
+- Если str является пустой строкой, возвращается пустая строка
+- Если old является пустой строкой, возвращается исходная строка str (без замены)
+- Если old не найдена в str, возвращается исходная строка str
+
+## Примеры {#examples}
+
+1. Базовая операция замены
+```sql
+SELECT REPLACE('hello world', 'world', 'universe');
+```
+```text
++---------------------------------------------+
+| REPLACE('hello world', 'world', 'universe') |
++---------------------------------------------+
+| hello universe |
++---------------------------------------------+
+```
+
+2. Замена нескольких вхождений
+```sql
+SELECT REPLACE('apple apple apple', 'apple', 'orange');
+```
+```text
++------------------------------------------------+
+| REPLACE('apple apple apple', 'apple', 'orange') |
++------------------------------------------------+
+| orange orange orange |
++------------------------------------------------+
+```
+
+3. Удаление подстроки (замена пустой строкой)
+```sql
+SELECT REPLACE('banana', 'a', '');
+```
+```text
++---------------------------+
+| REPLACE('banana', 'a', '') |
++---------------------------+
+| bnn |
++---------------------------+
+```
+
+4. Обработка значений NULL
+```sql
+SELECT REPLACE(NULL, 'old', 'new'), REPLACE('test', NULL, 'new'), REPLACE('test', 'old', NULL);
+```
+```text
++------------------------------+------------------------------+------------------------------+
+| REPLACE(NULL, 'old', 'new') | REPLACE('test', NULL, 'new') | REPLACE('test', 'old', NULL) |
++------------------------------+------------------------------+------------------------------+
+| NULL | NULL | NULL |
++------------------------------+------------------------------+------------------------------+
+```
+
+5. Замена символов UTF-8
+```sql
+SELECT REPLACE('ṭṛì ḍḍumai test ṭṛì ḍḍumannàri', 'ṭṛì', 'replaced');
+```
+```text
++-----------------------------------------------------------+
+| REPLACE('ṭṛì ḍḍumai test ṭṛì ḍḍumannàri', 'ṭṛì', 'replaced') |
++-----------------------------------------------------------+
+| replaced ḍḍumai test replaced ḍḍumannàri |
++-----------------------------------------------------------+
+```
diff --git a/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/string-functions/reverse.md b/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/string-functions/reverse.md
new file mode 100644
index 000000000000..be9586a9da92
--- /dev/null
+++ b/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/string-functions/reverse.md
@@ -0,0 +1,157 @@
+---
+{
+ "title": "REVERSE",
+ "language": "ru",
+ "description": "Функция REVERSE изменяет порядок входной последовательности на обратный. Для строковых аргументов она возвращает строку с обратным порядком символов;"
+}
+---
+
+## Описание {#description}
+
+Функция REVERSE изменяет порядок входной последовательности на обратный. Для строковых аргументов она возвращает строку с обратным порядком символов; для аргументов в виде массивов она возвращает массив с обратным порядком элементов. Функция выполняет обращение посимвольно и корректно обрабатывает многобайтовые символы UTF-8.
+
+## Синтаксис {#syntax}
+
+```sql
+REVERSE(<seq>)
+```
+
+## Параметры {#parameters}
+
+| Параметр | Описание |
+|---------|----------------|
+| `<seq>` | Строка или массив, порядок которых нужно изменить на обратный. Тип: VARCHAR или ARRAY |
+
+## Возвращаемое значение {#return-value}
+
+Возвращает последовательность в обратном порядке, сохраняя тип входного значения:
+- Строка на входе: возвращает строку типа VARCHAR с обратным порядком символов
+- Массив на входе: возвращает массив типа ARRAY с обратным порядком элементов
+
+Особые случаи:
+- Если параметр равен NULL, возвращает NULL
+- Если строка пустая, возвращает пустую строку
+- Если массив пустой, возвращает пустой массив
+- Строка из одного символа остаётся неизменной после обращения
+
+## Примеры {#examples}
+
+1. Простое обращение строки
+```sql
+SELECT REVERSE('hello');
+```
+```text
++------------------+
+| REVERSE('hello') |
++------------------+
+| olleh |
++------------------+
+```
+
+2. Обращение порядка элементов массива
+```sql
+SELECT REVERSE(['hello', 'world']);
+```
+```text
++-----------------------------+
+| REVERSE(['hello', 'world']) |
++-----------------------------+
+| ["world", "hello"] |
++-----------------------------+
+```
+
+3. Обработка значения NULL
+```sql
+SELECT REVERSE(NULL);
+```
+```text
++---------------+
+| REVERSE(NULL) |
++---------------+
+| NULL |
++---------------+
+```
+
+4. Пустая строка и пустой массив
+```sql
+SELECT REVERSE(''), REVERSE([]);
+```
+```text
++-------------+-------------+
+| REVERSE('') | REVERSE([]) |
++-------------+-------------+
+| | [] |
++-------------+-------------+
+```
+
+5. Строка из одного символа и массив из одного элемента
+```sql
+SELECT REVERSE('A'), REVERSE(['single']);
+```
+```text
++--------------+--------------------+
+| REVERSE('A') | REVERSE(['single']) |
++--------------+--------------------+
+| A | ["single"] |
++--------------+--------------------+
+```
+
+6. Числа и специальные символы
+```sql
+SELECT REVERSE('12345'), REVERSE('!@#$%');
+```
+```text
++------------------+------------------+
+| REVERSE('12345') | REVERSE('!@#$%') |
++------------------+------------------+
+| 54321 | %$#@! |
++------------------+------------------+
+```
+
+7. Многобайтовые символы UTF-8
+```sql
+SELECT REVERSE('ṭṛì ḍḍumai'), REVERSE('ḍḍumannàri');
+```
+```text
++--------------------------------+----------------------------+
+| REVERSE('ṭṛì ḍḍumai') | REVERSE('ḍḍumannàri') |
++--------------------------------+----------------------------+
+| iamuḍḍ ìṛṭ | irànnamuḍḍ |
++--------------------------------+----------------------------+
+```
+
+8. Сочетание разных типов символов
+```sql
+SELECT REVERSE('Hello123'), REVERSE('test@email.com');
+```
+```text
++---------------------+--------------------------+
+| REVERSE('Hello123') | REVERSE('test@email.com') |
++---------------------+--------------------------+
+| 321olleH | moc.liame@tset |
++---------------------+--------------------------+
+```
+
+9. Массив из нескольких элементов
+```sql
+SELECT REVERSE([1, 2, 3, 4, 5]), REVERSE(['a', 'b', 'c']);
+```
+```text
++---------------------------+------------------------+
+| REVERSE([1, 2, 3, 4, 5]) | REVERSE(['a', 'b', 'c']) |
++---------------------------+------------------------+
+| [5, 4, 3, 2, 1] | ["c", "b", "a"] |
++---------------------------+------------------------+
+```
+
+10. Проверка палиндрома
+```sql
+SELECT REVERSE('level'), REVERSE('12321');
+```
+```text
++------------------+-------------------+
+| REVERSE('level') | REVERSE('12321') |
++------------------+-------------------+
+| level | 12321 |
++------------------+-------------------+
+```
diff --git a/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/string-functions/rpad.md b/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/string-functions/rpad.md
new file mode 100644
index 000000000000..f29b498b6231
--- /dev/null
+++ b/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/string-functions/rpad.md
@@ -0,0 +1,164 @@
+---
+{
+ "title": "RPAD",
+ "language": "ru",
+ "description": "Функция RPAD (Right Padding) дополняет строку справа указанными символами до заданной длины."
+}
+---
+
+## Описание {#description}
+
+Функция RPAD (Right Padding) дополняет строку справа указанными символами до заданной длины. Если заданная длина меньше длины исходной строки, строка усекается. Эта функция рассчитывает длину в символах, а не в байтах.
+
+## Синтаксис {#syntax}
+
+```sql
+RPAD(<str>, <len>, <pad>)
+```
+
+## Параметры {#parameters}
+
+| Параметр | Описание |
+|---------|----------------------------|
+| `<str>` | Исходная строка, которую нужно дополнить. Тип: VARCHAR |
+| `<len>` | Заданная длина в символах (не в байтах). Тип: INT |
+| `<pad>` | Строка, используемая для дополнения. Тип: VARCHAR |
+
+## Возвращаемое значение {#return-value}
+
+Возвращает значение типа VARCHAR, представляющее дополненную или усечённую строку.
+
+Правила дополнения:
+- Если len > длины исходной строки: строка pad повторно добавляется справа, пока общая длина не достигнет len
+- Если len = длине исходной строки: возвращается исходная строка
+- Если len < длины исходной строки: строка усекается, возвращаются только первые len символов
+- Строка pad используется циклически; при необходимости берётся только часть её символов
+- Длина рассчитывается в символах, поддерживаются многобайтовые символы UTF-8
+
+Особые случаи:
+- Если любой из параметров равен NULL, возвращается NULL
+- Если pad — пустая строка и len > длины str, возвращается пустая строка
+- Если len равен 0, возвращается пустая строка
+- Если len отрицателен, возвращается NULL
+
+## Примеры {#examples}
+
+1. Простое дополнение справа
+```sql
+SELECT RPAD('hi', 5, 'xy'), RPAD('hello', 8, '*');
+```
+```text
++---------------------+-----------------------+
+| RPAD('hi', 5, 'xy') | RPAD('hello', 8, '*') |
++---------------------+-----------------------+
+| hixyx | hello*** |
++---------------------+-----------------------+
+```
+
+2. Усечение строки
+```sql
+SELECT RPAD('hello', 1, ''), RPAD('hello world', 5, 'x');
+```
+```text
++----------------------+------------------------------+
+| RPAD('hello', 1, '') | RPAD('hello world', 5, 'x') |
++----------------------+------------------------------+
+| h | hello |
++----------------------+------------------------------+
+```
+
+3. Обработка значений NULL
+```sql
+SELECT RPAD(NULL, 5, 'x'), RPAD('hi', NULL, 'x'), RPAD('hi', 5, NULL);
+```
+```text
++---------------------+------------------------+----------------------+
+| RPAD(NULL, 5, 'x') | RPAD('hi', NULL, 'x') | RPAD('hi', 5, NULL) |
++---------------------+------------------------+----------------------+
+| NULL | NULL | NULL |
++---------------------+------------------------+----------------------+
+```
+
+4. Пустая строка и нулевая длина
+```sql
+SELECT RPAD('', 0, ''), RPAD('hi', 0, 'x'), RPAD('', 5, '*');
+```
+```text
++-----------------+-------------------+--------------------+
+| RPAD('', 0, '') | RPAD('hi', 0, 'x') | RPAD('', 5, '*') |
++-----------------+-------------------+--------------------+
+| | | ***** |
++-----------------+-------------------+--------------------+
+```
+
+5. Пустая строка дополнения
+```sql
+SELECT RPAD('hello', 10, ''), RPAD('hi', 2, '');
+```
+```text
++-----------------------+-------------------+
+| RPAD('hello', 10, '') | RPAD('hi', 2, '') |
++-----------------------+-------------------+
+| | hi |
++-----------------------+-------------------+
+```
+
+6. Длинная строка дополнения и циклическое повторение
+```sql
+SELECT RPAD('hello', 10, 'world'), RPAD('X', 7, 'ABC');
+```
+```text
++----------------------------+----------------------+
+| RPAD('hello', 10, 'world') | RPAD('X', 7, 'ABC') |
++----------------------------+----------------------+
+| helloworld | XABCABC |
++----------------------------+----------------------+
+```
+
+7. Дополнение многобайтовыми символами UTF-8
+```sql
+SELECT RPAD('hello', 10, 'ṭṛì'), RPAD('ḍḍumai', 3, 'x');
+```
+```text
++---------------------------+--------------------------+
+| RPAD('hello', 10, 'ṭṛì') | RPAD('ḍḍumai', 3, 'x') |
++---------------------------+--------------------------+
+| helloṭṛìṭṛ | ḍḍu |
++---------------------------+--------------------------+
+```
+
+8. Форматирование строк с числами
+```sql
+SELECT RPAD('$99', 8, '.'), RPAD('Item1', 10, ' ');
+```
+```text
++---------------------+------------------------+
+| RPAD('$99', 8, '.') | RPAD('Item1', 10, ' ') |
++---------------------+------------------------+
+| $99..... | Item1 |
++---------------------+------------------------+
+```
+
+9. Выравнивание столбцов таблицы
+```sql
+SELECT RPAD('Name', 15, ' '), RPAD('Price', 10, ' ');
+```
+```text
++------------------------+------------------------+
+| RPAD('Name', 15, ' ') | RPAD('Price', 10, ' ') |
++------------------------+------------------------+
+| Name | Price |
++------------------------+------------------------+
+```
+
+10. Обработка отрицательной длины
+```sql
+SELECT RPAD('hello', -1, 'x'), RPAD('test', -5, '*');
+```
+```text
++------------------------+------------------------+
+| RPAD('hello', -1, 'x') | RPAD('test', -5, '*') |
++------------------------+------------------------+
+| NULL | NULL |
++------------------------+------------------------+
+```
diff --git a/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/string-functions/rtrim-in.md b/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/string-functions/rtrim-in.md
new file mode 100644
index 000000000000..5b5522b72273
--- /dev/null
+++ b/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/string-functions/rtrim-in.md
@@ -0,0 +1,124 @@
+---
+{
+ "title": "RTRIM_IN",
+ "language": "ru",
+ "description": "Функция RTRIMIN удаляет заданные символы с правого края строки. Если набор символов не указан,"
+}
+---
+
+## Описание {#description}
+
+Функция RTRIM_IN удаляет заданные символы с правого края строки. Если набор символов не указан, по умолчанию удаляются пробелы в конце строки. Если набор символов указан, с правого края удаляются все символы, входящие в этот набор (независимо от их порядка в наборе).
+
+Ключевая особенность RTRIM_IN заключается в том, что она удаляет любое сочетание символов из заданного набора, тогда как функция RTRIM удаляет символы на основе точного совпадения строк.
+
+## Синтаксис {#syntax}
+
+```sql
+RTRIM_IN(<str>[, <rhs>])
+```
+
+## Параметры {#parameters}
+| Параметр | Описание |
+| --------- | ---------------------------------------------------------------------- |
+| `<str>` | Обрабатываемая строка. Тип: VARCHAR |
+| `<rhs>` | Необязательный параметр: набор символов для удаления. Тип: VARCHAR |
+
+## Возвращаемое значение {#return-value}
+
+Возвращает значение типа VARCHAR, представляющее обработанную строку.
+
+Особые случаи:
+- Если str имеет значение NULL, возвращает NULL
+- Если rhs не указан, удаляет все пробелы в конце строки
+- Если rhs указан, удаляет с правого края все символы, входящие в rhs, до первого символа, не входящего в rhs
+
+## Примеры {#examples}
+
+1. Удаление пробелов в конце строки
+```sql
+SELECT rtrim_in('ab d ') str;
+```
+```text
++------+
+| str |
++------+
+| ab d |
++------+
+```
+
+2. Удаление символов из заданного набора
+```sql
+SELECT rtrim_in('ababccaab', 'ab') str;
+```
+```text
++---------+
+| str |
++---------+
+| ababcc |
++---------+
+```
+
+3. Сравнение с функцией RTRIM
+```sql
+SELECT rtrim_in('ababccaab', 'ab'), rtrim('ababccaab', 'ab');
+```
+```text
++-----------------------------+--------------------------+
+| rtrim_in('ababccaab', 'ab') | rtrim('ababccaab', 'ab') |
++-----------------------------+--------------------------+
+| ababcc | ababcca |
++-----------------------------+--------------------------+
+```
+
+4. Порядок символов в наборе не имеет значения
+```sql
+SELECT rtrim_in('Helloabc', 'cba');
+```
+```text
++-----------------------------+
+| rtrim_in('Helloabc', 'cba') |
++-----------------------------+
+| Hello |
++-----------------------------+
+```
+
+5. Поддержка символов UTF-8
+```sql
+SELECT rtrim_in('ṭṛì ḍḍumai+++', '+');
+```
+```text
++------------------------------------+
+| rtrim_in('ṭṛì ḍḍumai+++', '+') |
++------------------------------------+
+| ṭṛì ḍḍumai |
++------------------------------------+
+```
+
+6. Обработка значения NULL
+```sql
+SELECT rtrim_in(NULL, 'abc');
+```
+```text
++------------------------+
+| rtrim_in(NULL, 'abc') |
++------------------------+
+| NULL |
++------------------------+
+```
+
+7. Обработка пустых строк
+```sql
+SELECT rtrim_in('', 'abc'), rtrim_in('abc', '');
+```
+```text
++---------------------+---------------------+
+| rtrim_in('', 'abc') | rtrim_in('abc', '') |
++---------------------+---------------------+
+| | abc |
++---------------------+---------------------+
+```
+
+### Ключевые слова {#keywords}
+
+ RTRIM_IN, RTRIM
diff --git a/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/string-functions/rtrim.md b/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/string-functions/rtrim.md
new file mode 100644
index 000000000000..ab86685f67ce
--- /dev/null
+++ b/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/string-functions/rtrim.md
@@ -0,0 +1,147 @@
+---
+{
+ "title": "RTRIM",
+ "language": "ru",
+ "description": "Функция RTRIM используется для удаления подряд идущих пробелов или указанных строк с конца строки."
+}
+---
+
+## Описание {#description}
+
+Функция RTRIM используется для удаления подряд идущих пробелов или указанных строк с конца строки. Если второй параметр не указан, удаляются завершающие пробелы; если указан, функция удаляет указанную строку целиком с правого края.
+
+## Синтаксис {#syntax}
+
+```sql
+RTRIM(<str>[, <rhs>])
+```
+
+## Параметры {#parameters}
+
+| Параметр | Описание |
+| --------- | ----------- |
+| `<str>` | Обрабатываемая строка. Тип: VARCHAR |
+| `<rhs>` | Необязательный параметр: символы, которые нужно удалить с конца строки. Тип: VARCHAR |
+
+## Возвращаемое значение {#return-value}
+
+Возвращает значение типа VARCHAR.
+
+Особые случаи:
+- Если какой-либо параметр равен NULL, возвращается NULL
+- Если rhs не указан, удаляются завершающие пробелы
+- Если rhs указан, строка rhs удаляется целиком (а не посимвольно)
+
+## Примеры {#examples}
+
+1. Удаление завершающих пробелов
+```sql
+SELECT rtrim('ab d ') str;
+```
+```text
++------+
+| str |
++------+
+| ab d |
++------+
+```
+
+2. Удаление указанной строки с конца
+```sql
+SELECT rtrim('ababccaab', 'ab') str;
+```
+```text
++---------+
+| str |
++---------+
+| ababcca |
++---------+
+```
+
+3. По умолчанию удаляются только пробелы ASCII: `RTRIM` **не** удаляет символы табуляции (`\t`) или перевода строки (`\n`) без второго аргумента. Сравните `LENGTH` до и после: удаляется только один завершающий пробел ASCII; `\t\n` сохраняются.
+```sql
+SELECT LENGTH('hello world \t\n '), LENGTH(RTRIM('hello world \t\n '));
+```
+```text
++------------------------------+-------------------------------------+
+| LENGTH('hello world \t\n ') | LENGTH(RTRIM('hello world \t\n ')) |
++------------------------------+-------------------------------------+
+| 16 | 15 |
++------------------------------+-------------------------------------+
+```
+
+4. Поддержка символов UTF-8
+```sql
+SELECT rtrim('ṭṛì ḍḍumai ');
+```
+```text
++---------------------------+
+| rtrim('ṭṛì ḍḍumai ') |
++---------------------------+
+| ṭṛì ḍḍumai |
++---------------------------+
+```
+
+5. Если совпадающего суффикса нет, возвращается исходная строка
+```sql
+SELECT rtrim('Hello World', 'xyz');
+```
+```text
++---------------------------------+
+| rtrim('Hello World', 'xyz') |
++---------------------------------+
+| Hello World |
++---------------------------------+
+```
+
+6. Обработка значений NULL
+```sql
+SELECT rtrim(NULL), rtrim('Hello', NULL);
+```
+```text
++-------------+------------------------+
+| rtrim(NULL) | rtrim('Hello', NULL) |
++-------------+------------------------+
+| NULL | NULL |
++-------------+------------------------+
+```
+
+7. Обработка пустой строки
+```sql
+SELECT rtrim(''), rtrim('abc', '');
+```
+```text
++-----------+-------------------+
+| rtrim('') | rtrim('abc', '') |
++-----------+-------------------+
+| | abc |
++-----------+-------------------+
+```
+
+8. Удаление повторяющегося шаблона с конца строки
+```sql
+SELECT rtrim('abcabcabc', 'abc');
+```
+```text
++-------------------------------+
+| rtrim('abcabcabc', 'abc') |
++-------------------------------+
+| |
++-------------------------------+
+```
+
+9. Несколько вхождений: удаляется только совпадение в конце строки
+```sql
+SELECT rtrim('HelloHelloWorld', 'Hello');
+```
+```text
++---------------------------------------+
+| rtrim('HelloHelloWorld', 'Hello') |
++---------------------------------------+
+| HelloHelloWorld |
++---------------------------------------+
+```
+
+### Ключевые слова {#keywords}
+
+ RTRIM
diff --git a/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/string-functions/soundex.md b/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/string-functions/soundex.md
new file mode 100644
index 000000000000..9cacb681da88
--- /dev/null
+++ b/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/string-functions/soundex.md
@@ -0,0 +1,154 @@
+---
+{
+ "title": "SOUNDEX",
+ "language": "ru",
+ "description": "Функция SOUNDEX вычисляет код Soundex для строки."
+}
+---
+
+## Описание {#description}
+
+Функция SOUNDEX вычисляет [код Soundex](https://en.wikipedia.org/wiki/Soundex) для строки. Soundex представляет собой фонетический алгоритм, который преобразует английские слова в коды, отражающие их произношение, поэтому слова с похожим произношением получают одинаковый код.
+
+Правило кодирования: возвращается код из 4 символов, состоящий из одной прописной буквы и трёх цифр (например, S530).
+
+## Синтаксис {#syntax}
+
+```sql
+SOUNDEX(<expr>)
+```
+
+## Параметры {#parameters}
+
+| Параметр | Описание |
+| -------- | ----------------------------------------- |
+| `<expr>` | Строка, для которой вычисляется код Soundex (поддерживаются только символы ASCII). Тип: VARCHAR |
+
+## Возвращаемое значение {#return-value}
+
+Возвращает значение типа VARCHAR(4), представляющее код Soundex для строки.
+
+Особые случаи:
+- Если аргумент равен NULL, возвращается NULL
+- Если строка пуста или не содержит букв, возвращается пустая строка
+- Обрабатываются только буквы ASCII, остальные символы игнорируются
+- Символы вне ASCII вызывают ошибку функции
+
+## Примеры {#examples}
+
+1. Базовое использование: кодирование слова
+```sql
+SELECT soundex('Doris');
+```
+```text
++------------------+
+| soundex('Doris') |
++------------------+
+| D620 |
++------------------+
+```
+
+2. Слова с похожим произношением получают одинаковый код
+```sql
+SELECT soundex('Smith'), soundex('Smyth');
+```
+```text
++------------------+------------------+
+| soundex('Smith') | soundex('Smyth') |
++------------------+------------------+
+| S530 | S530 |
++------------------+------------------+
+```
+
+3. Обработка пустой строки
+```sql
+SELECT soundex('');
+```
+```text
++-------------+
+| soundex('') |
++-------------+
+| |
++-------------+
+```
+
+4. Обработка значения NULL
+
+```sql
+SELECT soundex(NULL);
+```
+
+```text
++---------------+
+| soundex(NULL) |
++---------------+
+| NULL |
++---------------+
+```
+
+5. Для пустой строки возвращается пустая строка
+
+```sql
+SELECT soundex('');
+```
+
+```text
++-------------+
+| soundex('') |
++-------------+
+| |
++-------------+
+```
+
+6. Для строки, содержащей только небуквенные символы, возвращается пустая строка
+
+```sql
+SELECT soundex('123@*%');
+```
+
+```text
++-------------------+
+| soundex('123@*%') |
++-------------------+
+| |
++-------------------+
+```
+
+7. Игнорирование небуквенных символов
+
+```sql
+SELECT soundex('R@b-e123rt'), soundex('Robert');
+```
+
+```text
++-----------------------+-------------------+
+| soundex('R@b-e123rt') | soundex('Robert') |
++-----------------------+-------------------+
+| R163 | R163 |
++-----------------------+-------------------+
+```
+
+9. Пример ошибки для строки, содержащей только символы вне ASCII
+
+```sql
+SELECT soundex('你好');
+```
+```text
+ERROR 1105 (HY000): errCode = 2, detailMessage = Not Supported: Not Supported: soundex only supports ASCII, but got: 你
+```
+
+```sql
+SELECT soundex('Apache Doris 你好');
+```
+
+```text
++--------------------------------+
+| soundex('Apache Doris 你好') |
++--------------------------------+
+| A123 |
++--------------------------------+
+```
+
+### Ключевые слова {#keywords}
+
+ SOUNDEX
diff --git a/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/string-functions/space.md b/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/string-functions/space.md
new file mode 100644
index 000000000000..28d59b7293c3
--- /dev/null
+++ b/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/string-functions/space.md
@@ -0,0 +1,84 @@
+---
+{
+ "title": "SPACE",
+ "language": "ru",
+ "description": "Создаёт строку, состоящую из заданного количества пробелов."
+}
+---
+
+## Описание {#description}
+
+Создаёт строку, состоящую из заданного количества пробелов.
+
+## Синтаксис {#syntax}
+
+```sql
+SPACE ( <len> )
+```
+
+## Параметры {#parameters}
+
+| Параметр | Описание |
+|-----------|----------------------------------|
+| `<len>` | Количество пробелов для создания |
+
+## Возвращаемое значение {#return-value}
+
+Возвращает строку, состоящую из заданного количества пробелов. Особые случаи:
+
+- Если какой-либо параметр равен NULL, возвращается NULL.
+- Если `<len>` меньше 0, возвращается пустая строка.
+
+## Примеры {#examples}
+
+1. Создание заданного количества пробелов
+```sql
+SELECT space(5);
+```
+```text
++----------+
+| space(5) |
++----------+
+| |
++----------+
+```
+
+2. Обработка нулевого или отрицательного количества пробелов
+```sql
+SELECT space(0), space(-5);
+```
+```text
++----------+-----------+
+| space(0) | space(-5) |
++----------+-----------+
+| | |
++----------+-----------+
+```
+
+3. Обработка значения NULL
+```sql
+SELECT space(NULL);
+```
+```text
++-------------+
+| space(NULL) |
++-------------+
+| NULL |
++-------------+
+```
+
+4. Использование с другими функциями
+```sql
+SELECT CONCAT('Hello', space(3), 'World');
+```
+```text
++------------------------------------+
+| concat('Hello', space(3), 'World') |
++------------------------------------+
+| Hello World |
++------------------------------------+
+```
+
+### Ключевые слова {#keywords}
+
+ SPACE
diff --git a/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/string-functions/split-by-regexp.md b/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/string-functions/split-by-regexp.md
new file mode 100644
index 000000000000..303cd2000381
--- /dev/null
+++ b/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/string-functions/split-by-regexp.md
@@ -0,0 +1,171 @@
+---
+{
+ "title": "SPLIT_BY_REGEXP/REGEXP_SPLIT_TO_ARRAY",
+ "language": "ru",
+ "description": "Функция SPLIT_BY_REGEXP разбивает строку на массив строк по заданному шаблону регулярного выражения. В отличие от SPLITBYSTRING,"
+}
+---
+
+## Описание {#description}
+
+Функция SPLIT_BY_REGEXP разбивает строку на массив строк по заданному шаблону регулярного выражения. В отличие от SPLIT_BY_STRING, эта функция поддерживает сопоставление со сложными регулярными выражениями, позволяя гибко задавать правила разбиения. При необходимости можно ограничить максимальное количество разбиений, что полезно при обработке структурированного текста, очистке данных и сопоставлении с шаблоном.
+
+## Синтаксис {#syntax}
+
+```sql
+SPLIT_BY_REGEXP(<str>, <pattern> [, <max_limit>])
+```
+
+## Параметры {#parameters}
+
+| Параметр | Описание |
+|-----------|-------------|
+| `<str>` | Исходная строка для разбиения. Тип: VARCHAR |
+| `<pattern>` | Шаблон регулярного выражения, используемый в качестве разделителя. Тип: VARCHAR |
+| `<max_limit>` | Необязательный параметр, ограничивающий максимальное количество элементов в возвращаемом массиве. Тип: INT |
+
+## Возвращаемое значение {#return-value}
+
+Возвращает значение типа ARRAY<VARCHAR>, представляющее собой массив строк, полученный разбиением по регулярному выражению.
+
+Правила разбиения:
+
+- Точки разбиения определяются по совпадениям с шаблоном регулярного выражения
+- Поддерживается стандартный синтаксис регулярных выражений
+- Если шаблон представляет собой пустую строку, строка разбивается на отдельные символы
+- Если совпадений с шаблоном нет, возвращается массив из одного элемента, содержащего исходную строку
+- max_limit ограничивает максимальную длину результирующего массива
+
+Особые случаи:
+
+- Если любой из параметров равен NULL, возвращается NULL
+- Если строка пуста, возвращается массив из одного элемента, содержащего пустую строку
+- Если регулярное выражение представляет собой пустую строку, выполняется разбиение по символам
+- Если max_limit равен 0 или отрицателен, ограничение не применяется
+- Последовательные совпадения создают элементы с пустыми строками
+
+## Примеры {#examples}
+
+1. Разбиение по символам с пустым шаблоном
+```sql
+SELECT SPLIT_BY_REGEXP('abcde', '');
+```
... 7997 lines suppressed ...
---------------------------------------------------------------------
To unsubscribe, e-mail: commits-unsubscribe@doris.apache.org
For additional commands, e-mail: commits-help@doris.apache.org