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:33:09 UTC
(doris-website) branch master updated: [i18n](ru) Translate 100 documentation pages (T09 20261022T103416Z-011) (#4447)
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 92de2eb82ef6 [i18n](ru) Translate 100 documentation pages (T09 20261022T103416Z-011) (#4447)
92de2eb82ef6 is described below
commit 92de2eb82ef6711a238d6a86ec1f5b0e9688ebf6
Author: Mingyu Chen (Rayner) <mo...@gmail.com>
AuthorDate: Fri Oct 23 05:33:02 2026 +0100
[i18n](ru) Translate 100 documentation pages (T09 20261022T103416Z-011) (#4447)
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: 91/100 generated pages passed on the first attempt; 0
pages copied across versions; 109 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/array-functions/array-intersect.md`
| Translate | 1 | Local gates passed |
|
`docs/sql-manual/sql-functions/scalar-functions/array-functions/array-join.md`
| Translate | 2 | Local gates passed |
|
`docs/sql-manual/sql-functions/scalar-functions/array-functions/array-last-index.md`
| Translate | 2 | Local gates passed |
|
`docs/sql-manual/sql-functions/scalar-functions/array-functions/array-last.md`
| Translate | 2 | Local gates passed |
|
`docs/sql-manual/sql-functions/scalar-functions/array-functions/array-map.md`
| Translate | 2 | Local gates passed |
|
`docs/sql-manual/sql-functions/scalar-functions/array-functions/array-match-all.md`
| Translate | 2 | Local gates passed |
|
`docs/sql-manual/sql-functions/scalar-functions/array-functions/array-match-any.md`
| Translate | 2 | Local gates passed |
|
`docs/sql-manual/sql-functions/scalar-functions/array-functions/array-max.md`
| Translate | 2 | Local gates passed |
|
`docs/sql-manual/sql-functions/scalar-functions/array-functions/array-min.md`
| Translate | 2 | Local gates passed |
|
`docs/sql-manual/sql-functions/scalar-functions/array-functions/array-popback.md`
| Translate | 1 | Local gates passed |
|
`docs/sql-manual/sql-functions/scalar-functions/array-functions/array-popfront.md`
| Translate | 1 | Local gates passed |
|
`docs/sql-manual/sql-functions/scalar-functions/array-functions/array-position.md`
| Translate | 1 | Local gates passed |
|
`docs/sql-manual/sql-functions/scalar-functions/array-functions/array-product.md`
| Translate | 1 | Local gates passed |
|
`docs/sql-manual/sql-functions/scalar-functions/array-functions/array-pushback.md`
| Translate | 1 | Local gates passed |
|
`docs/sql-manual/sql-functions/scalar-functions/array-functions/array-pushfront.md`
| Translate | 1 | Local gates passed |
|
`docs/sql-manual/sql-functions/scalar-functions/array-functions/array-range.md`
| Translate | 1 | Local gates passed |
|
`docs/sql-manual/sql-functions/scalar-functions/array-functions/array-remove.md`
| Translate | 1 | Local gates passed |
|
`docs/sql-manual/sql-functions/scalar-functions/array-functions/array-repeat.md`
| Translate | 1 | Local gates passed |
|
`docs/sql-manual/sql-functions/scalar-functions/array-functions/array-reverse-sort.md`
| Translate | 1 | Local gates passed |
|
`docs/sql-manual/sql-functions/scalar-functions/array-functions/array-reverse-split.md`
| Translate | 1 | Local gates passed |
|
`docs/sql-manual/sql-functions/scalar-functions/array-functions/array-shuffle.md`
| Translate | 1 | Local gates passed |
|
`docs/sql-manual/sql-functions/scalar-functions/array-functions/array-size.md`
| Translate | 1 | Local gates passed |
|
`docs/sql-manual/sql-functions/scalar-functions/array-functions/array-slice.md`
| Translate | 1 | Local gates passed |
|
`docs/sql-manual/sql-functions/scalar-functions/array-functions/array-sort.md`
| Translate | 1 | Local gates passed |
|
`docs/sql-manual/sql-functions/scalar-functions/array-functions/array-sortby.md`
| Translate | 1 | Local gates passed |
|
`docs/sql-manual/sql-functions/scalar-functions/array-functions/array-split.md`
| Translate | 1 | Local gates passed |
|
`docs/sql-manual/sql-functions/scalar-functions/array-functions/array-sum.md`
| Translate | 1 | Local gates passed |
|
`docs/sql-manual/sql-functions/scalar-functions/array-functions/array-union.md`
| Translate | 1 | Local gates passed |
|
`docs/sql-manual/sql-functions/scalar-functions/array-functions/array-with-constant.md`
| Translate | 1 | Local gates passed |
|
`docs/sql-manual/sql-functions/scalar-functions/array-functions/array-zip.md`
| Translate | 1 | Local gates passed |
|
`docs/sql-manual/sql-functions/scalar-functions/array-functions/array.md`
| Translate | 2 | Local gates passed |
|
`docs/sql-manual/sql-functions/scalar-functions/array-functions/arrays-overlap.md`
| Translate | 1 | Local gates passed |
|
`docs/sql-manual/sql-functions/scalar-functions/array-functions/countequal.md`
| Translate | 1 | Local gates passed |
|
`docs/sql-manual/sql-functions/scalar-functions/array-functions/trim-array.md`
| Translate | 1 | Local gates passed |
|
`docs/sql-manual/sql-functions/scalar-functions/binary-functions/from-base64-binary.md`
| Translate | 1 | Local gates passed |
|
`docs/sql-manual/sql-functions/scalar-functions/binary-functions/from_hex.md`
| Translate | 1 | Local gates passed |
|
`docs/sql-manual/sql-functions/scalar-functions/binary-functions/sub-binary.md`
| Translate | 1 | Local gates passed |
|
`docs/sql-manual/sql-functions/scalar-functions/binary-functions/to-base64-binary.md`
| Translate | 1 | Local gates passed |
|
`docs/sql-manual/sql-functions/scalar-functions/binary-functions/to_hex.md`
| Translate | 1 | Local gates passed |
|
`docs/sql-manual/sql-functions/scalar-functions/bitmap-functions/bitmap-and-count.md`
| Translate | 1 | Local gates passed |
|
`docs/sql-manual/sql-functions/scalar-functions/bitmap-functions/bitmap-and-not-count.md`
| Translate | 1 | Local gates passed |
|
`docs/sql-manual/sql-functions/scalar-functions/bitmap-functions/bitmap-and-not.md`
| Translate | 1 | Local gates passed |
|
`docs/sql-manual/sql-functions/scalar-functions/bitmap-functions/bitmap-and.md`
| Translate | 1 | Local gates passed |
|
`docs/sql-manual/sql-functions/scalar-functions/bitmap-functions/bitmap-contains.md`
| Translate | 1 | Local gates passed |
|
`docs/sql-manual/sql-functions/scalar-functions/bitmap-functions/bitmap-count.md`
| Translate | 1 | Local gates passed |
|
`docs/sql-manual/sql-functions/scalar-functions/bitmap-functions/bitmap-empty.md`
| Translate | 1 | Local gates passed |
|
`docs/sql-manual/sql-functions/scalar-functions/bitmap-functions/bitmap-from-array.md`
| Translate | 1 | Local gates passed |
|
`docs/sql-manual/sql-functions/scalar-functions/bitmap-functions/bitmap-from-base64.md`
| Translate | 1 | Local gates passed |
|
`docs/sql-manual/sql-functions/scalar-functions/bitmap-functions/bitmap-from-string.md`
| Translate | 1 | Local gates passed |
|
`docs/sql-manual/sql-functions/scalar-functions/bitmap-functions/bitmap-has-all.md`
| Translate | 1 | Local gates passed |
|
`docs/sql-manual/sql-functions/scalar-functions/bitmap-functions/bitmap-has-any.md`
| Translate | 1 | Local gates passed |
|
`docs/sql-manual/sql-functions/scalar-functions/bitmap-functions/bitmap-hash.md`
| Translate | 1 | Local gates passed |
|
`docs/sql-manual/sql-functions/scalar-functions/bitmap-functions/bitmap-hash64.md`
| Translate | 1 | Local gates passed |
|
`docs/sql-manual/sql-functions/scalar-functions/bitmap-functions/bitmap-max.md`
| Translate | 1 | Local gates passed |
|
`docs/sql-manual/sql-functions/scalar-functions/bitmap-functions/bitmap-min.md`
| Translate | 1 | Local gates passed |
|
`docs/sql-manual/sql-functions/scalar-functions/bitmap-functions/bitmap-not.md`
| Translate | 1 | Local gates passed |
|
`docs/sql-manual/sql-functions/scalar-functions/bitmap-functions/bitmap-or-count.md`
| Translate | 1 | Local gates passed |
|
`docs/sql-manual/sql-functions/scalar-functions/bitmap-functions/bitmap-or.md`
| Translate | 1 | Local gates passed |
|
`docs/sql-manual/sql-functions/scalar-functions/bitmap-functions/bitmap-remove.md`
| Translate | 1 | Local gates passed |
|
`docs/sql-manual/sql-functions/scalar-functions/bitmap-functions/bitmap-subset-in-range.md`
| Translate | 1 | Local gates passed |
|
`docs/sql-manual/sql-functions/scalar-functions/bitmap-functions/bitmap-subset-limit.md`
| Translate | 1 | Local gates passed |
|
`docs/sql-manual/sql-functions/scalar-functions/bitmap-functions/bitmap-to-array.md`
| Translate | 1 | Local gates passed |
|
`docs/sql-manual/sql-functions/scalar-functions/bitmap-functions/bitmap-to-base64.md`
| Translate | 1 | Local gates passed |
|
`docs/sql-manual/sql-functions/scalar-functions/bitmap-functions/bitmap-to-string.md`
| Translate | 1 | Local gates passed |
|
`docs/sql-manual/sql-functions/scalar-functions/bitmap-functions/bitmap-xor-count.md`
| Translate | 1 | Local gates passed |
|
`docs/sql-manual/sql-functions/scalar-functions/bitmap-functions/bitmap-xor.md`
| Translate | 1 | Local gates passed |
|
`docs/sql-manual/sql-functions/scalar-functions/bitmap-functions/sub-bitmap.md`
| Translate | 1 | Local gates passed |
|
`docs/sql-manual/sql-functions/scalar-functions/bitmap-functions/to-bitmap.md`
| Translate | 1 | Local gates passed |
|
`docs/sql-manual/sql-functions/scalar-functions/bitwise-functions/bit-length.md`
| Translate | 1 | Local gates passed |
|
`docs/sql-manual/sql-functions/scalar-functions/bitwise-functions/bit-test.md`
| Translate | 1 | Local gates passed |
|
`docs/sql-manual/sql-functions/scalar-functions/bitwise-functions/bitand.md`
| Translate | 1 | Local gates passed |
|
`docs/sql-manual/sql-functions/scalar-functions/bitwise-functions/bitcount.md`
| Translate | 1 | Local gates passed |
|
`docs/sql-manual/sql-functions/scalar-functions/bitwise-functions/bitnot.md`
| Translate | 1 | Local gates passed |
|
`docs/sql-manual/sql-functions/scalar-functions/bitwise-functions/bitor.md`
| Translate | 1 | Local gates passed |
|
`docs/sql-manual/sql-functions/scalar-functions/bitwise-functions/bitshiftleft.md`
| Translate | 1 | Local gates passed |
|
`docs/sql-manual/sql-functions/scalar-functions/bitwise-functions/bitshiftright.md`
| Translate | 1 | Local gates passed |
|
`docs/sql-manual/sql-functions/scalar-functions/bitwise-functions/xor.md`
| Translate | 1 | Local gates passed |
|
`docs/sql-manual/sql-functions/scalar-functions/conditional-functions/coalesce.md`
| Translate | 1 | Local gates passed |
|
`docs/sql-manual/sql-functions/scalar-functions/conditional-functions/greatest.md`
| Translate | 1 | Local gates passed |
|
`docs/sql-manual/sql-functions/scalar-functions/conditional-functions/if.md`
| Translate | 1 | Local gates passed |
|
`docs/sql-manual/sql-functions/scalar-functions/conditional-functions/ifnull.md`
| Translate | 1 | Local gates passed |
|
`docs/sql-manual/sql-functions/scalar-functions/conditional-functions/least.md`
| Translate | 1 | Local gates passed |
|
`docs/sql-manual/sql-functions/scalar-functions/conditional-functions/not-null-or-empty.md`
| Translate | 1 | Local gates passed |
|
`docs/sql-manual/sql-functions/scalar-functions/conditional-functions/null-or-empty.md`
| Translate | 1 | Local gates passed |
|
`docs/sql-manual/sql-functions/scalar-functions/conditional-functions/nullif.md`
| Translate | 1 | Local gates passed |
|
`docs/sql-manual/sql-functions/scalar-functions/conditional-functions/overview.md`
| Translate | 1 | Local gates passed |
|
`docs/sql-manual/sql-functions/scalar-functions/date-time-functions/add-time.md`
| Translate | 1 | Local gates passed |
|
`docs/sql-manual/sql-functions/scalar-functions/date-time-functions/century.md`
| Translate | 1 | Local gates passed |
|
`docs/sql-manual/sql-functions/scalar-functions/date-time-functions/convert-tz.md`
| Translate | 1 | Local gates passed |
|
`docs/sql-manual/sql-functions/scalar-functions/date-time-functions/curdate.md`
| Translate | 1 | Local gates passed |
|
`docs/sql-manual/sql-functions/scalar-functions/date-time-functions/curtime.md`
| Translate | 1 | Local gates passed |
|
`docs/sql-manual/sql-functions/scalar-functions/date-time-functions/date-add.md`
| Translate | 1 | Local gates passed |
|
`docs/sql-manual/sql-functions/scalar-functions/date-time-functions/date-ceil.md`
| Translate | 1 | Local gates passed |
|
`docs/sql-manual/sql-functions/scalar-functions/date-time-functions/date-floor.md`
| Translate | 1 | Local gates passed |
|
`docs/sql-manual/sql-functions/scalar-functions/date-time-functions/date-format.md`
| Translate | 1 | Local gates passed |
|
`docs/sql-manual/sql-functions/scalar-functions/date-time-functions/date-sub.md`
| Translate | 1 | Local gates passed |
|
`docs/sql-manual/sql-functions/scalar-functions/date-time-functions/date-trunc.md`
| Translate | 1 | Local gates passed |
|
`docs/sql-manual/sql-functions/scalar-functions/date-time-functions/date.md`
| Translate | 1 | Local gates passed |
|
`docs/sql-manual/sql-functions/scalar-functions/date-time-functions/datediff.md`
| Translate | 1 | Local gates passed |
|
`docs/sql-manual/sql-functions/scalar-functions/date-time-functions/day-ceil.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>
---
.../array-functions/array-intersect.md | 148 ++++++++++++++
.../scalar-functions/array-functions/array-join.md | 166 +++++++++++++++
.../array-functions/array-last-index.md | 160 +++++++++++++++
.../scalar-functions/array-functions/array-last.md | 147 ++++++++++++++
.../scalar-functions/array-functions/array-map.md | 152 ++++++++++++++
.../array-functions/array-match-all.md | 59 ++++++
.../array-functions/array-match-any.md | 66 ++++++
.../scalar-functions/array-functions/array-max.md | 163 +++++++++++++++
.../scalar-functions/array-functions/array-min.md | 163 +++++++++++++++
.../array-functions/array-popback.md | 145 +++++++++++++
.../array-functions/array-popfront.md | 145 +++++++++++++
.../array-functions/array-position.md | 169 ++++++++++++++++
.../array-functions/array-product.md | 138 +++++++++++++
.../array-functions/array-pushback.md | 162 +++++++++++++++
.../array-functions/array-pushfront.md | 158 +++++++++++++++
.../array-functions/array-range.md | 117 +++++++++++
.../array-functions/array-remove.md | 44 ++++
.../array-functions/array-repeat.md | 83 ++++++++
.../array-functions/array-reverse-sort.md | 41 ++++
.../array-functions/array-reverse-split.md | 53 +++++
.../array-functions/array-shuffle.md | 76 +++++++
.../scalar-functions/array-functions/array-size.md | 36 ++++
.../array-functions/array-slice.md | 53 +++++
.../scalar-functions/array-functions/array-sort.md | 204 +++++++++++++++++++
.../array-functions/array-sortby.md | 51 +++++
.../array-functions/array-split.md | 53 +++++
.../scalar-functions/array-functions/array-sum.md | 73 +++++++
.../array-functions/array-union.md | 95 +++++++++
.../array-functions/array-with-constant.md | 83 ++++++++
.../scalar-functions/array-functions/array-zip.md | 81 ++++++++
.../scalar-functions/array-functions/array.md | 142 +++++++++++++
.../array-functions/arrays-overlap.md | 153 ++++++++++++++
.../scalar-functions/array-functions/countequal.md | 43 ++++
.../scalar-functions/array-functions/trim-array.md | 106 ++++++++++
.../binary-functions/from-base64-binary.md | 73 +++++++
.../scalar-functions/binary-functions/from_hex.md | 73 +++++++
.../binary-functions/sub-binary.md | 109 ++++++++++
.../binary-functions/to-base64-binary.md | 56 ++++++
.../scalar-functions/binary-functions/to_hex.md | 75 +++++++
.../bitmap-functions/bitmap-and-count.md | 78 +++++++
.../bitmap-functions/bitmap-and-not-count.md | 59 ++++++
.../bitmap-functions/bitmap-and-not.md | 83 ++++++++
.../bitmap-functions/bitmap-and.md | 66 ++++++
.../bitmap-functions/bitmap-contains.md | 55 +++++
.../bitmap-functions/bitmap-count.md | 53 +++++
.../bitmap-functions/bitmap-empty.md | 51 +++++
.../bitmap-functions/bitmap-from-array.md | 67 ++++++
.../bitmap-functions/bitmap-from-base64.md | 79 ++++++++
.../bitmap-functions/bitmap-from-string.md | 91 +++++++++
.../bitmap-functions/bitmap-has-all.md | 80 ++++++++
.../bitmap-functions/bitmap-has-any.md | 68 +++++++
.../bitmap-functions/bitmap-hash.md | 88 ++++++++
.../bitmap-functions/bitmap-hash64.md | 60 ++++++
.../bitmap-functions/bitmap-max.md | 76 +++++++
.../bitmap-functions/bitmap-min.md | 76 +++++++
.../bitmap-functions/bitmap-not.md | 75 +++++++
.../bitmap-functions/bitmap-or-count.md | 112 +++++++++++
.../scalar-functions/bitmap-functions/bitmap-or.md | 144 +++++++++++++
.../bitmap-functions/bitmap-remove.md | 65 ++++++
.../bitmap-functions/bitmap-subset-in-range.md | 94 +++++++++
.../bitmap-functions/bitmap-subset-limit.md | 107 ++++++++++
.../bitmap-functions/bitmap-to-array.md | 94 +++++++++
.../bitmap-functions/bitmap-to-base64.md | 101 ++++++++++
.../bitmap-functions/bitmap-to-string.md | 94 +++++++++
.../bitmap-functions/bitmap-xor-count.md | 129 ++++++++++++
.../bitmap-functions/bitmap-xor.md | 113 +++++++++++
.../bitmap-functions/sub-bitmap.md | 95 +++++++++
.../scalar-functions/bitmap-functions/to-bitmap.md | 107 ++++++++++
.../bitwise-functions/bit-length.md | 48 +++++
.../scalar-functions/bitwise-functions/bit-test.md | 58 ++++++
.../scalar-functions/bitwise-functions/bitand.md | 49 +++++
.../scalar-functions/bitwise-functions/bitcount.md | 47 +++++
.../scalar-functions/bitwise-functions/bitnot.md | 47 +++++
.../scalar-functions/bitwise-functions/bitor.md | 49 +++++
.../bitwise-functions/bitshiftleft.md | 48 +++++
.../bitwise-functions/bitshiftright.md | 52 +++++
.../scalar-functions/bitwise-functions/xor.md | 49 +++++
.../conditional-functions/coalesce.md | 63 ++++++
.../conditional-functions/greatest.md | 78 +++++++
.../scalar-functions/conditional-functions/if.md | 72 +++++++
.../conditional-functions/ifnull.md | 64 ++++++
.../conditional-functions/least.md | 79 ++++++++
.../conditional-functions/not-null-or-empty.md | 36 ++++
.../conditional-functions/null-or-empty.md | 36 ++++
.../conditional-functions/nullif.md | 63 ++++++
.../conditional-functions/overview.md | 90 +++++++++
.../date-time-functions/add-time.md | 112 +++++++++++
.../date-time-functions/century.md | 61 ++++++
.../date-time-functions/convert-tz.md | 106 ++++++++++
.../date-time-functions/curdate.md | 40 ++++
.../date-time-functions/curtime.md | 68 +++++++
.../date-time-functions/date-add.md | 224 +++++++++++++++++++++
.../date-time-functions/date-ceil.md | 163 +++++++++++++++
.../date-time-functions/date-floor.md | 129 ++++++++++++
.../date-time-functions/date-format.md | 195 ++++++++++++++++++
.../date-time-functions/date-sub.md | 186 +++++++++++++++++
.../date-time-functions/date-trunc.md | 131 ++++++++++++
.../scalar-functions/date-time-functions/date.md | 63 ++++++
.../date-time-functions/datediff.md | 88 ++++++++
.../date-time-functions/day-ceil.md | 172 ++++++++++++++++
.../array-functions/array-intersect.json | 37 ++++
.../array-functions/array-join.json | 46 +++++
.../array-functions/array-last-index.json | 46 +++++
.../array-functions/array-last.json | 46 +++++
.../array-functions/array-map.json | 46 +++++
.../array-functions/array-match-all.json | 46 +++++
.../array-functions/array-match-any.json | 46 +++++
.../array-functions/array-max.json | 46 +++++
.../array-functions/array-min.json | 46 +++++
.../array-functions/array-popback.json | 37 ++++
.../array-functions/array-popfront.json | 37 ++++
.../array-functions/array-position.json | 37 ++++
.../array-functions/array-product.json | 37 ++++
.../array-functions/array-pushback.json | 37 ++++
.../array-functions/array-pushfront.json | 37 ++++
.../array-functions/array-range.json | 37 ++++
.../array-functions/array-remove.json | 37 ++++
.../array-functions/array-repeat.json | 37 ++++
.../array-functions/array-reverse-sort.json | 37 ++++
.../array-functions/array-reverse-split.json | 37 ++++
.../array-functions/array-shuffle.json | 37 ++++
.../array-functions/array-size.json | 37 ++++
.../array-functions/array-slice.json | 37 ++++
.../array-functions/array-sort.json | 37 ++++
.../array-functions/array-sortby.json | 37 ++++
.../array-functions/array-split.json | 37 ++++
.../array-functions/array-sum.json | 37 ++++
.../array-functions/array-union.json | 37 ++++
.../array-functions/array-with-constant.json | 37 ++++
.../array-functions/array-zip.json | 37 ++++
.../scalar-functions/array-functions/array.json | 46 +++++
.../array-functions/arrays-overlap.json | 37 ++++
.../array-functions/countequal.json | 37 ++++
.../array-functions/trim-array.json | 37 ++++
.../binary-functions/from-base64-binary.json | 37 ++++
.../binary-functions/from_hex.json | 37 ++++
.../binary-functions/sub-binary.json | 37 ++++
.../binary-functions/to-base64-binary.json | 37 ++++
.../scalar-functions/binary-functions/to_hex.json | 37 ++++
.../bitmap-functions/bitmap-and-count.json | 37 ++++
.../bitmap-functions/bitmap-and-not-count.json | 37 ++++
.../bitmap-functions/bitmap-and-not.json | 37 ++++
.../bitmap-functions/bitmap-and.json | 37 ++++
.../bitmap-functions/bitmap-contains.json | 37 ++++
.../bitmap-functions/bitmap-count.json | 37 ++++
.../bitmap-functions/bitmap-empty.json | 37 ++++
.../bitmap-functions/bitmap-from-array.json | 37 ++++
.../bitmap-functions/bitmap-from-base64.json | 37 ++++
.../bitmap-functions/bitmap-from-string.json | 37 ++++
.../bitmap-functions/bitmap-has-all.json | 37 ++++
.../bitmap-functions/bitmap-has-any.json | 37 ++++
.../bitmap-functions/bitmap-hash.json | 37 ++++
.../bitmap-functions/bitmap-hash64.json | 37 ++++
.../bitmap-functions/bitmap-max.json | 37 ++++
.../bitmap-functions/bitmap-min.json | 37 ++++
.../bitmap-functions/bitmap-not.json | 37 ++++
.../bitmap-functions/bitmap-or-count.json | 37 ++++
.../bitmap-functions/bitmap-or.json | 37 ++++
.../bitmap-functions/bitmap-remove.json | 37 ++++
.../bitmap-functions/bitmap-subset-in-range.json | 37 ++++
.../bitmap-functions/bitmap-subset-limit.json | 37 ++++
.../bitmap-functions/bitmap-to-array.json | 37 ++++
.../bitmap-functions/bitmap-to-base64.json | 37 ++++
.../bitmap-functions/bitmap-to-string.json | 37 ++++
.../bitmap-functions/bitmap-xor-count.json | 37 ++++
.../bitmap-functions/bitmap-xor.json | 37 ++++
.../bitmap-functions/sub-bitmap.json | 37 ++++
.../bitmap-functions/to-bitmap.json | 37 ++++
.../bitwise-functions/bit-length.json | 37 ++++
.../bitwise-functions/bit-test.json | 37 ++++
.../scalar-functions/bitwise-functions/bitand.json | 37 ++++
.../bitwise-functions/bitcount.json | 37 ++++
.../scalar-functions/bitwise-functions/bitnot.json | 37 ++++
.../scalar-functions/bitwise-functions/bitor.json | 37 ++++
.../bitwise-functions/bitshiftleft.json | 37 ++++
.../bitwise-functions/bitshiftright.json | 37 ++++
.../scalar-functions/bitwise-functions/xor.json | 37 ++++
.../conditional-functions/coalesce.json | 37 ++++
.../conditional-functions/greatest.json | 37 ++++
.../scalar-functions/conditional-functions/if.json | 37 ++++
.../conditional-functions/ifnull.json | 37 ++++
.../conditional-functions/least.json | 37 ++++
.../conditional-functions/not-null-or-empty.json | 37 ++++
.../conditional-functions/null-or-empty.json | 37 ++++
.../conditional-functions/nullif.json | 37 ++++
.../conditional-functions/overview.json | 37 ++++
.../date-time-functions/add-time.json | 37 ++++
.../date-time-functions/century.json | 37 ++++
.../date-time-functions/convert-tz.json | 37 ++++
.../date-time-functions/curdate.json | 37 ++++
.../date-time-functions/curtime.json | 37 ++++
.../date-time-functions/date-add.json | 37 ++++
.../date-time-functions/date-ceil.json | 37 ++++
.../date-time-functions/date-floor.json | 37 ++++
.../date-time-functions/date-format.json | 37 ++++
.../date-time-functions/date-sub.json | 37 ++++
.../date-time-functions/date-trunc.json | 37 ++++
.../scalar-functions/date-time-functions/date.json | 37 ++++
.../date-time-functions/datediff.json | 37 ++++
.../date-time-functions/day-ceil.json | 37 ++++
200 files changed, 13121 insertions(+)
diff --git a/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/array-functions/array-intersect.md b/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/array-functions/array-intersect.md
new file mode 100644
index 000000000000..9c71cb5d2abe
--- /dev/null
+++ b/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/array-functions/array-intersect.md
@@ -0,0 +1,148 @@
+---
+{
+ "title": "ARRAY_INTERSECT",
+ "language": "ru",
+ "description": "Возвращает пересечение нескольких массивов, то есть элементы, присутствующие во всех массивах."
+}
+---
+
+## array_intersect {#array_intersect}
+
+<version since="2.0.0">
+
+</version>
+
+### Описание {#description}
+
+Возвращает пересечение нескольких массивов, то есть элементы, присутствующие во всех массивах. Функция находит элементы, присутствующие во всех входных массивах, и формирует из них новый массив без дубликатов.
+
+### Синтаксис {#syntax}
+
+```sql
+array_intersect(ARRAY<T> arr1, ARRAY<T> arr2, [ARRAY<T> arr3, ...])
+```
+
+### Параметры {#parameters}
+
+- `arr1, arr2, arr3, ...`: массивы типа ARRAY<T>, для которых вычисляется пересечение. Поддерживаются два и более параметра-массива.
+
+**Поддерживаемые типы T:**
+- Числовые типы: TINYINT, SMALLINT, INT, BIGINT, LARGEINT, FLOAT, DOUBLE, DECIMAL
+- Строковые типы: CHAR, VARCHAR, STRING
+- Типы даты и времени: DATE, DATETIME, DATEV2, DATETIMEV2, TIMESTAMP_NS
+- Логический тип: BOOLEAN
+- Типы IP: IPV4, IPV6
+- UUID: [UUID](../../../basic-element/sql-data-types/uuid.md)
+
+### Возвращаемое значение {#return-value}
+
+Тип возвращаемого значения: ARRAY<T>
+
+Описание возвращаемого значения:
+- Возвращается новый массив, содержащий уникальные элементы, присутствующие во всех входных массивах
+- Пустой массив: если во всех входных массивах нет общих элементов
+
+Примечания по использованию:
+- Функция находит элементы, присутствующие во всех входных массивах, и удаляет дубликаты из результирующего массива
+- Пересечение пустого массива с любым массивом, отличным от NULL, даёт пустой массив. Если общих элементов нет, функция возвращает пустой массив.
+- Функция не поддерживает массивы NULL
+- Сравнение элементов выполняется по правилам совместимости типов. Если типы несовместимы, предпринимается попытка преобразования; при неудаче результатом становится null
+- Значения null в элементах массива: при выполнении операции элементы null обрабатываются как обычные элементы, при этом null считается равным null
+
+**Примеры запросов:**
+
+Пересечение двух массивов:
+```sql
+SELECT array_intersect([1, 2, 3, 4, 5], [2, 4, 6, 8]);
++------------------------------------------------+
+| array_intersect([1, 2, 3, 4, 5], [2, 4, 6, 8]) |
++------------------------------------------------+
+| [4, 2] |
++------------------------------------------------+
+```
+
+Пересечение нескольких массивов:
+```sql
+SELECT array_intersect([1, 2, 3, 4, 5], [2, 4, 6, 8], [2, 4, 10, 12]);
++----------------------------------------------------------------+
+| array_intersect([1, 2, 3, 4, 5], [2, 4, 6, 8], [2, 4, 10, 12]) |
++----------------------------------------------------------------+
+| [2, 4] |
++----------------------------------------------------------------+
+```
+
+Пересечение строковых массивов:
+```sql
+SELECT array_intersect(['a', 'b', 'c'], ['b', 'c', 'd']);
++--------------------------------------------+
+| array_intersect(['a','b','c'], ['b','c','d']) |
++--------------------------------------------+
+| ["b", "c"] |
++--------------------------------------------+
+```
+
+Массив со значениями null: null рассматривается как значение, которое можно сравнивать на равенство:
+```sql
+SELECT array_intersect([1, null, 2, null, 3], [null, 2, 3, 4]);
++---------------------------------------------------------+
+| array_intersect([1, null, 2, null, 3], [null, 2, 3, 4]) |
++---------------------------------------------------------+
+| [null, 2, 3] |
++---------------------------------------------------------+
+```
+
+Пересечение строкового массива и массива целых чисел:
+Строку '2' можно преобразовать в целое число 2; преобразование 'b' завершается неудачей, и значение становится null:
+```sql
+SELECT array_intersect([1, 2, null, 3], ['2', 'b']);
++----------------------------------------------+
+| array_intersect([1, 2, null, 3], ['2', 'b']) |
++----------------------------------------------+
+| [null, 2] |
++----------------------------------------------+
+```
+
+Пересечение пустого массива с любым массивом:
+```sql
+SELECT array_intersect([], [1, 2, 3]);
++-----------------------------+
+| array_intersect([], [1,2,3]) |
++-----------------------------+
+| [] |
++-----------------------------+
+```
+
+Передача NULL вместо входных массивов приводит к ошибке:
+```sql
+SELECT array_intersect(NULL, NULL);
+ERROR 1105 (HY000): errCode = 2, detailMessage = class org.apache.doris.nereids.types.NullType cannot be cast to class org.apache.doris.nereids.types.ArrayType (org.apache.doris.nereids.types.NullType and org.apache.doris.nereids.types.ArrayType are in unnamed module of loader 'app')
+```
+
+Сложные типы не поддерживаются и приводят к ошибке:
+Вложенные массивы не поддерживаются и приводят к ошибке:
+```sql
+SELECT array_intersect([[1,2],[3,4],[5,6]]);
+ERROR 1105 (HY000): errCode = 2, detailMessage = array_intersect does not support type ARRAY<ARRAY<TINYINT>>, expression is array_intersect([[1, 2], [3, 4], [5, 6]])
+```
+
+Типы Map не поддерживаются и приводят к ошибке:
+```sql
+SELECT array_intersect([{'k':1},{'k':2},{'k':3}]);
+ERROR 1105 (HY000): errCode = 2, detailMessage = array_intersect does not support type ARRAY<MAP<VARCHAR(1),TINYINT>>, expression is array_intersect([map('k', 1), map('k', 2), map('k', 3)])
+```
+
+Ошибка при неверном количестве параметров:
+```sql
+SELECT array_intersect([1, 2, 3]);
+ERROR 1105 (HY000): errCode = 2, detailMessage = Can not found function 'array_intersect' which has 1 arity. Candidate functions are: [array_intersect(Expression, Expression, ...)]
+```
+
+Ошибка при передаче значения, не являющегося массивом:
+```sql
+SELECT array_intersect('not_an_array', [1, 2, 3]);
+ERROR 1105 (HY000): errCode = 2, detailMessage = Can not find the compatibility function signature: array_intersect(VARCHAR(12), ARRAY<INT>)
+```
+
+### Ключевые слова {#keywords}
+
+ARRAY, INTERSECT, ARRAY_INTERSECT
diff --git a/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/array-functions/array-join.md b/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/array-functions/array-join.md
new file mode 100644
index 000000000000..00e2380478c4
--- /dev/null
+++ b/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/array-functions/array-join.md
@@ -0,0 +1,166 @@
+---
+{
+ "title": "ARRAY_JOIN",
+ "language": "ru",
+ "description": "Объединяет элементы массива в строку. Функция преобразует все элементы массива в строки, а затем соединяет их с помощью "
+}
+---
+
+## array_join {#array_join}
+
+<version since="2.0.0">
+
+</version>
+
+## Описание {#description}
+
+Объединяет элементы массива в строку. Функция преобразует все элементы массива в строки, а затем соединяет их с помощью указанного разделителя.
+
+## Синтаксис {#syntax}
+
+```sql
+array_join(ARRAY<T> arr, STRING separator [, STRING null_replacement])
+```
+
+### Параметры {#parameters}
+
+- `arr`: тип ARRAY<T>, объединяемый массив
+- `separator`: тип STRING, обязательный параметр, разделитель между элементами массива
+- `null_replacement`: тип STRING, необязательный параметр, строка для замены значений NULL в массиве. Если этот параметр не указан, значения NULL пропускаются
+
+**Поддерживаемые типы T:**
+- Числовые типы: TINYINT, SMALLINT, INT, BIGINT, LARGEINT, FLOAT, DOUBLE, DECIMAL
+- Строковые типы: CHAR, VARCHAR, STRING
+- Типы даты и времени: DATE, DATETIME, DATEV2, DATETIMEV2, TIMESTAMP_NS
+- Логический тип: BOOLEAN
+- Типы IP: IPV4, IPV6
+- UUID: UUID; элементы преобразуются в каноническое текстовое представление
+
+### Возвращаемое значение {#return-value}
+
+Тип возвращаемого значения: STRING
+
+Возвращаемое значение:
+- Строка, содержащая все элементы массива, объединённые с помощью разделителя
+- NULL: если входной массив равен NULL
+
+Особенности использования:
+- Функция преобразует каждый элемент массива в строку и объединяет полученные строки с помощью указанного разделителя
+- Обработка значений NULL в элементах массива:
+ - Если параметр `null_replacement` указан, элементы со значением NULL заменяются этой строкой
+ - Если параметр `null_replacement` не указан, элементы со значением NULL пропускаются
+- Для пустых массивов возвращаются пустые строки
+
+**Примеры запросов:**
+
+Объединение элементов массивов с помощью разделителя:
+```sql
+SELECT array_join([1, 2, 3, 4, 5], ',');
++--------------------------------------+
+| array_join([1, 2, 3, 4, 5], ',') |
++--------------------------------------+
+| 1,2,3,4,5 |
++--------------------------------------+
+```
+
+Объединение элементов строковых массивов с пробелом в качестве разделителя:
+```sql
+SELECT array_join(['hello', 'world', 'doris'], ' ');
++--------------------------------------------------+
+| array_join(['hello', 'world', 'doris'], ' ') |
++--------------------------------------------------+
+| hello world doris |
++--------------------------------------------------+
+```
+
+Объединение элементов массивов, содержащих значения NULL (значения NULL пропускаются):
+```sql
+SELECT array_join([1, null, 3, null, 5], '-');
++--------------------------------------------+
+| array_join([1, null, 3, null, 5], '-') |
++--------------------------------------------+
+| 1-3-5 |
++--------------------------------------------+
+```
+
+Замена значений NULL с помощью параметра null_replacement:
+```sql
+SELECT array_join([1, null, 3, null, 5], '-', 'NULL');
++--------------------------------------------------+
+| array_join([1, null, 3, null, 5], '-', 'NULL') |
++--------------------------------------------------+
+| 1-NULL-3-NULL-5 |
++--------------------------------------------------+
+```
+
+Объединение элементов массивов чисел с плавающей точкой:
+```sql
+SELECT array_join([1.1, 2.2, 3.3], ' | ');
++------------------------------------------+
+| array_join([1.1, 2.2, 3.3], ' | ') |
++------------------------------------------+
+| 1.1 | 2.2 | 3.3 |
++------------------------------------------+
+```
+
+Объединение элементов массивов дат:
+```sql
+SELECT array_join(CAST(['2023-01-01', '2023-06-15', '2023-12-31'] AS ARRAY<DATETIME>), ' to ');
++-----------------------------------------------------------------------------------------+
+| array_join(CAST(['2023-01-01', '2023-06-15', '2023-12-31'] AS ARRAY<DATETIME>), ' to ') |
++-----------------------------------------------------------------------------------------+
+| 2023-01-01 00:00:00 to 2023-06-15 00:00:00 to 2023-12-31 00:00:00 |
++-----------------------------------------------------------------------------------------+
+```
+
+Объединение элементов массивов IP-адресов:
+```sql
+SELECT array_join(CAST(['192.168.1.1', '192.168.1.2', '192.168.1.3'] AS ARRAY<IPV4>), ' -> ');
++----------------------------------------------------------------------------------+
+| array_join(CAST(['192.168.1.1', '192.168.1.2', '192.168.1.3'] AS ARRAY<IPV4>), ' -> ') |
++----------------------------------------------------------------------------------+
+| 192.168.1.1 -> 192.168.1.2 -> 192.168.1.3 |
++----------------------------------------------------------------------------------+
+```
+
+Для пустых массивов возвращаются пустые строки:
+```sql
+SELECT array_join([], ',');
++----------------------+
+| array_join([], ',') |
++----------------------+
+| |
++----------------------+
+```
+
+Если массив равен NULL, возвращается NULL:
+```sql
+SELECT array_join(NULL, ',');
++----------------------+
+| array_join(NULL, ',') |
++----------------------+
+| NULL |
++----------------------+
+```
+
+Ошибка при передаче сложных типов:
+```sql
+SELECT array_join([{'name':'Alice','age':20}, {'name':'Bob','age':30}], '; ');
+ERROR 1105 (HY000): errCode = 2, detailMessage = can not cast from origin type ARRAY<MAP<TEXT,TEXT>> to target type=ARRAY<VARCHAR(65533)>
+```
+
+Ошибка при неверном количестве параметров:
+```sql
+SELECT array_join([1,2,3], ',', 'extra', 'too_many');
+ERROR 1105 (HY000): errCode = 2, detailMessage = Can not found function 'array_join' which has 4 arity. Candidate functions are: [array_join(Expression, Expression, Expression), array_join(Expression, Expression)]
+```
+
+Ошибка при передаче значений, не являющихся массивами:
+```sql
+SELECT array_join('not_an_array', ',');
+ERROR 1105 (HY000): errCode = 2, detailMessage = Can not find the compatibility function signature: array_join(VARCHAR(12), VARCHAR(1))
+```
+
+### Ключевые слова {#keywords}
+
+ARRAY, JOIN, ARRAY_JOIN
diff --git a/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/array-functions/array-last-index.md b/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/array-functions/array-last-index.md
new file mode 100644
index 000000000000..34cfc6836bcf
--- /dev/null
+++ b/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/array-functions/array-last-index.md
@@ -0,0 +1,160 @@
+---
+{
+ "title": "ARRAY_LAST_INDEX",
+ "language": "ru",
+ "description": "Находит индекс (начиная с 1) последнего элемента массива, удовлетворяющего лямбда-выражению."
+}
+---
+
+## array_last_index {#array_last_index}
+
+<version since="2.0.0">
+
+</version>
+
+## Описание {#description}
+
+Находит индекс (начиная с 1) последнего элемента массива, удовлетворяющего лямбда-выражению. Находит последний элемент, удовлетворяющий условию, и возвращает его индекс.
+
+## Синтаксис {#syntax}
+
+```sql
+array_last_index(lambda, ARRAY<T> arr1, [ARRAY<T> arr2, ...])
+```
+
+### Параметры {#parameters}
+
+- `lambda`: лямбда-выражение, задающее условия поиска
+- `arr1, arr2, ...`: массивы типа ARRAY<T>, в которых выполняется поиск. Поддерживается один или несколько параметров-массивов.
+
+**Поддерживаемые типы T:**
+- Числовые типы: TINYINT, SMALLINT, INT, BIGINT, LARGEINT, FLOAT, DOUBLE, DECIMAL
+- Строковые типы: CHAR, VARCHAR, STRING
+- Типы даты и времени: DATE, DATETIME, DATEV2, DATETIMEV2, TIMESTAMP_NS
+- Логический тип: BOOLEAN
+- Типы IP: IPV4, IPV6
+- UUID: [UUID](../../../basic-element/sql-data-types/uuid.md)
+- Сложные типы: ARRAY, MAP, STRUCT
+
+### Возвращаемое значение {#return-value}
+
+Тип возвращаемого значения: BIGINT
+
+Значение результата:
+- Возвращает индекс последнего элемента массива, удовлетворяющего лямбда-выражению. Отсчёт начинается с 1, а не с 0. Если найденный элемент, удовлетворяющий условию, является первым элементом массива, функция возвращает 1, а не 0
+- 0: если входной массив равен NULL и лямбда-выражение отсутствует, массив пуст или ни один элемент не удовлетворяет условию
+
+Примечания по использованию:
+- Количество параметров лямбда-выражения должно совпадать с количеством параметров-массивов
+- Для пустых массивов возвращается 0. Если входной массив равен NULL и лямбда-выражение отсутствует, возвращается 0. Если входной массив равен NULL и задано лямбда-выражение, возникает ошибка
+- При передаче нескольких параметров-массивов все массивы должны иметь одинаковую длину
+- В лямбда-выражении можно использовать любые скалярные выражения, но нельзя использовать агрегатные функции
+- Лямбда-выражения могут вызывать другие функции высшего порядка, но типы возвращаемых значений должны быть совместимы
+- Обработка значений null в элементах массива: элементы null передаются в лямбда-выражение для обработки, и оно может проверять значения на null
+
+**Примеры запросов:**
+
+Поиск индекса последнего элемента, большего или равного 3, в массиве чисел с плавающей точкой:
+```sql
+SELECT array_last_index(x -> x >= 3, [1.1, 2.2, 3.3, 4.4, 5.5]);
++----------------------------------------------------------+
+| array_last_index(x -> x >= 3, [1.1, 2.2, 3.3, 4.4, 5.5]) |
++----------------------------------------------------------+
+| 5 |
++----------------------------------------------------------+
+```
+
+Поиск индекса последнего элемента, длина которого больше 2, в массиве строк:
+```sql
+SELECT array_last_index(x -> length(x) > 2, ['a', 'bb', 'ccc', 'dddd', 'eeeee']);
++---------------------------------------------------------------------------+
+| array_last_index(x -> length(x) > 2, ['a', 'bb', 'ccc', 'dddd', 'eeeee']) |
++---------------------------------------------------------------------------+
+| 5 |
++---------------------------------------------------------------------------+
+```
+
+Для пустого массива возвращается 0:
+```sql
+SELECT array_last_index(x -> x > 0, []);
++----------------------------------------+
+| array_last_index(x -> x > 0, []) |
++----------------------------------------+
+| 0 |
++----------------------------------------+
+```
+
+Сочетание массива NULL и лямбда-выражения. При использовании лямбда-выражения с NULL возникает ошибка. Если лямбда-выражение отсутствует, возвращается 0:
+```sql
+SELECT array_last_index(NULL);
++-------------------------+
+| array_last_index(NULL) |
++-------------------------+
+| 0 |
++-------------------------+
+
+SELECT array_last_index(x -> x > 2, NULL);
+ERROR 1105 (HY000): errCode = 2, detailMessage = lambda argument must be array but is NULL
+```
+
+Массив со значениями null: лямбда-выражение может проверять значения на null:
+```sql
+SELECT array_last_index(x -> x is not null, [null, 1, null, 3, null, 5]);
++-------------------------------------------------------------------+
+| array_last_index(x -> x is not null, [null, 1, null, 3, null, 5]) |
++-------------------------------------------------------------------+
+| 6 |
++-------------------------------------------------------------------+
+```
+
+Поиск в нескольких массивах: найти индекс последнего элемента, для которого значение из первого массива больше соответствующего значения из второго массива:
+```sql
+SELECT array_last_index((x, y) -> x > y, [1, 2, 3, 4, 5], [1.1, 2.2, 3.3, 4.4, 5.5]);
++-------------------------------------------------------------------------------+
+| array_last_index((x, y) -> x > y, [1, 2, 3, 4, 5], [1.1, 2.2, 3.3, 4.4, 5.5]) |
++-------------------------------------------------------------------------------+
+| 0 |
++-------------------------------------------------------------------------------+
+```
+
+Поиск во вложенном массиве: найти индекс последнего подмассива, длина которого больше 2:
+```sql
+SELECT array_last_index(x -> size(x) > 2, [[1,2],[3,4,5],[6],[7,8,9,10]]);
++--------------------------------------------------------------------+
+| array_last_index(x -> size(x) > 2, [[1,2],[3,4,5],[6],[7,8,9,10]]) |
++--------------------------------------------------------------------+
+| 4 |
++--------------------------------------------------------------------+
+```
+
+Поиск в массиве элементов типа Map: найти индекс последнего элемента, у которого значение по ключу 'a' больше 10:
+```sql
+SELECT array_last_index(x -> x['a'] > 10, [{'a':5}, {'a':15}, {'a':20}]);
++-------------------------------------------------------------------+
+| array_last_index(x -> x['a'] > 10, [{'a':5}, {'a':15}, {'a':20}]) |
++-------------------------------------------------------------------+
+| 3 |
++-------------------------------------------------------------------+
+```
+
+Ошибка при неверном количестве параметров:
+```sql
+SELECT array_last_index();
+ERROR 1105 (HY000): errCode = 2, detailMessage = Can not found function 'array_last_index' which has 0 arity. Candidate functions are: [array_last_index(Expression, Expression...)]
+```
+
+Ошибка при несовпадении количества параметров лямбда-выражения с количеством параметров-массивов:
+```sql
+SELECT array_last_index(x -> x > 0, [1,2,3], [4,5,6], [7,8,9]);
+ERROR 1105 (HY000): errCode = 2, detailMessage = lambda x -> (x > 0) arguments' size is not equal parameters' size
+```
+
+Ошибка при передаче значения, не являющегося массивом:
+```sql
+SELECT array_last_index(x -> x > 0, 'not_an_array');
+ERROR 1105 (HY000): errCode = 2, detailMessage = Can not find the compatibility function signature: array_last_index(Expression, VARCHAR(12))
+```
+
+### Ключевые слова {#keywords}
+
+ARRAY, LAST, INDEX, ARRAY_LAST_INDEX
diff --git a/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/array-functions/array-last.md b/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/array-functions/array-last.md
new file mode 100644
index 000000000000..49fd3d6d0547
--- /dev/null
+++ b/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/array-functions/array-last.md
@@ -0,0 +1,147 @@
+---
+{
+ "title": "ARRAY_LAST",
+ "language": "ru",
+ "description": "Находит последний элемент массива, удовлетворяющий лямбда-выражению. Находит последний элемент, удовлетворяющий условию, и возвращает его."
+}
+---
+
+## array_last {#array_last}
+
+<version since="2.0.0">
+
+</version>
+
+## Описание {#description}
+
+Находит последний элемент массива, удовлетворяющий лямбда-выражению. Находит последний элемент, удовлетворяющий условию, и возвращает его.
+
+## Синтаксис {#syntax}
+
+```sql
+array_last(lambda, ARRAY<T> arr1, [ARRAY<T> arr2, ...])
+```
+
+### Параметры {#parameters}
+
+- `lambda`：лямбда-выражение для задания условий поиска
+- `arr1, arr2, ...`：массивы типа ARRAY<T>, в которых выполняется поиск. Поддерживается один или несколько параметров-массивов.
+
+**Поддерживаемые типы T:**
+- Числовые типы: TINYINT, SMALLINT, INT, BIGINT, LARGEINT, FLOAT, DOUBLE, DECIMAL
+- Строковые типы: CHAR, VARCHAR, STRING
+- Типы даты и времени: DATE, DATETIME, DATEV2, DATETIMEV2, TIMESTAMP_NS
+- Логический тип: BOOLEAN
+- Типы IP: IPV4, IPV6
+- UUID: [UUID](../../../basic-element/sql-data-types/uuid.md)
+- Сложные типы: ARRAY, MAP, STRUCT
+
+### Возвращаемое значение {#return-value}
+
+Тип возвращаемого значения: T
+
+Значение результата:
+- Возвращает последний элемент массива, удовлетворяющий лямбда-выражению
+- NULL: если ни один элемент не удовлетворяет условию или входной массив равен NULL
+
+Примечания по использованию:
+- Количество параметров лямбда-выражения должно совпадать с количеством параметров-массивов
+- Если ни один элемент не удовлетворяет условию, возвращается NULL
+- Входные параметры со значением NULL не поддерживаются
+- При передаче нескольких параметров-массивов все массивы должны иметь одинаковую длину
+- Лямбда-выражение может использовать любое скалярное выражение, но не может использовать агрегатные функции
+- Лямбда-выражения могут вызывать другие функции высшего порядка, но типы возвращаемых значений должны быть совместимы
+- Обработка значений null в элементах массива: элементы null передаются в лямбда-выражение для обработки, и оно может проверять значения на null
+
+**Примеры запросов:**
+
+Поиск последнего элемента, который больше или равен 3, в массиве чисел с плавающей точкой:
+```sql
+SELECT array_last(x -> x >= 3, [1.1, 2.2, 3.3, 4.4, 5.5]);
++----------------------------------------------------+
+| array_last(x -> x >= 3, [1.1, 2.2, 3.3, 4.4, 5.5]) |
++----------------------------------------------------+
+| 5.5 |
++----------------------------------------------------+
+```
+
+Поиск последнего элемента длиной больше 2 в массиве строк:
+```sql
+SELECT array_last(x -> length(x) > 2, ['a', 'bb', 'ccc', 'dddd', 'eeeee']);
++---------------------------------------------------------------------+
+| array_last(x -> length(x) > 2, ['a', 'bb', 'ccc', 'dddd', 'eeeee']) |
++---------------------------------------------------------------------+
+| eeeee |
++---------------------------------------------------------------------+
+```
+
+Для пустого массива возвращается NULL:
+```sql
+SELECT array_last(x -> x > 0, []);
++-------------------------------------+
+| array_last(x -> x > 0, []) |
++-------------------------------------+
+| NULL |
++-------------------------------------+
+```
+
+Входной параметр со значением NULL вызывает ошибку:
+```sql
+SELECT array_last(x -> x > 2, NULL);
+ERROR 1105 (HY000): errCode = 2, detailMessage = lambda argument must be array but is NULL
+
+SELECT array_last(NULL);
+ERROR 1105 (HY000): errCode = 2, detailMessage = Can not build function: 'array_last', expression: array_last(NULL), The 1st arg of array_filter must be lambda but is NULL
+```
+
+Массив со значениями null: лямбда-выражение может проверять значения на null:
+```sql
+SELECT array_last(x -> x is not null, [null, 1, null, 3, null, 5]);
++-------------------------------------------------------------+
+| array_last(x -> x is not null, [null, 1, null, 3, null, 5]) |
++-------------------------------------------------------------+
+| 5 |
++-------------------------------------------------------------+
+```
+
+Поиск по нескольким массивам: найти последний элемент первого массива, который больше соответствующего элемента второго массива:
+```sql
+SELECT array_last((x, y) -> x > y, [1, 2, 3, 4, 5], [1.1, 2.2, 3.3, 4.4, 5.5]);
++-------------------------------------------------------------------------+
+| array_last((x, y) -> x > y, [1, 2, 3, 4, 5], [1.1, 2.2, 3.3, 4.4, 5.5]) |
++-------------------------------------------------------------------------+
+| NULL |
++-------------------------------------------------------------------------+
+```
+
+Поиск во вложенном массиве: найти последний подмассив, длина которого больше 2:
+```sql
+SELECT array_last(x -> size(x) > 2, [[1,2],[3,4,5],[6],[7,8,9,10]]);
++--------------------------------------------------------------+
+| array_last(x -> size(x) > 2, [[1,2],[3,4,5],[6],[7,8,9,10]]) |
++--------------------------------------------------------------+
+| [7, 8, 9, 10] |
++--------------------------------------------------------------+
+```
+
+Ошибка при неверном количестве параметров:
+```sql
+SELECT array_last();
+ERROR 1105 (HY000): errCode = 2, detailMessage = Can not found function 'array_last' which has 0 arity. Candidate functions are: [array_last(Expression, Expression...)]
+```
+
+Ошибка при несовпадении количества параметров лямбда-выражения с количеством параметров-массивов:
+```sql
+SELECT array_last(x -> x > 0, [1,2,3], [4,5,6], [7,8,9]);
+ERROR 1105 (HY000): errCode = 2, detailMessage = lambda x -> (x > 0) arguments' size is not equal parameters' size
+```
+
+Ошибка при передаче значения, не являющегося массивом:
+```sql
+SELECT array_last(x -> x > 0, 'not_an_array');
+ERROR 1105 (HY000): errCode = 2, detailMessage = Can not find the compatibility function signature: array_last(Expression, VARCHAR(12))
+```
+
+### Ключевые слова {#keywords}
+
+ARRAY, LAST, ARRAY_LAST
diff --git a/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/array-functions/array-map.md b/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/array-functions/array-map.md
new file mode 100644
index 000000000000..582a501d6881
--- /dev/null
+++ b/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/array-functions/array-map.md
@@ -0,0 +1,152 @@
+---
+{
+ "title": "ARRAY_MAP",
+ "language": "ru",
+ "description": "Применяет лямбда-выражение к элементам массива и возвращает новый массив."
+}
+---
+
+## array_map {#array_map}
+
+<version since="2.0.0">
+
+</version>
+
+## Описание {#description}
+
+Применяет лямбда-выражение к элементам массива и возвращает новый массив. Функция применяет лямбда-выражение к каждому элементу массива и возвращает соответствующий результат.
+
+## Синтаксис {#syntax}
+
+```sql
+array_map(lambda, ARRAY<T> arr1, [ARRAY<T> arr2, ...])
+```
+
+### Параметры {#parameters}
+
+- `lambda`：лямбда-выражение, задающее правила преобразования
+- `arr1, arr2, ...`：массивы типа ARRAY<T>, которые необходимо преобразовать. Поддерживается один или несколько параметров-массивов.
+
+**Поддерживаемые типы T:**
+- Числовые типы: TINYINT, SMALLINT, INT, BIGINT, LARGEINT, FLOAT, DOUBLE, DECIMAL
+- Строковые типы: CHAR, VARCHAR, STRING
+- Типы даты и времени: DATE, DATETIME, DATEV2, DATETIMEV2, TIMESTAMP_NS
+- Логический тип: BOOLEAN
+- Типы IP: IPV4, IPV6
+- UUID: [UUID](../../../basic-element/sql-data-types/uuid.md)
+- Сложные типы: ARRAY, MAP, STRUCT
+
+### Возвращаемое значение {#return-value}
+
+Тип возвращаемого значения: ARRAY<R>
+
+Описание возвращаемого значения:
+- Возвращает новый массив той же длины, что и входной массив. Каждая позиция содержит результат применения лямбда-выражения к соответствующему элементу
+
+Особенности использования:
+- Количество параметров лямбда-выражения должно совпадать с количеством параметров-массивов
+- Значение NULL не поддерживается для входных параметров-массивов
+- Если передано несколько параметров-массивов, все массивы должны иметь одинаковую длину
+- Лямбда-выражение может содержать любые скалярные выражения, но не может использовать агрегатные функции
+- Лямбда-выражения могут вызывать другие функции высшего порядка, но типы возвращаемых значений должны быть совместимы
+- Обработка значений null в элементах массива: элементы со значением null передаются в лямбда-выражение для обработки, и в нём можно проверять наличие значений null
+
+**Примеры запросов:**
+
+Возведение каждого элемента массива в квадрат:
+```sql
+SELECT array_map(x -> x * x, [1, 2, 3, 4, 5]);
++------------------------------------------+
+| array_map(x -> x * x, [1, 2, 3, 4, 5]) |
++------------------------------------------+
+| [1, 4, 9, 16, 25] |
++------------------------------------------+
+```
+
+Округление каждого элемента массива чисел с плавающей точкой:
+```sql
+SELECT array_map(x -> round(x), [1.1, 2.7, 3.3, 4.9, 5.5]);
++--------------------------------------------------+
+| array_map(x -> round(x), [1.1, 2.7, 3.3, 4.9, 5.5]) |
++--------------------------------------------------+
+| [1, 3, 3, 5, 6] |
++--------------------------------------------------+
+```
+
+Вычисление длины каждого элемента массива строк:
+```sql
+SELECT array_map(x -> length(x), ['a', 'bb', 'ccc', 'dddd', 'eeeee']);
++--------------------------------------------------+
+| array_map(x -> length(x), ['a', 'bb', 'ccc', 'dddd', 'eeeee']) |
++--------------------------------------------------+
+| [1, 2, 3, 4, 5] |
++--------------------------------------------------+
+```
+
+Обработка массива, содержащего значения null:
+```sql
+SELECT array_map(x -> x is not null, [1, null, 3, null, 5]);
++--------------------------------------------------+
+| array_map(x -> x is not null, [1, null, 3, null, 5]) |
++--------------------------------------------------+
+| [1, 0, 1, 0, 1] |
++--------------------------------------------------+
+```
+
+Передача NULL в array_map приводит к ошибке:
+```
+mysql> SELECT array_map(x->x>2, NULL);
+ERROR 1105 (HY000): errCode = 2, detailMessage = lambda argument must be array but is NULL
+```
+
+Пример с несколькими параметрами-массивами: сложение соответствующих элементов двух массивов:
+```sql
+SELECT array_map((x, y) -> x + y, [1, 2, 3, 4, 5], [10, 20, 30, 40, 50]);
++--------------------------------------------------+
+| array_map((x, y) -> x + y, [1, 2, 3, 4, 5], [10, 20, 30, 40, 50]) |
++--------------------------------------------------+
+| [11, 22, 33, 44, 55] |
++--------------------------------------------------+
+```
+
+Обработка вложенного массива: вычисление длины каждого подмассива:
+```sql
+SELECT array_map(x -> size(x), [[1,2],[3,4,5],[6],[7,8,9,10]]);
++--------------------------------------------------+
+| array_map(x -> size(x), [[1,2],[3,4,5],[6],[7,8,9,10]]) |
++--------------------------------------------------+
+| [2, 3, 1, 4] |
++--------------------------------------------------+
+```
+
+Обработка типа Map: извлечение значения по ключу 'a' из каждого отображения:
+```sql
+SELECT array_map(x -> x['a'], [{'a':1,'b':2}, {'a':3,'b':4}, {'a':5,'b':6}]);
++--------------------------------------------------+
+| array_map(x -> x['a'], [{'a':1,'b':2}, {'a':3,'b':4}, {'a':5,'b':6}]) |
++--------------------------------------------------+
+| [1, 3, 5] |
++--------------------------------------------------+
+```
+
+Ошибка при неверном количестве параметров:
+```sql
+SELECT array_map();
+ERROR 1105 (HY000): errCode = 2, detailMessage = Can not found function 'array_map' which has 0 arity. Candidate functions are: [array_map(Expression, Expression...)]
+```
+
+Ошибка, возникающая, когда количество параметров лямбда-выражения не совпадает с количеством параметров-массивов:
+```sql
+SELECT array_map(x -> x > 0, [1,2,3], [4,5,6], [7,8,9]);
+ERROR 1105 (HY000): errCode = 2, detailMessage = lambda x -> (x > 0) arguments' size is not equal parameters' size
+```
+
+Ошибка при передаче значения, тип которого не является массивом:
+```sql
+SELECT array_map(x -> x * 2, 'not_an_array');
+ERROR 1105 (HY000): errCode = 2, detailMessage = Can not find the compatibility function signature: array_map(Expression, VARCHAR(12))
+```
+
+### Ключевые слова {#keywords}
+
+ARRAY, MAP, ARRAY_MAP
diff --git a/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/array-functions/array-match-all.md b/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/array-functions/array-match-all.md
new file mode 100644
index 000000000000..6d49dc360ae8
--- /dev/null
+++ b/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/array-functions/array-match-all.md
@@ -0,0 +1,59 @@
+---
+{
+ "title": "ARRAY_MATCH_ALL",
+ "language": "ru",
+ "description": "Возвращает true, если все элементы массива удовлетворяют заданному условию, и false в противном случае."
+}
+---
+
+## Описание {#description}
+
+Возвращает true, если все элементы массива удовлетворяют заданному условию, и false в противном случае. Если массив содержит элементы NULL и все элементы, отличные от NULL, удовлетворяют условию, возвращает NULL.
+
+## Синтаксис {#syntax}
+
+```sql
+array_match_all(lambda, <arr> [, <arr> ...])
+```
+
+## Параметры {#parameters}
+
+- `lambda`: Лямбда-выражение, задающее условие для проверки каждого элемента
+- `<arr>`: Один или несколько массивов для проверки. Лямбда-функция применяется к каждому элементу этих массивов
+
+## Возвращаемое значение {#return-value}
+
+Возвращает логическое значение, допускающее NULL:
+- `true`, если все элементы массива удовлетворяют условию
+- `false`, если хотя бы один элемент массива не удовлетворяет условию
+- `NULL`, если массив содержит элементы NULL и все элементы, отличные от NULL, удовлетворяют условию
+
+## Примеры {#examples}
+
+```sql
+-- Check if all numbers in array are greater than 5
+mysql> SELECT array_match_all(x -> x > 5, [1, 2, 3, 4, 7]);
++----------------------------------------------+
+| array_match_all(x -> x > 5, [1, 2, 3, 4, 7]) |
++----------------------------------------------+
+| 0 |
++----------------------------------------------+
+
+-- Check if all numbers in array are greater than corresponding numbers in another array
+mysql> SELECT array_match_all((x, i) -> x > i, [1, 2, 3, 4, 5], [1, 2, 3, 4, 7]);
++--------------------------------------------------------------------+
+| array_match_all((x, i) -> x > i, [1, 2, 3, 4, 5], [1, 2, 3, 4, 7]) |
++--------------------------------------------------------------------+
+| 0 |
++--------------------------------------------------------------------+
+```
+
+## Примечания {#notes}
+
+1. Функция обрабатывает значения NULL следующим образом:
+ - Если есть элементы NULL и все элементы, отличные от NULL, удовлетворяют условию, возвращает NULL
+ - Если хотя бы один элемент, отличный от NULL, не удовлетворяет условию, возвращает false независимо от наличия элементов NULL
+
+2. Эту функцию удобно использовать для:
+ - Проверки того, что все элементы массива соответствуют заданным критериям
+ - Выполнения сложных операций с массивами в сочетании с другими функциями для работы с массивами
diff --git a/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/array-functions/array-match-any.md b/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/array-functions/array-match-any.md
new file mode 100644
index 000000000000..e5f89aea1f1f
--- /dev/null
+++ b/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/array-functions/array-match-any.md
@@ -0,0 +1,66 @@
+---
+{
+ "title": "array_match_any",
+ "language": "ru",
+ "description": "Возвращает true, если хотя бы один элемент массива удовлетворяет заданному условию, и false в противном случае."
+}
+---
+
+## Описание {#description}
+
+Возвращает true, если хотя бы один элемент массива удовлетворяет заданному условию, и false в противном случае. Если массив содержит элементы NULL, а все элементы, отличные от NULL, имеют значение false, возвращает NULL.
+
+## Синтаксис {#syntax}
+
+```sql
+array_match_any(lambda, <arr> [, <arr> ...])
+```
+
+## Параметры {#parameters}
+
+- `lambda`: Лямбда-выражение, задающее условие проверки каждого элемента
+- `<arr>`: Один или несколько массивов для проверки. Лямбда-функция применяется к каждому элементу этих массивов
+
+## Возвращаемое значение {#return-value}
+
+Возвращает логическое значение, допускающее NULL:
+- `true`, если хотя бы один элемент массива удовлетворяет условию
+- `false`, если ни один элемент массива не удовлетворяет условию
+- `NULL`, если массив содержит элементы NULL и ни один элемент, отличный от NULL, не удовлетворяет условию
+
+## Примеры {#examples}
+
+```sql
+-- Check if any number in array is greater than 5
+mysql> SELECT array_match_any(x -> x > 5, [1, 2, 3, 4, 7]);
++----------------------------------------------+
+| array_match_any(x -> x > 5, [1, 2, 3, 4, 7]) |
++----------------------------------------------+
+| 1 |
++----------------------------------------------+
+
+-- Check if any number in array is greater than corresponding numbers in another array
+mysql> SELECT array_match_any((x, i) -> x > i, [1, 2, 3, 4, 5], [1, 2, 3, 4, 7]);
++--------------------------------------------------------------------+
+| array_match_any((x, i) -> x > i, [1, 2, 3, 4, 5], [1, 2, 3, 4, 7]) |
++--------------------------------------------------------------------+
+| 0 |
++--------------------------------------------------------------------+
+
+mysql> SELECT array_match_any((x, i) -> i > x, [1, 2, 3, 4, 5], [1, 2, 3, 4, 7]);
++--------------------------------------------------------------------+
+| array_match_any((x, i) -> i > x, [1, 2, 3, 4, 5], [1, 2, 3, 4, 7]) |
++--------------------------------------------------------------------+
+| 1 |
++--------------------------------------------------------------------+
+```
+
+## Примечания {#notes}
+
+1. Функция обрабатывает значения NULL следующим образом:
+ - Если массив содержит элементы NULL и ни один элемент, отличный от NULL, не удовлетворяет условию, возвращает NULL
+ - Если хотя бы один элемент, отличный от NULL, удовлетворяет условию, возвращает true независимо от наличия элементов NULL
+
+2. Эта функция полезна для:
+ - Проверки того, удовлетворяет ли хотя бы один элемент массива заданным критериям
+ - Выполнения сложных операций с массивами в сочетании с другими функциями для работы с массивами
diff --git a/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/array-functions/array-max.md b/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/array-functions/array-max.md
new file mode 100644
index 000000000000..47f43c507296
--- /dev/null
+++ b/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/array-functions/array-max.md
@@ -0,0 +1,163 @@
+---
+{
+ "title": "ARRAY_MAX",
+ "language": "ru",
+ "description": "Вычисляет максимальное значение в массиве. Функция перебирает все элементы массива, находит максимальное значение и возвращает его."
+}
+---
+
+## array_max {#array_max}
+
+<version since="2.0.0">
+
+</version>
+
+## Описание {#description}
+
+Вычисляет максимальное значение в массиве. Функция перебирает все элементы массива, находит максимальное значение и возвращает его.
+
+## Синтаксис {#syntax}
+
+```sql
+array_max(ARRAY<T> arr)
+```
+
+### Параметры {#parameters}
+
+- `arr`：тип ARRAY<T>, массив, для которого нужно вычислить максимальное значение.
+
+**Поддерживаемые типы T:**
+- Числовые типы: TINYINT, SMALLINT, INT, BIGINT, LARGEINT, FLOAT, DOUBLE, DECIMAL
+- Строковые типы: CHAR, VARCHAR, STRING
+- Типы даты и времени: DATE, DATETIME, DATEV2, DATETIMEV2, TIMESTAMP_NS
+- Логический тип: BOOLEAN
+- Типы IP: IPV4, IPV6
+- UUID: [UUID](../../../basic-element/sql-data-types/uuid.md)
+
+### Возвращаемое значение {#return-value}
+
+Тип возвращаемого значения: T
+
+Описание возвращаемого значения:
+- Возвращает максимальное значение в массиве
+- NULL: если массив пуст или все его элементы имеют значение null
+
+Примечания по использованию:
+- Определяет возвращаемый элемент путём сравнения элементов массива; поддерживается сравнение элементов одного типа данных
+- Если массив равен NULL, возникает ошибка преобразования типа
+- Элементы массива со значением null не участвуют в сравнении
+
+**Примеры запросов:**
+
+Вычисление максимального значения в массиве чисел с плавающей точкой:
+```sql
+SELECT array_max([5.5, 2.2, 8.8, 1.1, 9.9, 3.3]);
++-------------------------------------------+
+| array_max([5.5, 2.2, 8.8, 1.1, 9.9, 3.3]) |
++-------------------------------------------+
+| 9.9 |
++-------------------------------------------+
+```
+
+Вычисление максимального значения в массиве строк (в лексикографическом порядке):
+```sql
+SELECT array_max(['zebra', 'appleeee', 'banana', 'cherry']);
++------------------------------------------------------+
+| array_max(['zebra', 'appleeee', 'banana', 'cherry']) |
++------------------------------------------------------+
+| zebra |
++------------------------------------------------------+
+```
+
+Вычисление максимального значения в массиве, содержащем значения null:
+```sql
+SELECT array_max([5, null, 2, null, 8, 1]);
++-------------------------------------+
+| array_max([5, null, 2, null, 8, 1]) |
++-------------------------------------+
+| 8 |
++-------------------------------------+
+```
+
+Для пустого массива возвращается NULL:
+```sql
+SELECT array_max([]);
++------------------+
+| array_max([]) |
++------------------+
+| NULL |
++------------------+
+```
+
+Для массива, все элементы которого имеют значение null, возвращается NULL:
+```sql
+SELECT array_max([null, null, null]);
++----------------------------------+
+| array_max([null, null, null]) |
++----------------------------------+
+| NULL |
++----------------------------------+
+```
+
+Максимальное значение в массиве дат:
+```sql
+SELECT array_max(cast(['2023-01-01', '2022-12-31', '2023-06-15'] as array<datetime>));
++--------------------------------------------------------------------------------+
+| array_max(cast(['2023-01-01', '2022-12-31', '2023-06-15'] as array<datetime>)) |
++--------------------------------------------------------------------------------+
+| 2023-06-15 00:00:00 |
++--------------------------------------------------------------------------------+
+```
+
+Максимальное значение в массиве IP-адресов:
+```sql
+SELECT array_max(CAST(['192.168.1.100', '192.168.1.1', '192.168.1.50'] AS ARRAY<IPV4>));
++----------------------------------------------------------------------------------+
+| array_max(CAST(['192.168.1.100', '192.168.1.1', '192.168.1.50'] AS ARRAY<IPV4>)) |
++----------------------------------------------------------------------------------+
+| 192.168.1.100 |
++----------------------------------------------------------------------------------+
+
+SELECT array_max(CAST(['2001:db8::1', '2001:db8::2', '2001:db8::0'] AS ARRAY<IPV6>));
++-------------------------------------------------------------------------------+
+| array_max(CAST(['2001:db8::1', '2001:db8::2', '2001:db8::0'] AS ARRAY<IPV6>)) |
++-------------------------------------------------------------------------------+
+| 2001:db8::2 |
++-------------------------------------------------------------------------------+
+```
+
+Примеры со сложными типами:
+
+Вложенные массивы не поддерживаются; возникает ошибка:
+```sql
+SELECT array_max([[1,2],[3,4],[5,6]]);
+ERROR 1105 (HY000): errCode = 2, detailMessage = array_max does not support complex types: array_max([[1, 2], [3, 4], [5, 6]])
+```
+
+Типы Map не поддерживаются; возникает ошибка:
+```sql
+SELECT array_max([{'k':1},{'k':2},{'k':3}]);
+ERROR 1105 (HY000): errCode = 2, detailMessage = array_max does not support complex types: array_max([map('k', 1), map('k', 2), map('k', 3)])
+```
+
+Ошибка при неверном количестве параметров:
+```sql
+SELECT array_max([1,2,3], [4,5,6]);
+ERROR 1105 (HY000): errCode = 2, detailMessage = Can not found function 'array_max' which has 2 arity. Candidate functions are: [array_max(Expression)]
+```
+
+Ошибка при передаче значения, тип которого не является массивом:
+```sql
+SELECT array_max('not_an_array');
+ERROR 1105 (HY000): errCode = 2, detailMessage = class org.apache.doris.nereids.types.VarcharType cannot be cast to class org.apache.doris.nereids.types.ArrayType (org.apache.doris.nereids.types.VarcharType and org.apache.doris.nereids.types.ArrayType are in unnamed module of loader 'app')
+```
+
+Если массив равен NULL, возникает ошибка преобразования типа:
+```sql
+mysql> SELECT array_max(NULL);
+ERROR 1105 (HY000): errCode = 2, detailMessage = class org.apache.doris.nereids.types.NullType cannot be cast to class org.apache.doris.nereids.types.ArrayType (org.apache.doris.nereids.types.NullType and org.apache.doris.nereids.types.ArrayType are in unnamed module of loader 'app')
+```
+
+### Ключевые слова {#keywords}
+
+ARRAY, MAX, ARRAY_MAX
diff --git a/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/array-functions/array-min.md b/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/array-functions/array-min.md
new file mode 100644
index 000000000000..df2035377156
--- /dev/null
+++ b/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/array-functions/array-min.md
@@ -0,0 +1,163 @@
+---
+{
+ "title": "ARRAY_MIN",
+ "language": "ru",
+ "description": "Вычисляет минимальное значение в массиве. Функция перебирает все элементы массива, находит минимальное значение и возвращает его."
+}
+---
+
+## array_min {#array_min}
+
+<version since="2.0.0">
+
+</version>
+
+## Описание {#description}
+
+Вычисляет минимальное значение в массиве. Функция перебирает все элементы массива, находит минимальное значение и возвращает его.
+
+## Синтаксис {#syntax}
+
+```sql
+array_min(ARRAY<T> arr)
+```
+
+### Параметры {#parameters}
+
+- `arr`：массив типа ARRAY<T>, для которого нужно вычислить минимальное значение.
+
+**Поддерживаемые типы T:**
+- Числовые типы: TINYINT, SMALLINT, INT, BIGINT, LARGEINT, FLOAT, DOUBLE, DECIMAL
+- Строковые типы: CHAR, VARCHAR, STRING
+- Типы даты и времени: DATE, DATETIME, DATEV2, DATETIMEV2, TIMESTAMP_NS
+- Логический тип: BOOLEAN
+- Типы IP-адресов: IPV4, IPV6
+- UUID: [UUID](../../../basic-element/sql-data-types/uuid.md)
+
+### Возвращаемое значение {#return-value}
+
+Тип возвращаемого значения: T
+
+Значение результата:
+- Минимальное значение в массиве
+- NULL: если массив пуст или все его элементы равны null
+
+Примечания по использованию:
+- Возвращаемый элемент определяется путём сравнения элементов массива; поддерживается сравнение элементов одного типа данных
+- Если массив равен NULL, возвращается ошибка преобразования типа
+- Элементы массива со значением null не участвуют в сравнении
+
+**Примеры запросов:**
+
+Вычисление минимального значения в массиве чисел с плавающей точкой:
+```sql
+SELECT array_min([5.5, 2.2, 8.8, 1.1, 9.9, 3.3]);
++-------------------------------------------+
+| array_min([5.5, 2.2, 8.8, 1.1, 9.9, 3.3]) |
++-------------------------------------------+
+| 1.1 |
++-------------------------------------------+
+```
+
+Вычисление минимального значения в массиве строк (в лексикографическом порядке):
+```sql
+SELECT array_min(['zebra', 'apple', 'banana', 'cherry']);
++---------------------------------------------------+
+| array_min(['zebra', 'apple', 'banana', 'cherry']) |
++---------------------------------------------------+
+| apple |
++---------------------------------------------------+
+```
+
+Вычисление минимального значения в массиве, содержащем значения null; элементы со значением null не участвуют в сравнении:
+```sql
+SELECT array_min([5, null, 2, null, 8, 1]);
++-------------------------------------+
+| array_min([5, null, 2, null, 8, 1]) |
++-------------------------------------+
+| 1 |
++-------------------------------------+
+```
+
+Для пустого массива возвращается NULL:
+```sql
+SELECT array_min([]);
++------------------+
+| array_min([]) |
++------------------+
+| NULL |
++------------------+
+```
+
+Для массива, все элементы которого равны null, возвращается NULL:
+```sql
+SELECT array_min([null, null, null]);
++----------------------------------+
+| array_min([null, null, null]) |
++----------------------------------+
+| NULL |
++----------------------------------+
+```
+
+Минимальное значение в массиве дат:
+```sql
+SELECT array_min(cast(['2023-01-01', '2022-12-31', '2023-06-15'] as array<datetime>));
++--------------------------------------------------------------------------------+
+| array_min(cast(['2023-01-01', '2022-12-31', '2023-06-15'] as array<datetime>)) |
++--------------------------------------------------------------------------------+
+| 2022-12-31 00:00:00 |
++--------------------------------------------------------------------------------+
+```
+
+Минимальное значение в массиве IP-адресов:
+```sql
+SELECT array_min(CAST(['192.168.1.100', '192.168.1.1', '192.168.1.50'] AS ARRAY<IPV4>));
++----------------------------------------------------------------------------------+
+| array_min(CAST(['192.168.1.100', '192.168.1.1', '192.168.1.50'] AS ARRAY<IPV4>)) |
++----------------------------------------------------------------------------------+
+| 192.168.1.1 |
++----------------------------------------------------------------------------------+
+
+SELECT array_min(CAST(['2001:db8::1', '2001:db8::2', '2001:db8::0'] AS ARRAY<IPV6>));
++-------------------------------------------------------------------------------+
+| array_min(CAST(['2001:db8::1', '2001:db8::2', '2001:db8::0'] AS ARRAY<IPV6>)) |
++-------------------------------------------------------------------------------+
+| 2001:db8:: |
++-------------------------------------------------------------------------------+
+```
+
+Примеры со сложными типами:
+
+Вложенные массивы не поддерживаются; вызов завершится ошибкой:
+```sql
+SELECT array_min([[1,2],[3,4],[5,6]]);
+ERROR 1105 (HY000): errCode = 2, detailMessage = array_min does not support complex types: array_min([[1, 2], [3, 4], [5, 6]])
+```
+
+Типы Map не поддерживаются; вызов завершится ошибкой:
+```sql
+SELECT array_min([{'k':1},{'k':2},{'k':3}]);
+ERROR 1105 (HY000): errCode = 2, detailMessage = array_min does not support complex types: array_min([map('k', 1), map('k', 2), map('k', 3)])
+```
+
+Ошибка при неверном количестве параметров:
+```sql
+SELECT array_min([1,2,3], [4,5,6]);
+ERROR 1105 (HY000): errCode = 2, detailMessage = Can not found function 'array_min' which has 2 arity. Candidate functions are: [array_min(Expression)]
+```
+
+Ошибка при передаче значения, не являющегося массивом:
+```sql
+SELECT array_min('not_an_array');
+ERROR 1105 (HY000): errCode = 2, detailMessage = class org.apache.doris.nereids.types.VarcharType cannot be cast to class org.apache.doris.nereids.types.ArrayType (org.apache.doris.nereids.types.VarcharType and org.apache.doris.nereids.types.ArrayType are in unnamed module of loader 'app')
+```
+
+Если массив равен NULL, возвращается ошибка преобразования типа:
+```sql
+mysql> SELECT array_min(NULL);
+ERROR 1105 (HY000): errCode = 2, detailMessage = class org.apache.doris.nereids.types.NullType cannot be cast to class org.apache.doris.nereids.types.ArrayType (org.apache.doris.nereids.types.NullType and org.apache.doris.nereids.types.ArrayType are in unnamed module of loader 'app')
+```
+
+### Ключевые слова {#keywords}
+
+ARRAY, MIN, ARRAY_MIN
diff --git a/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/array-functions/array-popback.md b/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/array-functions/array-popback.md
new file mode 100644
index 000000000000..f6281c529fc2
--- /dev/null
+++ b/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/array-functions/array-popback.md
@@ -0,0 +1,145 @@
+---
+{
+ "title": "ARRAY_POPBACK",
+ "language": "ru",
+ "description": "Удаляет последний элемент массива. Функция возвращает новый массив, содержащий все элементы исходного массива, кроме последнего."
+}
+---
+
+## array_popback {#array_popback}
+
+<version since="2.0.0">
+
+</version>
+
+## Описание {#description}
+
+Удаляет последний элемент массива. Функция возвращает новый массив, содержащий все элементы исходного массива, кроме последнего.
+
+## Синтаксис {#syntax}
+
+```sql
+array_popback(ARRAY<T> arr)
+```
+
+### Параметры {#parameters}
+
+- `arr`：тип ARRAY<T>, массив, из которого нужно удалить последний элемент
+
+**Поддерживаемые типы T:**
+- Числовые типы: TINYINT, SMALLINT, INT, BIGINT, LARGEINT, FLOAT, DOUBLE, DECIMAL
+- Строковые типы: CHAR, VARCHAR, STRING
+- Типы даты и времени: DATE, DATETIME, DATEV2, DATETIMEV2, TIMESTAMP_NS
+- Логический тип: BOOLEAN
+- Типы IP: IPV4, IPV6
+- UUID: [UUID](../../../basic-element/sql-data-types/uuid.md)
+- Сложные типы: ARRAY, MAP, STRUCT
+
+### Возвращаемое значение {#return-value}
+
+Тип возвращаемого значения: ARRAY<T>
+
+Описание возвращаемого значения:
+- Возвращает новый массив, содержащий все элементы исходного массива, кроме последнего
+- NULL: если входной массив равен NULL
+
+Примечания по использованию:
+- Функция удаляет последний элемент массива и возвращает оставшиеся элементы
+- Для пустых массивов и массивов, содержащих только один элемент, возвращаются пустые массивы
+- Элементы массива со значением null обрабатываются обычным образом
+
+**Примеры запросов:**
+
+Удаление последнего элемента строкового массива:
+```sql
+SELECT array_popback(['apple', 'banana', 'cherry', 'date']);
++--------------------------------------------------+
+| array_popback(['apple', 'banana', 'cherry', 'date']) |
++--------------------------------------------------+
+| ["apple", "banana", "cherry"] |
++--------------------------------------------------+
+```
+
+Удаление последнего элемента массива, содержащего значения null:
+```sql
+SELECT array_popback([1, null, 3, null, 5]);
++--------------------------------------------+
+| array_popback([1, null, 3, null, 5]) |
++--------------------------------------------+
+| [1, null, 3, null] |
++--------------------------------------------+
+```
+
+Для массивов, содержащих только один элемент, возвращаются пустые массивы:
+```sql
+SELECT array_popback([42]);
++----------------------+
+| array_popback([42]) |
++----------------------+
+| [] |
++----------------------+
+```
+
+Для пустых массивов возвращаются пустые массивы:
+```sql
+SELECT array_popback([]);
++----------------------+
+| array_popback([]) |
++----------------------+
+| [] |
++----------------------+
+```
+
+Для массивов со значением NULL возвращается NULL:
+```sql
+SELECT array_popback(NULL);
++----------------------+
+| array_popback(NULL) |
++----------------------+
+| NULL |
++----------------------+
+```
+
+Удаление последнего элемента массива IP-адресов:
+```sql
+SELECT array_popback(CAST(['192.168.1.1', '192.168.1.2', '192.168.1.3'] AS ARRAY<IPV4>));
++----------------------------------------------------------------------------------+
+| array_popback(CAST(['192.168.1.1', '192.168.1.2', '192.168.1.3'] AS ARRAY<IPV4>)) |
++----------------------------------------------------------------------------------+
+| ["192.168.1.1", "192.168.1.2"] |
++----------------------------------------------------------------------------------+
+```
+
+Удаление последнего элемента вложенного массива:
+```sql
+SELECT array_popback([[1, 2], [3, 4], [5, 6]]);
++------------------------------------------+
+| array_popback([[1, 2], [3, 4], [5, 6]]) |
++------------------------------------------+
+| [[1, 2], [3, 4]] |
++------------------------------------------+
+```
+
+Удаление последнего элемента массива MAP:
+```sql
+SELECT array_popback([{'name':'Alice','age':20}, {'name':'Bob','age':30}, {'name':'Charlie','age':40}]);
++--------------------------------------------------------------------------------------------------+
+| array_popback([{'name':'Alice','age':20}, {'name':'Bob','age':30}, {'name':'Charlie','age':40}]) |
++--------------------------------------------------------------------------------------------------+
+| [{"name":"Alice", "age":"20"}, {"name":"Bob", "age":"30"}] |
++--------------------------------------------------------------------------------------------------+
+```
+
+Удаление последнего элемента массива STRUCT:
+```sql
+SELECT array_popback(array(named_struct('name','Alice','age',20), named_struct('name','Bob','age',30), named_struct('name','Charlie','age',40)));
++-------------------------------------------------------------------------------------------------------------------------------------------+
+| array_popback(array(named_struct('name','Alice','age',20), named_struct('name','Bob','age',30), named_struct('name','Charlie','age',40))) |
++-------------------------------------------------------------------------------------------------------------------------------------------+
+| [{"name":"Alice", "age":20}, {"name":"Bob", "age":30}] |
++-------------------------------------------------------------------------------------------------------------------------------------------+
+```
+
+### Ключевые слова {#keywords}
+
+ARRAY, POPBACK, ARRAY_POPBACK
diff --git a/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/array-functions/array-popfront.md b/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/array-functions/array-popfront.md
new file mode 100644
index 000000000000..519d71429d6f
--- /dev/null
+++ b/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/array-functions/array-popfront.md
@@ -0,0 +1,145 @@
+---
+{
+ "title": "ARRAY_POPFRONT",
+ "language": "ru",
+ "description": "Удаляет первый элемент массива. Функция возвращает новый массив, содержащий все элементы исходного массива, кроме первого."
+}
+---
+
+## array_popfront {#array_popfront}
+
+<version since="2.0.0">
+
+</version>
+
+## Описание {#description}
+
+Удаляет первый элемент массива. Функция возвращает новый массив, содержащий все элементы исходного массива, кроме первого.
+
+## Синтаксис {#syntax}
+
+```sql
+array_popfront(ARRAY<T> arr)
+```
+
+### Параметры {#parameters}
+
+- `arr`：тип ARRAY<T>, массив, из которого нужно удалить первый элемент
+
+**Поддерживаемые типы T:**
+- Числовые типы: TINYINT, SMALLINT, INT, BIGINT, LARGEINT, FLOAT, DOUBLE, DECIMAL
+- Строковые типы: CHAR, VARCHAR, STRING
+- Типы даты и времени: DATE, DATETIME, DATEV2, DATETIMEV2, TIMESTAMP_NS
+- Логический тип: BOOLEAN
+- Типы IP-адресов: IPV4, IPV6
+- UUID: [UUID](../../../basic-element/sql-data-types/uuid.md)
+- Сложные типы: ARRAY, MAP, STRUCT
+
+### Возвращаемое значение {#return-value}
+
+Тип возвращаемого значения: ARRAY<T>
+
+Описание возвращаемого значения:
+- Возвращает новый массив, содержащий все элементы исходного массива, кроме первого
+- NULL: если входной массив равен NULL
+
+Примечания по использованию:
+- Функция удаляет первый элемент массива и возвращает оставшиеся элементы
+- Для пустых массивов возвращаются пустые массивы; для массивов с единственным элементом также возвращаются пустые массивы
+- Значения null в элементах массива: элементы null обрабатываются обычным образом
+
+**Примеры запросов:**
+
+Удаление первого элемента массива строк:
+```sql
+SELECT array_popfront(['apple', 'banana', 'cherry', 'date']);
++----------------------------------------------------+
+| array_popfront(['apple', 'banana', 'cherry', 'date']) |
++----------------------------------------------------+
+| ["banana", "cherry", "date"] |
++----------------------------------------------------+
+```
+
+Удаление первого элемента массива, содержащего значения null:
+```sql
+SELECT array_popfront([1, null, 3, null, 5]);
++------------------------------------------+
+| array_popfront([1, null, 3, null, 5]) |
++------------------------------------------+
+| [null, 3, null, 5] |
++------------------------------------------+
+```
+
+Для массивов с единственным элементом возвращаются пустые массивы:
+```sql
+SELECT array_popfront([42]);
++------------------------+
+| array_popfront([42]) |
++------------------------+
+| [] |
++------------------------+
+```
+
+Для пустых массивов возвращаются пустые массивы:
+```sql
+SELECT array_popfront([]);
++------------------------+
+| array_popfront([]) |
++------------------------+
+| [] |
++------------------------+
+```
+
+Для массивов со значением NULL возвращается NULL:
+```sql
+SELECT array_popfront(NULL);
++------------------------+
+| array_popfront(NULL) |
++------------------------+
+| NULL |
++------------------------+
+```
+
+Удаление первого элемента массива IP-адресов:
+```sql
+SELECT array_popfront(CAST(['192.168.1.1', '192.168.1.2', '192.168.1.3'] AS ARRAY<IPV4>));
++----------------------------------------------------------------------------------+
+| array_popfront(CAST(['192.168.1.1', '192.168.1.2', '192.168.1.3'] AS ARRAY<IPV4>)) |
++----------------------------------------------------------------------------------+
+| ["192.168.1.2", "192.168.1.3"] |
++----------------------------------------------------------------------------------+
+```
+
+Удаление первого элемента вложенного массива:
+```sql
+SELECT array_popfront([[1, 2], [3, 4], [5, 6]]);
++------------------------------------------+
+| array_popfront([[1, 2], [3, 4], [5, 6]]) |
++------------------------------------------+
+| [[3, 4], [5, 6]] |
++------------------------------------------+
+```
+
+Удаление первого элемента массива MAP:
+```sql
+SELECT array_popfront([{'name':'Alice','age':20}, {'name':'Bob','age':30}, {'name':'Charlie','age':40}]);
++---------------------------------------------------------------------------------------------------+
+| array_popfront([{'name':'Alice','age':20}, {'name':'Bob','age':30}, {'name':'Charlie','age':40}]) |
++---------------------------------------------------------------------------------------------------+
+| [{"name":"Bob", "age":"30"}, {"name":"Charlie", "age":"40"}] |
++---------------------------------------------------------------------------------------------------+
+```
+
+Удаление первого элемента массива STRUCT:
+```sql
+SELECT array_popfront(array(named_struct('name','Alice','age',20), named_struct('name','Bob','age',30), named_struct('name','Charlie','age',40)));
++-------------------------------------------------------------------------------------------------------------------------------------------+
+| array_popfront(array(named_struct('name','Alice','age',20), named_struct('name','Bob','age',30), named_struct('name','Charlie','age',40))) |
++-------------------------------------------------------------------------------------------------------------------------------------------+
+| [{"name":"Bob", "age":30}, {"name":"Charlie", "age":40}] |
++-------------------------------------------------------------------------------------------------------------------------------------------+
+```
+
+### Ключевые слова {#keywords}
+
+ARRAY, POPFRONT, ARRAY_POPFRONT
diff --git a/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/array-functions/array-position.md b/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/array-functions/array-position.md
new file mode 100644
index 000000000000..ef680f241255
--- /dev/null
+++ b/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/array-functions/array-position.md
@@ -0,0 +1,169 @@
+---
+{
+ "title": "ARRAY_POSITION",
+ "language": "ru",
+ "description": "Находит индекс первого вхождения указанного элемента в массив (нумерация начинается с 1)."
+}
+---
+
+## array_position {#array_position}
+
+<version since="2.0.0">
+
+</version>
+
+## Описание {#description}
+
+Находит индекс первого вхождения указанного элемента в массив (нумерация начинается с 1). Функция просматривает массив слева направо, находит первый совпадающий элемент и возвращает его индекс.
+
+## Синтаксис {#syntax}
+
+```sql
+array_position(ARRAY<T> arr, T element)
+```
+
+### Параметры {#parameters}
+
+- `arr`：тип ARRAY<T>, массив для поиска
+- `element`：тип T, искомый элемент
+
+**Поддерживаемые типы T:**
+- Числовые типы: TINYINT, SMALLINT, INT, BIGINT, LARGEINT, FLOAT, DOUBLE, DECIMAL
+- Строковые типы: CHAR, VARCHAR, STRING
+- Типы даты и времени: DATE, DATETIME, DATEV2, DATETIMEV2, TIMESTAMP_NS
+- Логический тип: BOOLEAN
+- Типы IP-адресов: IPV4, IPV6
+- UUID: [UUID](../../../basic-element/sql-data-types/uuid.md)
+
+### Возвращаемое значение {#return-value}
+
+Тип возвращаемого значения: BIGINT
+
+Значение результата:
+- Возвращает индекс первого вхождения указанного элемента в массив. Нумерация возвращаемых значений начинается с 1, а не с 0. Если искомый элемент является первым элементом массива, функция возвращает 1, а не 0
+- 0: если совпадающий элемент не найден или входной массив равен NULL
+- NULL: если входной массив равен NULL
+
+Примечания по использованию:
+- Функция просматривает массив слева направо и находит первый совпадающий элемент. Если совпадающий элемент не найден, возвращает 0
+- Для пустых массивов возвращается 0
+- Значения null в элементах массива: элементы null сопоставляются как обычно
+
+**Примеры запросов:**
+
+Поиск позиции строки в массиве:
+```sql
+SELECT array_position(['apple', 'banana', 'cherry', 'apple'], 'apple');
++-----------------------------------------------------------------+
+| array_position(['apple', 'banana', 'cherry', 'apple'], 'apple') |
++-----------------------------------------------------------------+
+| 1 |
++-----------------------------------------------------------------+
+```
+
+Поиск позиции числа с плавающей точкой в массиве:
+```sql
+SELECT array_position([1.1, 2.2, 3.3, 4.4, 5.5], 3.3);
++------------------------------------------------+
+| array_position([1.1, 2.2, 3.3, 4.4, 5.5], 3.3) |
++------------------------------------------------+
+| 3 |
++------------------------------------------------+
+```
+
+Поиск отсутствующего элемента:
+```sql
+SELECT array_position([1, 2, 3, 4, 5], 10);
++-------------------------------------+
+| array_position([1, 2, 3, 4, 5], 10) |
++-------------------------------------+
+| 0 |
++-------------------------------------+
+```
+
+Поиск элемента null:
+```sql
+SELECT array_position([1, null, 3, null, 5], null);
++---------------------------------------------+
+| array_position([1, null, 3, null, 5], null) |
++---------------------------------------------+
+| 2 |
++---------------------------------------------+
+```
+
+Для пустого массива возвращается 0:
+```sql
+SELECT array_position([], 1);
++-----------------------+
+| array_position([], 1) |
++-----------------------+
+| 0 |
++-----------------------+
+```
+
+Если входной массив равен NULL, возвращается NULL:
+```sql
+SELECT array_position(NULL, 1);
++-------------------------+
+| array_position(NULL, 1) |
++-------------------------+
+| NULL |
++-------------------------+
+```
+
+Поиск элемента типа даты:
+```sql
+SELECT array_position(cast(['2023-01-01', '2022-12-31', '2023-06-15'] as array<datetime>), '2023-01-01');
++---------------------------------------------------------------------------------------------------+
+| array_position(cast(['2023-01-01', '2022-12-31', '2023-06-15'] as array<datetime>), '2023-01-01') |
++---------------------------------------------------------------------------------------------------+
+| 1 |
++---------------------------------------------------------------------------------------------------+
+```
+
+Поиск IP-адреса:
+```sql
+SELECT array_position(CAST(['192.168.1.1', '192.168.1.2', '192.168.1.3'] AS ARRAY<IPV4>), '192.168.1.2');
++---------------------------------------------------------------------------------------------------+
+| array_position(CAST(['192.168.1.1', '192.168.1.2', '192.168.1.3'] AS ARRAY<IPV4>), '192.168.1.2') |
++---------------------------------------------------------------------------------------------------+
+| 2 |
++---------------------------------------------------------------------------------------------------+
+
+SELECT array_position(CAST(['2001:db8::1', '2001:db8::2', '2001:db8::0'] AS ARRAY<IPV6>), '2001:db8::0');
++---------------------------------------------------------------------------------------------------+
+| array_position(CAST(['2001:db8::1', '2001:db8::2', '2001:db8::0'] AS ARRAY<IPV6>), '2001:db8::0') |
++---------------------------------------------------------------------------------------------------+
+| 3 |
++---------------------------------------------------------------------------------------------------+
+```
+
+Примеры со сложными типами:
+
+Вложенные массивы не поддерживаются, при их использовании возникает ошибка:
+```sql
+SELECT array_position([[1,2], [3,4], [5,6]], [3,4]);
+ERROR 1105 (HY000): errCode = 2, detailMessage = array_position does not support type ARRAY<ARRAY<TINYINT>>, expression is array_position([[1, 2], [3, 4], [5, 6]])
+```
+
+Поиск элемента типа Map:
+```sql
+SELECT array_position([{'k':1}, {'k':2}, {'k':3}], {'k':2});
+ERROR 1105 (HY000): errCode = 2, detailMessage = array_position does not support type ARRAY<MAP<VARCHAR(1),TINYINT>>, expression is array_position([map('k', 1), map('k', 2), map('k', 3)])
+```
+
+Ошибка при неверном количестве параметров:
+```sql
+SELECT array_position([1,2,3]);
+ERROR 1105 (HY000): errCode = 2, detailMessage = Can not found function 'array_position' which has 1 arity. Candidate functions are: [array_position(Expression, Expression)]
+```
+
+Ошибка при передаче значения, которое не является массивом:
+```sql
+SELECT array_position('not_an_array', 1);
+ERROR 1105 (HY000): errCode = 2, detailMessage = Can not find the compatibility function signature: array_position(VARCHAR(12), TINYINT)
+```
+
+### Ключевые слова {#keywords}
+
+ARRAY, POSITION, ARRAY_POSITION
diff --git a/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/array-functions/array-product.md b/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/array-functions/array-product.md
new file mode 100644
index 000000000000..e48acef76809
--- /dev/null
+++ b/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/array-functions/array-product.md
@@ -0,0 +1,138 @@
+---
+{
+ "title": "ARRAY_PRODUCT",
+ "language": "ru",
+ "description": "Вычисляет произведение всех элементов массива. Функция перебирает все элементы массива, перемножает их,"
+}
+---
+
+## array_product {#array_product}
+
+<version since="2.0.0">
+
+</version>
+
+## Описание {#description}
+
+Вычисляет произведение всех элементов массива. Функция перебирает все элементы массива, перемножает их и возвращает результат.
+
+## Синтаксис {#syntax}
+
+```sql
+array_product(ARRAY<T> arr)
+```
+
+### Параметры {#parameters}
+
+- `arr`：массив типа ARRAY<T>, для которого нужно вычислить произведение
+
+**Поддерживаемые типы T:**
+- Числовые типы: TINYINT, SMALLINT, INT, BIGINT, LARGEINT, FLOAT, DOUBLE, DECIMAL
+- Логический тип: BOOLEAN (true преобразуется в 1, false преобразуется в 0)
+
+### Возвращаемое значение {#return-value}
+
+Тип возвращаемого значения: DOUBLE или DECIMAL
+
+Значение результата:
+- Возвращает произведение всех элементов массива
+- NULL: если массив пуст, сам массив равен NULL или все его элементы равны NULL
+
+Особенности использования:
+- Функция пропускает значения NULL в массиве и вычисляет произведение только тех элементов, которые не равны NULL
+- Если все элементы массива равны NULL, возвращается NULL
+- Для пустых массивов возвращается NULL
+- Сложные типы (MAP, STRUCT, ARRAY) не поддерживают вычисление произведения и вызывают ошибки
+- Обработка значений null в элементах массива: элементы null не участвуют в вычислении произведения
+
+**Примеры запросов:**
+
+Вычисление произведения элементов массива целых чисел:
+```sql
+SELECT array_product([1, 2, 3, 4, 5]);
++--------------------------------+
+| array_product([1, 2, 3, 4, 5]) |
++--------------------------------+
+| 120 |
++--------------------------------+
+```
+
+Вычисление произведения элементов массива чисел с плавающей точкой:
+```sql
+SELECT array_product([1.1, 2.2, 3.3, 4.4, 5.5]);
++------------------------------------------+
+| array_product([1.1, 2.2, 3.3, 4.4, 5.5]) |
++------------------------------------------+
+| 193.2612 |
++------------------------------------------+
+```
+
+Вычисление произведения элементов массива, содержащего значения null:
+```sql
+SELECT array_product([1, null, 3, null, 5]);
++----------------------------------------+
+| array_product([1, null, 3, null, 5]) |
++----------------------------------------+
+| 15.0 |
++----------------------------------------+
+```
+
+Вычисление произведения элементов массива логических значений (true=1, false=0):
+```sql
+SELECT array_product([true, false, true, true]);
++------------------------------------------+
+| array_product([true, false, true, true]) |
++------------------------------------------+
+| 0 |
++------------------------------------------+
+```
+
+Для пустых массивов возвращается NULL:
+```sql
+SELECT array_product([]);
++----------------------+
+| array_product([]) |
++----------------------+
+| NULL |
++----------------------+
+```
+
+Для массивов, в которых все элементы равны null, возвращается NULL:
+```sql
+SELECT array_product([null, null, null]);
++----------------------------------+
+| array_product([null, null, null]) |
++----------------------------------+
+| NULL |
++----------------------------------+
+```
+
+Примеры со сложными типами:
+
+Вложенные массивы не поддерживаются и вызывают ошибку:
+```sql
+SELECT array_product([[1,2],[3,4],[5,6]]);
+ERROR 1105 (HY000): errCode = 2, detailMessage: array_product does not support type: ARRAY<ARRAY<TINYINT>>
+```
+
+Типы Map не поддерживаются и вызывают ошибку:
+```sql
+SELECT array_product([{'k':1},{'k':2},{'k':3}]);
+ERROR 1105 (HY000): errCode = 2, detailMessage: array_product does not support type: ARRAY<MAP<VARCHAR(1),TINYINT>>
+```
+
+Ошибка при неверном количестве параметров:
+```sql
+SELECT array_product([1,2,3], [4,5,6]);
+ERROR 1105 (HY000): errCode = 2, detailMessage: Can not found function 'array_product' which has 2 arity. Candidate functions are: [array_product(Expression)]
+```
+
+Ошибка при передаче значений, не являющихся массивами:
+```sql
+SELECT array_product('not_an_array');
+ERROR 1105 (HY000): errCode = 2, detailMessage: Can not find the compatibility function signature: array_product(VARCHAR(12))
+```
+
+### Ключевые слова {#keywords}
+
+ARRAY, PRODUCT, ARRAY_PRODUCT
diff --git a/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/array-functions/array-pushback.md b/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/array-functions/array-pushback.md
new file mode 100644
index 000000000000..0bc481423a06
--- /dev/null
+++ b/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/array-functions/array-pushback.md
@@ -0,0 +1,162 @@
+---
+{
+ "title": "ARRAY_PUSHBACK",
+ "language": "ru",
+ "description": "Добавляет элемент в конец массива. Функция возвращает новый массив, содержащий все элементы исходного массива и добавленный элемент."
+}
+---
+
+## array_pushback {#array_pushback}
+
+<version since="2.0.0">
+
+</version>
+
+## Описание {#description}
+
+Добавляет элемент в конец массива. Функция возвращает новый массив, содержащий все элементы исходного массива и добавленный элемент.
+
+## Псевдоним {#alias}
+
+- array_append
+
+## Синтаксис {#syntax}
+
+```sql
+array_pushback(ARRAY<T> arr, T element)
+```
+
+### Параметры {#parameters}
+
+- `arr`：тип ARRAY<T>, массив, в который добавляется элемент
+- `element`：тип T, элемент, добавляемый в конец массива
+
+**Поддерживаемые типы T:**
+- Числовые типы: TINYINT, SMALLINT, INT, BIGINT, LARGEINT, FLOAT, DOUBLE, DECIMAL
+- Строковые типы: CHAR, VARCHAR, STRING
+- Типы даты и времени: DATE, DATETIME, DATEV2, DATETIMEV2, TIMESTAMP_NS
+- Логический тип: BOOLEAN
+- Типы IP: IPV4, IPV6
+- UUID: [UUID](../../../basic-element/sql-data-types/uuid.md)
+- Сложные типы: ARRAY, MAP, STRUCT
+
+### Возвращаемое значение {#return-value}
+
+Тип возвращаемого значения: ARRAY<T>
+
+Значение результата:
+- Возвращает новый массив, содержащий все элементы исходного массива и добавленный элемент
+- NULL: если входной массив равен NULL
+
+Примечания по использованию:
+- Функция добавляет указанный элемент в конец массива
+- В пустые массивы также можно добавлять элементы; тип нового элемента должен быть совместим с типом элементов массива
+- Элементы массива со значением null обрабатываются обычным образом
+
+**Примеры запросов:**
+
+Добавление элемента в конец массива строк:
+```sql
+SELECT array_pushback(['apple', 'banana', 'cherry'], 'date');
++----------------------------------------------------+
+| array_pushback(['apple', 'banana', 'cherry'], 'date') |
++----------------------------------------------------+
+| ["apple", "banana", "cherry", "date"] |
++----------------------------------------------------+
+```
+
+Добавление элемента null в конец массива, содержащего значения null:
+```sql
+SELECT array_pushback([1, null, 3], null);
++------------------------------------+
+| array_pushback([1, null, 3], null) |
++------------------------------------+
+| [1, null, 3, null] |
++------------------------------------+
+```
+
+Добавление элемента в конец пустого массива:
+```sql
+SELECT array_pushback([], 42);
++--------------------------+
+| array_pushback([], 42) |
++--------------------------+
+| [42] |
++--------------------------+
+```
+
+Добавление элемента в конец массива чисел с плавающей точкой:
+```sql
+SELECT array_pushback([1.1, 2.2, 3.3], 4.4);
++------------------------------------------+
+| array_pushback([1.1, 2.2, 3.3], 4.4) |
++------------------------------------------+
+| [1.1, 2.2, 3.3, 4.4] |
++------------------------------------------+
+```
+
+Для массивов NULL возвращается NULL:
+```sql
+SELECT array_pushback(NULL, 1);
++--------------------------+
+| array_pushback(NULL, 1) |
++--------------------------+
+| NULL |
++--------------------------+
+```
+
+Добавление элемента в конец массива IP-адресов:
+```sql
+SELECT array_pushback(CAST(['192.168.1.1', '192.168.1.2'] AS ARRAY<IPV4>), CAST('192.168.1.3' AS IPV4));
++----------------------------------------------------------------------------------+
+| array_pushback(CAST(['192.168.1.1', '192.168.1.2'] AS ARRAY<IPV4>), CAST('192.168.1.3' AS IPV4)) |
++----------------------------------------------------------------------------------+
+| ["192.168.1.1", "192.168.1.2", "192.168.1.3"] |
++----------------------------------------------------------------------------------+
+```
+
+Добавление элемента в конец вложенного массива:
+```sql
+SELECT array_pushback([[1,2], [3,4]], [5,6]);
++------------------------------------------+
+| array_pushback([[1,2], [3,4]], [5,6]) |
++------------------------------------------+
+| [[1, 2], [3, 4], [5, 6]] |
++------------------------------------------+
+```
+
+Добавление элемента в конец массива MAP:
+```sql
+SELECT array_pushback([{'a':1}, {'b':2}], {'c':3});
++----------------------------------------------+
+| array_pushback([{'a':1}, {'b':2}], {'c':3}) |
++----------------------------------------------+
+| [{"a":1}, {"b":2}, {"c":3}] |
++----------------------------------------------+
+```
+
+Добавление элемента в конец массива STRUCT:
+```sql
+SELECT array_pushback(array(named_struct('name','Alice','age',20), named_struct('name','Bob','age',30)), named_struct('name','Charlie','age',40));
++-------------------------------------------------------------------------------------------------------------------------------------------+
+| array_pushback(array(named_struct('name','Alice','age',20), named_struct('name','Bob','age',30)), named_struct('name','Charlie','age',40)) |
++-------------------------------------------------------------------------------------------------------------------------------------------+
+| [{"name":"Alice", "age":20}, {"name":"Bob", "age":30}, {"name":"Charlie", "age":40}] |
++-------------------------------------------------------------------------------------------------------------------------------------------+
+```
+
+Ошибка при неверном количестве параметров:
+```sql
+SELECT array_pushback([1,2,3]);
+ERROR 1105 (HY000): errCode = 2, detailMessage: Can not found function 'array_pushback' which has 1 arity. Candidate functions are: [array_pushback(Expression, Expression)]
+```
+
+Ошибка при передаче значений, не являющихся массивами:
+```sql
+SELECT array_pushback('not_an_array', 1);
+ERROR 1105 (HY000): errCode = 2, detailMessage: Can not find the compatibility function signature: array_pushback(VARCHAR(12), TINYINT)
+```
+
+### Ключевые слова {#keywords}
+
+ARRAY, PUSHBACK, ARRAY_PUSHBACK
diff --git a/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/array-functions/array-pushfront.md b/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/array-functions/array-pushfront.md
new file mode 100644
index 000000000000..bdb0c045a247
--- /dev/null
+++ b/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/array-functions/array-pushfront.md
@@ -0,0 +1,158 @@
+---
+{
+ "title": "ARRAY_PUSHFRONT",
+ "language": "ru",
+ "description": "Добавляет элемент в начало массива. Функция возвращает новый массив, содержащий добавленный элемент и все элементы исходного массива "
+}
+---
+
+## array_pushfront {#array_pushfront}
+
+<version since="2.0.0">
+
+</version>
+
+## Описание {#description}
+
+Добавляет элемент в начало массива. Функция возвращает новый массив, содержащий добавленный элемент и все элементы исходного массива.
+
+## Синтаксис {#syntax}
+
+```sql
+array_pushfront(ARRAY<T> arr, T element)
+```
+
+### Параметры {#parameters}
+
+- `arr`：тип ARRAY<T>, массив, в который нужно добавить элемент
+- `element`：тип T, элемент, который нужно добавить в начало массива
+
+**Поддерживаемые типы T:**
+- Числовые типы: TINYINT, SMALLINT, INT, BIGINT, LARGEINT, FLOAT, DOUBLE, DECIMAL
+- Строковые типы: CHAR, VARCHAR, STRING
+- Типы даты и времени: DATE, DATETIME, DATEV2, DATETIMEV2, TIMESTAMP_NS
+- Логический тип: BOOLEAN
+- Типы IP: IPV4, IPV6
+- UUID: [UUID](../../../basic-element/sql-data-types/uuid.md)
+- Сложные типы: ARRAY, MAP, STRUCT
+
+### Возвращаемое значение {#return-value}
+
+Тип возвращаемого значения: ARRAY<T>
+
+Значение результата:
+- Возвращается новый массив, содержащий добавленный элемент и все элементы исходного массива
+- NULL: если входной массив имеет значение NULL
+
+Примечания по использованию:
+- Функция добавляет указанный элемент в начало массива
+- В пустые массивы также можно добавлять элементы; тип нового элемента должен быть совместим с типом элементов массива
+- Элементы массива со значением null обрабатываются обычным образом
+
+**Примеры запросов:**
+
+Добавление элемента в начало строкового массива:
+```sql
+SELECT array_pushfront(['banana', 'cherry', 'date'], 'apple');
++--------------------------------------------------------+
+| array_pushfront(['banana', 'cherry', 'date'], 'apple') |
++--------------------------------------------------------+
+| ["apple", "banana", "cherry", "date"] |
++--------------------------------------------------------+
+```
+
+Добавление элемента null в начало массива, содержащего значения null:
+```sql
+SELECT array_pushfront([1, null, 3], null);
++-------------------------------------+
+| array_pushfront([1, null, 3], null) |
++-------------------------------------+
+| [null, 1, null, 3] |
++-------------------------------------+
+```
+
+Добавление элемента в начало пустого массива:
+```sql
+SELECT array_pushfront([], 42);
++--------------------------+
+| array_pushfront([], 42) |
++--------------------------+
+| [42] |
++--------------------------+
+```
+
+Для массивов со значением NULL возвращается NULL:
+```sql
+SELECT array_pushfront(NULL, 1);
++---------------------------+
+| array_pushfront(NULL, 1) |
++---------------------------+
+| NULL |
++---------------------------+
+```
+
+Добавление элемента в начало массива чисел с плавающей точкой:
+```sql
+SELECT array_pushfront([2.2, 3.3, 4.4], 1.1);
++------------------------------------------+
+| array_pushfront([2.2, 3.3, 4.4], 1.1) |
++------------------------------------------+
+| [1.1, 2.2, 3.3, 4.4] |
++------------------------------------------+
+```
+
+Добавление элемента в начало массива IP-адресов:
+```sql
+SELECT array_pushfront(CAST(['192.168.1.2', '192.168.1.3'] AS ARRAY<IPV4>), CAST('192.168.1.1' AS IPV4));
++----------------------------------------------------------------------------------+
+| array_pushfront(CAST(['192.168.1.2', '192.168.1.3'] AS ARRAY<IPV4>), CAST('192.168.1.1' AS IPV4)) |
++----------------------------------------------------------------------------------+
+| ["192.168.1.1", "192.168.1.2", "192.168.1.3"] |
++----------------------------------------------------------------------------------+
+```
+
+Добавление элемента в начало вложенного массива:
+```sql
+SELECT array_pushfront([[3,4], [5,6]], [1,2]);
++------------------------------------------+
+| array_pushfront([[3,4], [5,6]], [1,2]) |
++------------------------------------------+
+| [[1, 2], [3, 4], [5, 6]] |
++------------------------------------------+
+```
+
+Добавление элемента в начало массива MAP:
+```sql
+SELECT array_pushfront([{'b':2}, {'c':3}], {'a':1});
++----------------------------------------------+
+| array_pushfront([{'b':2}, {'c':3}], {'a':1}) |
++----------------------------------------------+
+| [{"a":1}, {"b":2}, {"c":3}] |
++----------------------------------------------+
+```
+
+Добавление элемента в начало массива STRUCT:
+```sql
+SELECT array_pushfront(array(named_struct('name','Bob','age',30), named_struct('name','Charlie','age',40)), named_struct('name','Alice','age',20));
++-------------------------------------------------------------------------------------------------------------------------------------------+
+| array_pushfront(array(named_struct('name','Bob','age',30), named_struct('name','Charlie','age',40)), named_struct('name','Alice','age',20)) |
++-------------------------------------------------------------------------------------------------------------------------------------------+
+| [{"name":"Alice", "age":20}, {"name":"Bob", "age":30}, {"name":"Charlie", "age":40}] |
++-------------------------------------------------------------------------------------------------------------------------------------------+
+```
+
+Ошибка при неверном количестве параметров:
+```sql
+SELECT array_pushfront([1,2,3]);
+ERROR 1105 (HY000): errCode = 2, detailMessage: Can not found function 'array_pushfront' which has 1 arity. Candidate functions are: [array_pushfront(Expression, Expression)]
+```
+
+Ошибка при передаче значения, тип которого не является массивом:
+```sql
+SELECT array_pushfront('not_an_array', 1);
+ERROR 1105 (HY000): errCode = 2, detailMessage: Can not find the compatibility function signature: array_pushfront(VARCHAR(12), TINYINT)
+```
+
+### Ключевые слова {#keywords}
+
+ARRAY, PUSHFRONT, ARRAY_PUSHFRONT
diff --git a/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/array-functions/array-range.md b/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/array-functions/array-range.md
new file mode 100644
index 000000000000..64e22c9f6e0d
--- /dev/null
+++ b/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/array-functions/array-range.md
@@ -0,0 +1,117 @@
+---
+{
+ "title": "ARRAY_RANGE",
+ "language": "ru",
+ "description": "Создаёт массив чисел или значений даты и времени, образующих арифметическую последовательность."
+}
+---
+
+<a id="function"></a>
+
+## Описание {#description}
+
+Создаёт массив чисел или значений даты и времени, образующих арифметическую последовательность. Результат включает начальное значение и не включает конечное. Возвращает NULL, если любой из аргументов равен NULL.
+
+В серии Doris 4.1 начиная с версии 4.1.5 последовательности значений даты и времени сохраняют все допустимые значения, меньшие конечного, даже если между последним значением и конечным остаётся меньше полного интервала. В более ранних версиях эти значения в конце последовательности могли пропускаться.
+
+## Синтаксис {#syntax}
+
+```sql
+ARRAY_RANGE(<end>)
+ARRAY_RANGE(<start>, <end> [, <step>])
+ARRAY_RANGE(<start_dt>, <end_dt> [, INTERVAL <step> <unit>])
+```
+
+## Параметры {#parameters}
+
+| Параметр | Описание |
+| --- | --- |
+| `<start>` | Необязательное неотрицательное начальное значение типа INT. По умолчанию: 0. |
+| `<end>` | Неотрицательное конечное значение типа INT, не включаемое в результат. |
+| `<step>` | Необязательный шаг, заданный положительным целым числом. По умолчанию: 1. |
+| `<start_dt>`, `<end_dt>` | Начальное и конечное значения типа DATETIME или TIMESTAMP_NS. Оба аргумента должны иметь одинаковый тип. Конечное значение не включается в результат. Без INTERVAL шаг составляет 1 DAY. |
+| `<unit>` | Единица шага для значений даты и времени: YEAR, QUARTER, MONTH, WEEK, DAY, HOUR, MINUTE или SECOND. |
+
+## Возвращаемое значение {#return-value}
+
+Возвращает ARRAY. Числовые последовательности содержат элементы типа INT; последовательности значений даты и времени содержат элементы входного типа DATETIME или TIMESTAMP_NS.
+
+<a id="usage-notes"></a>
+
+- Возвращает NULL, если любой из аргументов равен NULL или недопустим, например если числовое начальное или конечное значение отрицательно либо шаг неположителен.
+- Возвращает пустой массив `[]`, если начальное значение больше или равно конечному.
+- Каждое следующее значение вычисляется на основе предыдущего. При операциях с месяцами дата может быть скорректирована до последнего дня целевого месяца.
+- Выдаёт ошибку, если последовательность превышает предельный размер массива. Если следующее значение выходит за диапазон типа даты, генерация останавливается после последнего допустимого значения.
+- `SEQUENCE` является псевдонимом `ARRAY_RANGE`.
+
+<a id="examples"></a>
+
+## Пример {#example}
+
+Числовые последовательности не включают конечное значение:
+
+```sql
+SELECT ARRAY_RANGE(5), ARRAY_RANGE(2, 6, 2), ARRAY_RANGE(3, 2);
+```
+
+```text
+[0, 1, 2, 3, 4] [2, 4] []
+```
+
+Последовательности значений даты и времени по умолчанию используют шаг в один день. Последнее значение сохраняется, даже если до конечного значения остаётся меньше одного дня:
+
+```sql
+SELECT ARRAY_RANGE(
+ CAST('2024-01-01 00:00:00.000000' AS DATETIME(6)),
+ CAST('2024-01-02 12:00:00.000000' AS DATETIME(6)));
+```
+
+```text
+["2024-01-01 00:00:00.000000", "2024-01-02 00:00:00.000000"]
+```
+
+При шаге в один месяц следующее значение вычисляется прибавлением месяца к ранее сгенерированной дате:
+
+```sql
+SELECT ARRAY_RANGE(
+ CAST('2020-01-31 00:00:00' AS DATETIME(6)),
+ CAST('2020-03-30 00:00:00' AS DATETIME(6)), INTERVAL 1 MONTH);
+```
+
+```text
+["2020-01-31 00:00:00.000000", "2020-02-29 00:00:00.000000", "2020-03-29 00:00:00.000000"]
+```
+
+Для `SEQUENCE` действуют те же правила:
+
+```sql
+SELECT SEQUENCE(
+ CAST('2024-01-01 00:00:00.000000' AS DATETIME(6)),
+ CAST('2024-01-01 00:00:01.500000' AS DATETIME(6)), INTERVAL 1 SECOND);
+```
+
+```text
+["2024-01-01 00:00:00.000000", "2024-01-01 00:00:01.000000"]
+```
+
+Аргументы со значением NULL или недопустимые аргументы:
+
+```sql
+SELECT ARRAY_RANGE(NULL), ARRAY_RANGE(-1, 3), ARRAY_RANGE(1, 3, 0);
+```
+
+```text
+NULL NULL NULL
+```
+
+При входных значениях типа TIMESTAMP_NS сохраняется наносекундная точность:
+
+```sql
+SELECT ARRAY_RANGE(
+ CAST('2022-05-15 12:00:00.123456789' AS TIMESTAMP_NS),
+ CAST('2022-05-15 12:00:02.123456789' AS TIMESTAMP_NS), INTERVAL 1 SECOND);
+```
+
+```text
+["2022-05-15 12:00:00.123456789", "2022-05-15 12:00:01.123456789"]
+```
diff --git a/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/array-functions/array-remove.md b/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/array-functions/array-remove.md
new file mode 100644
index 000000000000..32a50aff5d84
--- /dev/null
+++ b/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/array-functions/array-remove.md
@@ -0,0 +1,44 @@
+---
+{
+ "title": "ARRAY_REMOVE",
+ "language": "ru",
+ "description": "Удаляет из массива все элементы, равные заданному значению, сохраняя относительный порядок оставшихся элементов."
+}
+---
+
+## Назначение {#function}
+
+Удаляет из массива все элементы, равные заданному значению, сохраняя относительный порядок оставшихся элементов.
+
+## Синтаксис {#syntax}
+
+- `ARRAY_REMOVE(arr, target)`
+
+## Параметры {#parameters}
+
+- `arr`: `ARRAY<T>`, поддерживает числа, типы boolean, string, datetime, IP, UUID и другие.
+- `target`: значение того же типа, что и элементы массива, используемое для поиска элементов, которые нужно удалить.
+
+## Возвращаемое значение {#return-value}
+
+- Возвращает `ARRAY<T>` того же типа, что и входной массив.
+- Если `arr` имеет значение `NULL`, возвращает `NULL`.
+
+## Примечания по использованию {#usage-notes}
+
+- Правило сопоставления: удаляются только элементы, значение которых равно `target`. `NULL` равен `NULL`.
+
+## Примеры {#examples}
+
+- Базовый пример: после удаления оставшиеся элементы сохраняют исходный относительный порядок.
+ - `ARRAY_REMOVE([1,2,3], 1)` -> `[2,3]`
+ - `ARRAY_REMOVE([1,2,3,null], 1)` -> `[2,3,null]`
+
+- Если `target` имеет значение `NULL`, удаляются значения `NULL` из `arr`.
+ - `ARRAY_REMOVE(['a','b','c',NULL], NULL)` -> `NULL`
+
+- Если `arr` имеет значение `NULL`, возвращает `NULL`
+ - `ARRAY_REMOVE(NULL, 2)` -> `NULL`
+
+- Совпадений нет
+ - `ARRAY_REMOVE([1,2,3], 258)` -> `[1,2,3]`
diff --git a/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/array-functions/array-repeat.md b/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/array-functions/array-repeat.md
new file mode 100644
index 000000000000..27d8d2638e96
--- /dev/null
+++ b/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/array-functions/array-repeat.md
@@ -0,0 +1,83 @@
+---
+{
+ "title": "ARRAY_REPEAT",
+ "language": "ru",
+ "description": "ARRAYREPEAT используется для создания массива заданной длины, все элементы которого имеют указанное значение."
+}
+---
+
+## Функция {#function}
+
+`ARRAY_REPEAT` используется для создания массива заданной длины, все элементы которого имеют указанное значение.
+
+## Синтаксис {#syntax}
+
+```SQL
+ARRAY_REPEAT(element, count)
+```
+
+## Параметры {#parameters}
+
+- `element`: Любой тип данных, поддерживаемый в `ARRAY`.
+
+- `count`: Целочисленный тип, задаёт длину возвращаемого массива.
+
+
+## Возвращаемое значение {#return-value}
+
+- Возвращает массив типа `ARRAY<T>`, где `T` обозначает тип `element`.
+ - Массив содержит `count` копий одного и того же `element`.
+
+## Примечания по использованию {#usage-notes}
+
+- При `count = 0` или `NULL` возвращается пустой массив.
+- Если `element` имеет значение `NULL`, все элементы массива равны `NULL`.
+- Эта функция выполняет ту же задачу, что и `ARRAY_WITH_CONSTANT`, но порядок параметров обратный.
+
+## Примеры {#examples}
+
+1. Простой пример
+
+ ```SQL
+ SELECT ARRAY_REPEAT('hello', 3);
+ +---------------------------------+
+ | ARRAY_REPEAT('hello', 3) |
+ +---------------------------------+
+ | ["hello", "hello", "hello"] |
+ +---------------------------------+
+ ```
+
+2. Особые случаи
+
+ ```SQL
+ SELECT ARRAY_REPEAT('hello', 0);
+ +---------------------------------+
+ | ARRAY_REPEAT('hello', 0) |
+ +---------------------------------+
+ | [] |
+ +---------------------------------+
+
+ SELECT ARRAY_REPEAT('hello', NULL);
+ +------------------------------------+
+ | ARRAY_REPEAT('hello', NULL) |
+ +------------------------------------+
+ | [] |
+ +------------------------------------+
+
+ SELECT ARRAY_REPEAT(NULL, 2);
+ +------------------------------+
+ | ARRAY_REPEAT(NULL, 2) |
+ +------------------------------+
+ | [null, null] |
+ +------------------------------+
+
+ SELECT ARRAY_REPEAT(NULL, NULL);
+ +---------------------------------+
+ | ARRAY_REPEAT(NULL, NULL) |
+ +---------------------------------+
+ | [] |
+ +---------------------------------+
+
+ -- Returns error: INVALID_ARGUMENT
+ SELECT ARRAY_REPEAT('hello', -1);
+ ```
diff --git a/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/array-functions/array-reverse-sort.md b/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/array-functions/array-reverse-sort.md
new file mode 100644
index 000000000000..5d84f93c1be8
--- /dev/null
+++ b/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/array-functions/array-reverse-sort.md
@@ -0,0 +1,41 @@
+---
+{
+ "title": "ARRAY_REVERSE_SORT",
+ "language": "ru",
+ "description": "Сортирует элементы массива по убыванию."
+}
+---
+
+## Назначение {#function}
+
+Сортирует элементы массива по убыванию.
+
+## Синтаксис {#syntax}
+
+- `ARRAY_REVERSE_SORT(arr)`
+
+## Параметры {#parameters}
+
+- `arr`: `ARRAY<T>`, где `T` — один из поддерживаемых типов: числовой, логический, строковый, datetime, IP, UUID и т. д. Поддерживаются многомерные массивы, но все элементы массива (независимо от глубины вложенности) должны иметь поддерживаемые типы.
+
+## Возвращаемое значение {#return-value}
+
+- Возвращает `ARRAY<T>` того же типа, что и входной массив.
+- Элементы `NULL` помещаются в конец возвращаемого массива.
+
+## Примечания по использованию {#usage-notes}
+
+- Если входное значение — `NULL`, возвращает `NULL`; если на вход подан пустой массив `[]`, возвращает пустой массив.
+- `ARRAY_REVERSE_SORT` сортирует по убыванию, а `ARRAY_SORT` — по возрастанию.
+
+## Примеры {#examples}
+
+- Базовый пример: элементы `NULL` помещаются в конец возвращаемого массива
+ - `ARRAY_REVERSE_SORT([1,2,3,null])` -> `[3,2,1,null]`
+
+- Если входное значение — `NULL`, возвращает `NULL`; если на вход подан пустой массив `[]`, возвращает пустой массив.
+ - `ARRAY_REVERSE_SORT(NULL)` -> `NULL`
+ - `ARRAY_REVERSE_SORT([])` -> `[]`
+
+- Сортировка многомерного массива
+ - `ARRAY_REVERSE_SORT([[3, 4], [5, 6]])` -> `[[5, 6], [3, 4]]`
diff --git a/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/array-functions/array-reverse-split.md b/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/array-functions/array-reverse-split.md
new file mode 100644
index 000000000000..b1ebc8ad2156
--- /dev/null
+++ b/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/array-functions/array-reverse-split.md
@@ -0,0 +1,53 @@
+---
+{
+ "title": "ARRAY_REVERSE_SPLIT",
+ "language": "ru",
+ "description": "Разбивает входной массив на несколько подмассивов в соответствии с заданными логическими флагами."
+}
+---
+
+## Назначение {#function}
+
+Разбивает входной массив на несколько подмассивов в соответствии с заданными логическими флагами.
+
+- Правило разбиения (слева направо): для `arr=[a1,a2,...,an]` и `flags=[f1,f2,...,fn]` в каждой позиции, где `fi==true`, разбиение выполняется между `ai` и `a(i+1)`.
+ - Например, для `arr=[3, 4, 5]` и `flags=[false, true, false]` второй флаг равен true, поэтому разбиение выполняется между вторым и третьим элементами. В результате получаются два подмассива: `[3, 4]` и `[5]`.
+
+## Синтаксис {#syntax}
+
+- `ARRAY_REVERSE_SPLIT(arr, flags)`
+- `ARRAY_REVERSE_SPLIT(lamda, arr0, ...)`
+- `ARRAY_REVERSE_SPLIT(lambda, arr0, ...)` эквивалентно `ARRAY_REVERSE_SPLIT(arr0, ARRAY_MAP(lambda, arr0, ...))`
+
+## Параметры {#parameters}
+
+- `arr`: `ARRAY<T>`.
+- `flags`: `ARRAY<BOOLEAN>`, длина которого должна совпадать с длиной `arr` в каждой строке. `true` означает разбиение между текущим и следующим элементами.
+- `arr0, ...`: один или несколько массивов `ARRAY<T>`.
+- `lambda`: выражение `lambda`, применяемое к `arr0, ...` для получения `flags`, которые затем используются для разбиения.
+
+## Возвращаемое значение {#return-value}
+
+- Возвращает `ARRAY<ARRAY<T>>`. Элементы вложенных массивов совпадают с элементами `arr`.
+- Если количество элементов в `arr` и `flags` не совпадает, возникает ошибка.
+
+## Примечания по использованию {#usage-notes}
+
+- Если значение в какой-либо позиции `flags` равно `NULL`, разбиение в этой позиции не выполняется (эквивалентно `false`).
+- Правило разбиения для `ARRAY_REVERSE_SPLIT`: в каждой позиции, где `fi==true`, разбиение выполняется между `ai` и `a(i+1)`.
+- Правило разбиения для `ARRAY_SPLIT`: в каждой позиции, где `fi==true`, разбиение выполняется между `ai` и `a(i-1)`.
+
+## Примеры {#examples}
+
+- Базовое разбиение: в каждой позиции со значением `true` разбиение выполняется между текущим элементом и его правым соседом.
+ - `ARRAY_REVERSE_SPLIT([1,2,3,4,5], [false,true,false,true,false])` -> `[[1,2], [3,4], [5]]`
+ - `ARRAY_REVERSE_SPLIT(['a','b','c'], [false,false,false])` -> `[['a','b','c']]`
+
+- При наличии `NULL` в `flags`: `NULL` обрабатывается так же, как `false` (без разбиения).
+ - `ARRAY_REVERSE_SPLIT([1,NULL,3], [false,null,false])` -> `[[1, NULL, 3]]`
+
+- `lambda= x -> x-1` при применении к `arr=[1, 2, 3]` даёт `flags=[0,1,2]`, что эквивалентно `flags=[false,true,true]`
+ - `ARRAY_REVERSE_SPLIT(x->x-1, [1, 2, 3])` эквивалентно `ARRAY_REVERSE_SPLIT([1, 2, 3], [false,true,true])` -> `[[1, 2], [3]]`
+
+- `lambda= (x,y) -> x-y` при применении к `arr=[1, 2, 3]` и `arr1=[0,1,2]` даёт `flags=[true,true,true]`
+ - `ARRAY_REVERSE_SPLIT((x,y) -> x-y, [1, 2, 3], [0, 1, 2])` эквивалентно `ARRAY_REVERSE_SPLIT([1, 2, 3], [true,true,true])` -> `[[1], [2], [3]]`
diff --git a/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/array-functions/array-shuffle.md b/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/array-functions/array-shuffle.md
new file mode 100644
index 000000000000..64c00112fdc7
--- /dev/null
+++ b/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/array-functions/array-shuffle.md
@@ -0,0 +1,76 @@
+---
+{
+ "title": "ARRAY_SHUFFLE",
+ "language": "ru",
+ "description": "Случайным образом меняет порядок элементов в массиве."
+}
+---
+
+<a id="function"></a>
+
+## Описание {#description}
+
+Случайным образом меняет порядок элементов в массиве, сохраняя сами элементы и их количество. Возвращает NULL, если входной массив или начальное значение генератора имеет значение NULL. `SHUFFLE` — псевдоним этой функции.
+
+:::caution Изменение поведения (4.1.5)
+
+В ветке Doris 4.1 начиная с версии 4.1.5 параметр `seed` должен быть константой. Он принимает любое значение BIGINT, включая отрицательные значения, и использует все 64 бита. Константные массивы также перемешиваются отдельно для каждой строки, поэтому одно и то же начальное значение генератора может давать результат, отличающийся от результатов в более ранних версиях. В более ранних версиях 4.1 использовалось только начальное значение генератора из первой строки каждого пакета, отрицател [...]
+
+:::
+
+## Синтаксис {#syntax}
+
+```sql
+ARRAY_SHUFFLE(<arr> [, <seed>])
+```
+
+## Параметры {#parameters}
+
+| Параметр | Описание |
+| --- | --- |
+| `<arr>` | Массив типа ARRAY, элементы которого нужно перемешать. |
+| `<seed>` | Необязательное константное начальное значение генератора случайных чисел типа BIGINT. Поддерживаются константные выражения. Если параметр не указан, для каждого пакета используется новое случайное начальное значение генератора. |
+
+## Возвращаемое значение {#return-value}
+
+Возвращает массив того же типа, что и входной, с элементами в случайном порядке. Количество и типы элементов сохраняются. Возвращает NULL, если массив или начальное значение генератора имеет значение NULL, и пустой массив, если входной массив пуст.
+
+<a id="usage-notes"></a>
+
+Строки обрабатываются пакетами. Если задано начальное значение генератора, каждый пакет начинает генерацию случайной последовательности с этого значения, а строки пакета используют её по порядку. Поэтому перестановка элементов в строке может зависеть от границ пакетов. Указание начального значения генератора не гарантирует одинаковых перестановок для одинаковых массивов. Константные массивы также перемешиваются отдельно для каждой строки.
+
+<a id="examples"></a>
+
+## Пример {#example}
+
+Сортировка перемешанного массива подтверждает, что его элементы сохраняются. Допускаются как отрицательные начальные значения генератора, так и константные выражения:
+
+```sql
+SELECT ARRAY_SORT(ARRAY_SHUFFLE([1, 2, 3, 4], -1)),
+ ARRAY_SORT(ARRAY_SHUFFLE([1, 2, 3, 4], 1 + 1));
+```
+
+```text
+[1, 2, 3, 4] [1, 2, 3, 4]
+```
+
+NULL и пустые массивы:
+
+```sql
+SELECT ARRAY_SHUFFLE(CAST(NULL AS ARRAY<INT>), 1),
+ ARRAY_SHUFFLE([1, 2, 3], NULL), ARRAY_SHUFFLE([], 1);
+```
+
+```text
+NULL NULL []
+```
+
+Использование столбца в качестве начального значения генератора приводит к ошибке, содержащей следующий текст:
+
+```sql
+SELECT ARRAY_SHUFFLE([1, 2, 3], number) FROM numbers("number" = "2");
+```
+
+```text
+The seed of array_shuffle must be a constant
+```
diff --git a/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/array-functions/array-size.md b/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/array-functions/array-size.md
new file mode 100644
index 000000000000..9e9c9ec00a82
--- /dev/null
+++ b/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/array-functions/array-size.md
@@ -0,0 +1,36 @@
+---
+{
+ "title": "ARRAY_SIZE",
+ "language": "ru",
+ "description": "Возвращает количество элементов в массиве."
+}
+---
+
+## Назначение {#function}
+
+Возвращает количество элементов в массиве.
+
+## Синтаксис {#syntax}
+
+- `ARRAY_SIZE(arr)`
+
+## Параметры {#parameters}
+
+- `arr`: `ARRAY<T>`.
+
+## Возвращаемое значение {#return-value}
+
+- Возвращает количество элементов в `arr`.
+
+## Примечания по использованию {#usage-notes}
+
+- Если входной массив `arr` равен `NULL`, возвращает `NULL`.
+
+## Примеры {#examples}
+
+- Массивы:
+ - `ARRAY_SIZE([1, 2, 3])` -> `3`
+ - `ARRAY_SIZE(['a', NULL, 'b'])` -> `3`
+
+- Если входной массив `arr` равен `NULL`, возвращает `NULL`
+ - `ARRAY_SIZE(NULL)` -> `NULL`
diff --git a/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/array-functions/array-slice.md b/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/array-functions/array-slice.md
new file mode 100644
index 000000000000..d3e4b76e341e
--- /dev/null
+++ b/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/array-functions/array-slice.md
@@ -0,0 +1,53 @@
+---
+{
+ "title": "ARRAY_SLICE",
+ "language": "ru",
+ "description": "Возвращает подмассив с возможностью указать начальное смещение и длину."
+}
+---
+
+## Назначение {#function}
+
+Возвращает подмассив с возможностью указать начальное смещение и длину.
+
+## Синтаксис {#syntax}
+
+- `ARRAY_SLICE(arr, offset)`
+- `ARRAY_SLICE(arr, offset, length)`
+
+## Параметры {#parameters}
+
+- `arr`: `ARRAY<T>`.
+- `offset`: начальная позиция. Положительные значения отсчитываются от начала (`1` — первый элемент); отрицательные значения отсчитываются от конца (`-1` — последний элемент).
+- `length`: количество выбираемых элементов. При положительном значении выбирается `length` элементов; отрицательное значение обрабатывается как длина 0.
+
+## Возвращаемое значение {#return-value}
+
+- Возвращает `ARRAY<T>` того же типа, что и входной массив.
+
+## Примечания по использованию {#usage-notes}
+
+- Выход за границы обрабатывается безопасно: начальная и конечная позиции ограничиваются границами массива. Если выбранный диапазон не пересекается с массивом, возвращается пустой массив.
+
+## Примеры {#examples}
+
+- Положительное начальное смещение: от указанной позиции до конца массива
+ - `ARRAY_SLICE([1,2,3,4,5,6], 2)` -> `[2,3,4,5,6]`
+
+- Отрицательное начальное смещение: от указанной позиции до конца массива
+ - `ARRAY_SLICE([1,2,3,4,5,6], -3)` -> `[4,5,6]`
+
+- Положительная длина: выборка элементов вправо от начальной позиции
+ - `ARRAY_SLICE([1,2,3,4,5,6], 2, 3)` -> `[2,3,4]`
+ - `ARRAY_SLICE([1,2,3,4,5,6], -4, 2)` -> `[3,4]`
+
+- Отрицательная длина: обрабатывается как длина 0
+ - `ARRAY_SLICE([1,2,3,4,5,6], 2, -2)` -> `[]`
+
+- Аргументы за пределами диапазона: возвращается пустой массив
+ - `ARRAY_SLICE([1,2,3,4,5,6], 10, 3)` -> `[]`
+
+- Если любой аргумент равен `NULL`, возвращается `NULL`
+ - `ARRAY_SLICE([1,2,3], NULL, 2)` -> `NULL`
+ - `ARRAY_SLICE([1,2,3], 2, NULL)` -> `NULL`
+ - `ARRAY_SLICE(NULL, 2, 3)` -> `NULL`
diff --git a/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/array-functions/array-sort.md b/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/array-functions/array-sort.md
new file mode 100644
index 000000000000..c109dbd7cae7
--- /dev/null
+++ b/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/array-functions/array-sort.md
@@ -0,0 +1,204 @@
+---
+{
+ "title": "ARRAY_SORT",
+ "language": "ru",
+ "description": "Если лямбда-функция не указана, элементы массива сортируются по возрастанию. В противном случае,"
+}
+---
+
+<a id="function"></a>
+
+## Описание {#description}
+
+Если лямбда-функция не указана, элементы массива сортируются по возрастанию. В противном случае сортировка выполняется в соответствии с лямбда-функцией.
+
+## Синтаксис {#syntax}
+
+```sql
+ARRAY_SORT(<arr>)
+ARRAY_SORT(<lambda>, <arr>)
+```
+
+## Параметры {#parameters}
+
+| Параметр | Описание |
+| --- | --- |
+| `<arr>` | ARRAY, элементы которого могут быть числами, логическими значениями, строками, значениями даты и времени, IP, UUID или значениями других поддерживаемых типов. Поддерживаются многомерные массивы, но все вложенные элементы должны относиться к этим поддерживаемым типам. |
+| `<lambda>` | Необязательный компаратор, который принимает два элемента и возвращает -1, 0 или 1, если первый элемент соответственно меньше второго, равен ему или больше него. |
+
+## Возвращаемое значение {#return-value}
+
+- Если выражение `lambda` отсутствует
+ - Возвращает `ARRAY<T>` того же типа, что и входной массив.
+ - Элементы `NULL` помещаются в начало возвращаемого массива.
+- Если выражение `lambda` присутствует, сортирует элементы в соответствии с лямбда-выражением и возвращает `ARRAY<T>` того же типа, что и входной массив.
+
+В линейке Doris 4.1 начиная с версии 4.1.5 при использовании компаратора, который ссылается на аргумент внешней лямбда-функции или на другой столбец, явно выдаётся ошибка. Компаратор может использовать только два собственных аргумента, а вложенная в него лямбда-функция не может захватывать эти аргументы компаратора. Это ограничение не затрагивает обычный захват аргументов вложенными лямбда-функциями в `ARRAY_MAP`.
+
+## Примечания по использованию {#usage-notes}
+
+- Если выражение `lambda` отсутствует
+ - Если входное значение — `NULL`, возвращает `NULL`; если на вход подан пустой массив `[]`, возвращает пустой массив.
+ - `ARRAY_SORT` сортирует по возрастанию, а `ARRAY_REVERSE_SORT` — по убыванию.
+- Если выражение `lambda` присутствует
+ - Значение выражения `lambda` должно быть -1, 0 или 1. При наличии значения `NULL` необходимо явно указать, следует ли помещать значение `NULL` в начало или в конец массива.
+
+<a id="examples"></a>
+
+## Пример {#example}
+
+1. Базовый пример: элементы `NULL` помещаются в начало возвращаемого массива
+
+```sql
+SELECT ARRAY_SORT([2,1,3,null]);
+```
+
+```text
++--------------------------+
+| ARRAY_SORT([2,1,3,null]) |
++--------------------------+
+| [null, 1, 2, 3] |
++--------------------------+
+```
+
+2. Если входное значение — `NULL`, возвращает `NULL`; если на вход подан пустой массив `[]`, возвращает пустой массив.
+
+```sql
+SELECT ARRAY_SORT(NULL);
+```
+
+```text
++------------------+
+| ARRAY_SORT(NULL) |
++------------------+
+| NULL |
++------------------+
+```
+
+```sql
+SELECT ARRAY_SORT([]);
+```
+
+```text
++----------------+
+| ARRAY_SORT([]) |
++----------------+
+| [] |
++----------------+
+```
+
+3. Использование выражений `lambda`
+
+```sql
+SELECT array_sort((x, y) -> IF(x < y, 1, IF(x = y, 0, -1)), [3, 2, 5, 1, 2]);
+```
+
+```text
++-----------------------------------------------------------------------+
+| array_sort((x, y) -> IF(x < y, 1, IF(x = y, 0, -1)), [3, 2, 5, 1, 2]) |
++-----------------------------------------------------------------------+
+| [5, 3, 2, 2, 1] |
++-----------------------------------------------------------------------+
+```
+
+```sql
+SELECT array_sort((x, y) -> IF(x < y, 1, IF(x = y, 0, -1)), ['bc', 'ab', 'dc']);
+```
+
+```text
++--------------------------------------------------------------------------+
+| array_sort((x, y) -> IF(x < y, 1, IF(x = y, 0, -1)), ['bc', 'ab', 'dc']) |
++--------------------------------------------------------------------------+
+| ["dc", "bc", "ab"] |
++--------------------------------------------------------------------------+
+```
+
+```sql
+SELECT array_sort((x, y) -> CASE WHEN x IS NULL THEN -1
+ WHEN y IS NULL THEN 1
+ WHEN x < y THEN 1
+ WHEN x = y THEN 0
+ ELSE -1 END,
+ [3, 2, null, 5, null, 1, 2]);
+```
+
+```text
++------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| array_sort((x, y) -> CASE WHEN x IS NULL THEN -1
+ WHEN y IS NULL THEN 1
+ WHEN x < y THEN 1
+ WHEN x = y THEN 0
+ ELSE -1 END,
+ [3, 2, null, 5, null, 1, 2]) |
++------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| [null, null, 5, 3, 2, 2, 1] |
++------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+```
+
+```sql
+SELECT array_sort((x, y) -> CASE WHEN x IS NULL THEN 1
+ WHEN y IS NULL THEN -1
+ WHEN x < y THEN 1
+ WHEN x = y THEN 0
+ ELSE -1 END,
+ [3, 2, null, 5, null, 1, 2]);
+```
+
+```text
++------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| array_sort((x, y) -> CASE WHEN x IS NULL THEN 1
+ WHEN y IS NULL THEN -1
+ WHEN x < y THEN 1
+ WHEN x = y THEN 0
+ ELSE -1 END,
+ [3, 2, null, 5, null, 1, 2]) |
++------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| [5, 3, 2, 2, 1, null, null] |
++------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+```
+
+```sql
+SELECT array_sort((x, y) -> IF(length(x) < length(y), -1,
+ IF(length(x) = length(y), 0, 1)),
+ ['a', 'abcd', 'abc']);
+```
+
+```text
++--------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| array_sort((x, y) -> IF(length(x) < length(y), -1,
+ IF(length(x) = length(y), 0, 1)),
+ ['a', 'abcd', 'abc']) |
++--------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| ["a", "abc", "abcd"] |
++--------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+```
+
+```sql
+SELECT array_sort((x, y) -> IF(cardinality(x) < cardinality(y), -1,
+ IF(cardinality(x) = cardinality(y), 0, 1)),
+ [[2, 3, 1], [4, 2, 1, 4], [1, 2]]);
+```
+
+```text
++-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| array_sort((x, y) -> IF(cardinality(x) < cardinality(y), -1,
+ IF(cardinality(x) = cardinality(y), 0, 1)),
+ [[2, 3, 1], [4, 2, 1, 4], [1, 2]]) |
++-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| [[1, 2], [2, 3, 1], [4, 2, 1, 4]] |
++-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+```
+
+4. Сортировка многомерного массива
+
+```sql
+SELECT ARRAY_SORT([[6, 2], [5, 6]]);
+```
+
+```text
++------------------------------+
+| ARRAY_SORT([[6, 2], [5, 6]]) |
++------------------------------+
+| [[5, 6], [6, 2]] |
++------------------------------+
+```
diff --git a/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/array-functions/array-sortby.md b/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/array-functions/array-sortby.md
new file mode 100644
index 000000000000..b3172882b14e
--- /dev/null
+++ b/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/array-functions/array-sortby.md
@@ -0,0 +1,51 @@
+---
+{
+ "title": "ARRAY_SORTBY",
+ "language": "ru",
+ "description": "Сортирует массив значений в соответствии с порядком элементов массива ключей."
+}
+---
+
+## Функция {#function}
+
+Сортирует массив `values` в соответствии с порядком элементов массива `keys`.
+- Например, если `keys` равен `[3, 0, 2]`, а `values` равен `[5, 7, 8]`, после сортировки `keys` становится `[0, 2, 3]`, а соответствующий массив `values` становится `[7, 8, 5]`.
+
+## Синтаксис {#syntax}
+
+- `ARRAY_SORTBY(values, keys)`
+- `ARRAY_SORTBY(lambda, values)`
+- `ARRAY_SORTBY(lambda, values)` эквивалентно `ARRAY_SORTBY(values, ARRAY_MAP(lambda, values))`
+
+## Параметры {#parameters}
+
+- `values`: `ARRAY<T>`, массив значений для сортировки. Для `T` поддерживаются числовые, логические и строковые типы, datetime, IP, UUID и т. д. Поддерживаются многомерные массивы, но все элементы массива (независимо от глубины вложенности) должны иметь поддерживаемые типы.
+- `keys`: `ARRAY<T>`, массив ключей той же длины, что и `values`. Для `T` поддерживаются числовые, логические и строковые типы, datetime, IP, UUID и т. д. Поддерживаются многомерные массивы, но все элементы массива (независимо от глубины вложенности) должны иметь поддерживаемые типы.
+- `lambda`: выражение `lambda`, применяемое к `values` для получения массива `keys`, используемого при сортировке.
+
+## Возвращаемое значение {#return-value}
+
+- Возвращает `ARRAY<T>` того же типа, что и `values`.
+- Если хотя бы в одной строке количество элементов в `values` и `keys` различается, возникает ошибка.
+
+## Примечания по использованию {#usage-notes}
+
+- Стабильность: элементы `values` переупорядочиваются по возрастанию `keys`. Относительный порядок элементов с одинаковыми ключами не определён.
+- При вызовах функций высшего порядка сначала вычисляется массив `keys` с помощью `ARRAY_MAP`, затем `values` сортируется по `keys`.
+
+## Примеры {#examples}
+
+- Базовый пример: сортировка `values` по возрастанию `keys`.
+ - `ARRAY_SORTBY([10,20,30], [3,1,2])` -> `[20,30,10]`
+ - `ARRAY_SORTBY(['a','b','c'], [2,2,1])` -> `['c','a','b']`
+
+- Функция высшего порядка: вычисление `keys` с помощью `lambda` и последующая сортировка.
+ - `ARRAY_SORTBY(x -> x + 1, [3,1,2])` -> `[1,2,3]` (при значении `keys`, равном `[4,2,3]`)
+ - `ARRAY_SORTBY(x -> x*2 <= 2, [1,2,3])` -> `[2,3,1]` (при значении `keys`, равном `[true,false,false]`)
+
+- Если `keys` или `values` имеет значение `NULL`, возвращается `values` без изменений.
+ - `array_sortby([10,20,30], NULL)` -> `[10, 20, 30]`
+ - `array_sortby(NULL, [2,3])` -> `NULL`
+
+- Сортировка многомерных массивов: правила сортировки ключей определяются типом вложенных элементов.
+ - `ARRAY_SORTBY(x -> x[1], [[1,2],[0,1]])` -> `[[0, 1], [1, 2]]`
diff --git a/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/array-functions/array-split.md b/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/array-functions/array-split.md
new file mode 100644
index 000000000000..4e5c482f00c0
--- /dev/null
+++ b/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/array-functions/array-split.md
@@ -0,0 +1,53 @@
+---
+{
+ "title": "ARRAY_SPLIT",
+ "language": "ru",
+ "description": "Разбивает входной массив на несколько подмассивов в соответствии с заданными логическими флагами."
+}
+---
+
+## Назначение {#function}
+
+Разбивает входной массив на несколько подмассивов в соответствии с заданными логическими флагами.
+
+- Правило разбиения (слева направо): для `arr=[a1,a2,...,an]` и `flags=[f1,f2,...,fn]` в каждой позиции, где `fi==true`, выполняется разбиение между `ai` и `a(i-1)`.
+ - Например, для `arr=[3, 4, 5]` и `flags=[false, true, false]` второй флаг имеет значение true, поэтому разбиение выполняется между первым и вторым элементами. В результате получаются два подмассива: `[3]` и `[4,5]`.
+
+## Синтаксис {#syntax}
+
+- `ARRAY_SPLIT(arr, flags)`
+- `ARRAY_SPLIT(lambda, arr0, ...)`
+- `ARRAY_SPLIT(lambda, arr0, ...)` эквивалентно `ARRAY_SPLIT(arr0, ARRAY_MAP(lambda, arr0, ...))`
+
+## Параметры {#parameters}
+
+- `arr`: `ARRAY<T>`.
+- `flags`: `ARRAY<BOOLEAN>`, длина которого должна совпадать с длиной `arr` в каждой строке. `true` означает разбиение между текущей позицией и следующим элементом.
+- `arr0, ...`: один или несколько массивов `ARRAY<T>`.
+- `lambda`: выражение `lambda`, применяемое к `arr0, ...` для получения `flags`, которые затем используются для разбиения.
+
+## Возвращаемое значение {#return-value}
+
+- Возвращает `ARRAY<ARRAY<T>>`. Внутренние массивы содержат те же элементы, что и `arr`.
+- Если количество элементов в `arr` и `flags` не совпадает, возникает ошибка.
+
+## Примечания по использованию {#usage-notes}
+
+- Если в какой-либо позиции `flags` находится `NULL`, разбиение в этой позиции не выполняется (эквивалентно `false`).
+- Правило разбиения для `ARRAY_SPLIT`: в каждой позиции, где `fi==true`, выполняется разбиение между `ai` и `a(i-1)`.
+- Правило разбиения для `ARRAY_REVERSE_SPLIT`: в каждой позиции, где `fi==true`, выполняется разбиение между `ai` и `a(i+1)`.
+
+## Примеры {#examples}
+
+- Базовое разбиение: в каждой позиции со значением `true` разбиение выполняется между текущим элементом и его левым соседом.
+ - `ARRAY_SPLIT([1,2,3,4,5], [false,true,false,true,false])` -> `[[1], [2, 3], [4, 5]]`
+ - `ARRAY_SPLIT(['a','b','c'], [false,false,false])` -> `[['a','b','c']]`
+
+- При наличии `NULL` в `flags`: `NULL` обрабатывается так же, как `false` (без разбиения).
+ - `ARRAY_SPLIT([1,NULL,3], [false,null,false])` -> `[[1, NULL, 3]]`
+
+- `lambda= x -> x-1` при применении к `arr0=[1, 2, 3]` формирует `flags=[0,1,2]`, что эквивалентно `flags=[false,true,true]`
+ - `ARRAY_SPLIT(x->x-1, [1, 2, 3])` эквивалентно `ARRAY_SPLIT([1, 2, 3], [false,true,true])` -> `[[1], [2], [3]]`
+
+- `lambda= (x,y) -> x-y` при применении к `arr0=[1, 2, 3]` и `arr1=[0,1,2]` формирует `flags=[true,true,true]`
+ - `ARRAY_SPLIT((x,y) -> x-y, [1, 2, 3], [0, 1, 2])` эквивалентно `ARRAY_SPLIT([1, 2, 3], [true,true,true])` -> `[[1], [2], [3]]`
diff --git a/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/array-functions/array-sum.md b/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/array-functions/array-sum.md
new file mode 100644
index 000000000000..cde4031b33df
--- /dev/null
+++ b/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/array-functions/array-sum.md
@@ -0,0 +1,73 @@
+---
+{
+ "title": "ARRAY_SUM",
+ "language": "ru",
+ "description": "Функция ARRAYSUM вычисляет сумму всех числовых элементов массива."
+}
+---
+
+### Функция {#function}
+
+Функция `ARRAY_SUM` вычисляет сумму всех числовых элементов массива.
+
+## Синтаксис {#syntax}
+
+```SQL
+ARRAY_SUM(ARRAY<T>)
+```
+
+## Параметры {#parameters}
+
+`ARRAY<T>`: массив, содержащий элементы **числового типа**.
+
+## Возвращаемое значение {#return-value}
+
+- Возвращает сумму всех элементов массива, отличных от `NULL`.
+
+ - Если все элементы равны `NULL`, возвращает `NULL`.
+
+## Примечания по использованию {#usage-notes}
+
+1. Для суммирования элементов используется оператор `+`.
+
+2. Элементы со значением `NULL` автоматически игнорируются.
+
+3. Если массив содержит элементы нечислового типа (например, строки), возникает ошибка во время выполнения.
+
+## Примеры {#examples}
+
+1. Простой пример
+
+ ```SQL
+ SELECT ARRAY_SUM([1, 2, 3, 4]);
+ +-------------------------+
+ | ARRAY_SUM([1, 2, 3, 4]) |
+ +-------------------------+
+ | 10 |
+ +-------------------------+
+ ```
+
+2. Обработка значений `NULL` в массивах
+
+ ```SQL
+ SELECT ARRAY_SUM([1, NULL, 3]);
+ +-------------------------+
+ | ARRAY_SUM([1, NULL, 3]) |
+ +-------------------------+
+ | 4 |
+ +-------------------------+
+
+ SELECT ARRAY_SUM(NULL);
+ +-----------------+
+ | ARRAY_SUM(NULL) |
+ +-----------------+
+ | NULL |
+ +-----------------+
+
+ SELECT ARRAY_SUM([NULL, NULL]);
+ +-------------------------+
+ | ARRAY_SUM([NULL, NULL]) |
+ +-------------------------+
+ | NULL |
+ +-------------------------+
+ ```
diff --git a/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/array-functions/array-union.md b/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/array-functions/array-union.md
new file mode 100644
index 000000000000..75dae402265b
--- /dev/null
+++ b/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/array-functions/array-union.md
@@ -0,0 +1,95 @@
+---
+{
+ "title": "ARRAY_UNION",
+ "language": "ru",
+ "description": "ARRAYUNION возвращает объединение нескольких массивов: объединяет все их элементы, удаляет дубликаты и возвращает новый массив."
+}
+---
+
+## Назначение {#function}
+
+`ARRAY_UNION` возвращает объединение нескольких массивов: объединяет все их элементы, удаляет дубликаты и возвращает новый массив.
+
+## Синтаксис {#syntax}
+
+```SQL
+ARRAY_UNION(arr1, arr2, ..., arrN)
+```
+
+## Параметры {#parameters}
+
+- `arr1, arr2, ..., arrN`: произвольное число входных массивов типа `ARRAY<T>`.
+ - Тип элементов `T` должен быть одинаковым для всех массивов или допускать неявное приведение к общему типу.
+ - Тип элементов `T` может быть числовым, строковым, типом даты/времени, IP или UUID.
+
+## Возвращаемое значение {#return-value}
+
+- Возвращает новый массив типа `ARRAY<T>`, содержащий все уникальные элементы входных массивов (без дубликатов).
+ - Если хотя бы один входной параметр равен `NULL`, возвращается `NULL` (см. пример).
+
+## Примечания по использованию {#usage-notes}
+
+1. Дубликаты удаляются на основе сравнения на равенство (оператор `=`).
+2. В результирующем массиве сохраняется только один `NULL` (см. пример).
+3. Если сам входной массив содержит несколько одинаковых элементов, сохраняется только один из них (см. пример).
+4. Порядок элементов в результирующем массиве не гарантируется.
+
+## Примеры {#examples}
+
+1. Простой пример
+
+ ```SQL
+ SELECT ARRAY_UNION(ARRAY('hello', 'world'), ARRAY('hello', 'world'));
+ +---------------------------------------------------------------+
+ | ARRAY_UNION(ARRAY('hello', 'world'), ARRAY('hello', 'world')) |
+ +---------------------------------------------------------------+
+ | ["world", "hello"] |
+ +---------------------------------------------------------------+
+
+ SELECT ARRAY_UNION(ARRAY(1, 2, 3), ARRAY(3, 5, 6));
+ +---------------------------------------------+
+ | ARRAY_UNION(ARRAY(1, 2, 3), ARRAY(3, 5, 6)) |
+ +---------------------------------------------+
+ | [1, 5, 2, 6, 3] |
+ +---------------------------------------------+
+ ```
+
+2. Если хотя бы один входной массив равен `NULL`, возвращается `NULL`
+
+ ```SQL
+ SELECT ARRAY_UNION(ARRAY('hello', 'world'), ARRAY('hello', 'world'), NULL);
+ +---------------------------------------------------------------------+
+ | ARRAY_UNION(ARRAY('hello', 'world'), ARRAY('hello', 'world'), NULL) |
+ +---------------------------------------------------------------------+
+ | NULL |
+ +---------------------------------------------------------------------+
+ ```
+
+3. Если входные массивы содержат `NULL`, результирующий массив будет содержать только один `NULL`
+
+ ```SQL
+ SELECT ARRAY_UNION(ARRAY('hello', 'world'), ARRAY('hello', NULL));
+ +---------------------------------------------------------------------+
+ | ARRAY_UNION(ARRAY('hello', 'world', 'hello'), ARRAY('hello', NULL)) |
+ +---------------------------------------------------------------------+
+ | [null, "world", "hello"] |
+ +---------------------------------------------------------------------+
+
+ SELECT ARRAY_UNION(ARRAY(NULL, 'world'), ARRAY('hello', NULL));
+ +---------------------------------------------------------+
+ | ARRAY_UNION(ARRAY(NULL, 'world'), ARRAY('hello', NULL)) |
+ +---------------------------------------------------------+
+ | [null, "world", "hello"] |
+ +---------------------------------------------------------+
+ ```
+
+4. Если массив содержит повторяющиеся элементы, возвращается только один из них
+
+ ```SQL
+ SELECT ARRAY_UNION(ARRAY('hello', 'world', 'hello'), ARRAY('hello', NULL));
+ +------------------------------------------------------------+
+ | ARRAY_UNION(ARRAY('hello', 'world'), ARRAY('hello', NULL)) |
+ +------------------------------------------------------------+
+ | [null, "world", "hello"] |
+ +------------------------------------------------------------+
+ ```
diff --git a/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/array-functions/array-with-constant.md b/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/array-functions/array-with-constant.md
new file mode 100644
index 000000000000..e75ede6c3149
--- /dev/null
+++ b/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/array-functions/array-with-constant.md
@@ -0,0 +1,83 @@
+---
+{
+ "title": "ARRAY_WITH_CONSTANT",
+ "language": "ru",
+ "description": "ARRAYWITHCONSTANT используется для создания массива заданной длины, все элементы которого имеют указанное значение."
+}
+---
+
+## Назначение {#function}
+
+`ARRAY_WITH_CONSTANT` используется для создания массива заданной длины, все элементы которого имеют указанное значение.
+
+## Синтаксис {#syntax}
+
+```SQL
+ARRAY_WITH_CONSTANT(count, element)
+```
+
+## Параметры {#parameters}
+
+- `count`: целочисленный тип, задаёт длину возвращаемого массива.
+
+- `element`: любой тип данных, поддерживаемый в `ARRAY`.
+
+## Возвращаемое значение {#return-value}
+
+- Возвращает массив типа `ARRAY<T>`, где `T` обозначает тип `element`.
+ - Массив содержит `count` копий одного и того же элемента `element`.
+
+## Примечания по использованию {#usage-notes}
+
+- Если `count = 0` или `NULL`, возвращается пустой массив.
+- Если `element` имеет значение `NULL`, все элементы массива равны `NULL`.
+- Эта функция работает так же, как `ARRAY_REPEAT`, но параметры указаны в обратном порядке.
+- Можно использовать совместно с другими функциями для работы с массивами, чтобы создавать более сложные структуры данных.
+
+## Примеры {#examples}
+
+1. Простой пример
+
+ ```SQL
+ SELECT ARRAY_WITH_CONSTANT(3, 'hello');
+ +---------------------------------+
+ | ARRAY_WITH_CONSTANT(3, 'hello') |
+ +---------------------------------+
+ | ["hello", "hello", "hello"] |
+ +---------------------------------+
+ ```
+
+2. Особые случаи
+
+ ```SQL
+ SELECT ARRAY_WITH_CONSTANT(0, 'hello');
+ +---------------------------------+
+ | ARRAY_WITH_CONSTANT(0, 'hello') |
+ +---------------------------------+
+ | [] |
+ +---------------------------------+
+
+ SELECT ARRAY_WITH_CONSTANT(NULL, 'hello');
+ +------------------------------------+
+ | ARRAY_WITH_CONSTANT(NULL, 'hello') |
+ +------------------------------------+
+ | [] |
+ +------------------------------------+
+
+ SELECT ARRAY_WITH_CONSTANT(2, NULL);
+ +------------------------------+
+ | ARRAY_WITH_CONSTANT(2, NULL) |
+ +------------------------------+
+ | [null, null] |
+ +------------------------------+
+
+ SELECT ARRAY_WITH_CONSTANT(NULL, NULL);
+ +---------------------------------+
+ | ARRAY_WITH_CONSTANT(NULL, NULL) |
+ +---------------------------------+
+ | [] |
+ +---------------------------------+
+
+ -- Returns error: INVALID_ARGUMENT
+ SELECT ARRAY_WITH_CONSTANT(-1, 'hello');
+ ```
diff --git a/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/array-functions/array-zip.md b/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/array-functions/array-zip.md
new file mode 100644
index 000000000000..2b000e863a9c
--- /dev/null
+++ b/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/array-functions/array-zip.md
@@ -0,0 +1,81 @@
+---
+{
+ "title": "ARRAY_ZIP",
+ "language": "ru",
+ "description": "Функция ARRAYZIP поэлементно объединяет несколько массивов ARRAY (например, arr1, arr2, ... , arrN) в один ARRAY<STRUCT>,"
+}
+---
+
+## Назначение {#function}
+
+Функция `ARRAY_ZIP` поэлементно объединяет несколько массивов `ARRAY` (например, `arr1, arr2, ... , arrN`) в один массив `ARRAY<STRUCT>`, где каждая структура `STRUCT` содержит соответствующие элементы каждого входного массива.
+
+## Синтаксис {#syntax}
+
+```SQL
+ARRAY_ZIP(arr1, arr2, ... , arrN)
+```
+
+## Параметры {#parameters}
+
+- `arr1, arr2, ..., arrN`: N входных массивов с типами `ARRAY<T1>, ARRAY<T2>, ..., ARRAY<Tn>`.
+
+## Возвращаемое значение {#return-value}
+
+- Возвращаемый тип: `ARRAY<STRUCT<col1 T1, col2 T2, ..., colN Tn>>`, где каждая структура `STRUCT` представляет собой набор элементов входных массивов с одинаковым индексом.
+
+## Примечания по использованию {#usage-notes}
+
+1. **Если массивы имеют разную длину, функция завершается с ошибкой `RUNTIME_ERROR`**.
+2. Поддерживаются входные массивы разных типов; поля результирующей структуры соответствуют типам входных массивов один к одному.
+3. Функция полезна для объединения нескольких параллельных массивов в структурированный формат, удобный для обработки или анализа.
+
+## Примеры {#examples}
+
+1. Объединение нескольких массивов
+
+ ```SQL
+ SELECT ARRAY_ZIP(ARRAY(23, 24, 25), ARRAY("John", "Jane", "Jim"), ARRAY(true, false, true));
+ +-------------------------------------------------------------------------------------------------------------------+
+ | ARRAY_ZIP(ARRAY(23, 24, 25), ARRAY("John", "Jane", "Jim"), ARRAY(true, false, true)) |
+ +-------------------------------------------------------------------------------------------------------------------+
+ | [{"col1":23, "col2":"John", "col3":1}, {"col1":24, "col2":"Jane", "col3":0}, {"col1":25, "col2":"Jim", "col3":1}] |
+ +-------------------------------------------------------------------------------------------------------------------+
+ ```
+ - Первая структура `STRUCT` в возвращаемом значении содержит первый элемент каждого входного массива `ARRAY`.
+ - Вторая структура `STRUCT` содержит второй элемент каждого входного массива `ARRAY`.
+ - Третья структура `STRUCT` содержит третий элемент каждого входного массива `ARRAY`.
+
+2. Доступ к возвращаемому значению
+
+ ```SQL
+ -- Access the returned ARRAY
+ SELECT ARRAY_ZIP(ARRAY(23, 24, 25), ARRAY("John", "Jane", "Jim"))[1];
+ +---------------------------------------------------------------+
+ | ARRAY_ZIP(ARRAY(23, 24, 25), ARRAY("John", "Jane", "Jim"))[1] |
+ +---------------------------------------------------------------+
+ | {"col1":23, "col2":"John"} |
+ +---------------------------------------------------------------+
+ ```
+
+3. Если один из массивов равен `NULL`, возвращается `NULL`
+
+ ```SQL
+ SELECT ARRAY_ZIP(ARRAY(23, 24, 25), ARRAY("John", "Jane", "Jim"), NULL) ;
+ +------------------------------------------------------------------+
+ | ARRAY_ZIP(ARRAY(23, 24, 25), ARRAY("John", "Jane", "Jim"), NULL) |
+ +------------------------------------------------------------------+
+ | NULL |
+ +------------------------------------------------------------------+
+ ```
+
+4. Если элемент массива `ARRAY` равен `NULL`, соответствующее поле структуры `STRUCT` равно `NULL`
+
+ ```SQL
+ SELECT ARRAY_ZIP(ARRAY(23, NULL, 25), ARRAY("John", "Jane", NULL), ARRAY(NULL, false, true));
+ +-----------------------------------------------------------------------------------------------------------------------+
+ | ARRAY_ZIP(ARRAY(23, NULL, 25), ARRAY("John", "Jane", NULL), ARRAY(NULL, false, true)) |
+ +-----------------------------------------------------------------------------------------------------------------------+
+ | [{"col1":23, "col2":"John", "col3":null}, {"col1":null, "col2":"Jane", "col3":0}, {"col1":25, "col2":null, "col3":1}] |
+ +-----------------------------------------------------------------------------------------------------------------------+
+ ```
diff --git a/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/array-functions/array.md b/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/array-functions/array.md
new file mode 100644
index 000000000000..87cd2fd3d33d
--- /dev/null
+++ b/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/array-functions/array.md
@@ -0,0 +1,142 @@
+---
+{
+ "title": "ARRAY | Функции массивов",
+ "language": "ru",
+ "description": "Создаёт массив. Функция принимает ноль или более параметров и возвращает массив, содержащий все входные элементы.",
+ "sidebar_label": "ARRAY"
+}
+---
+
+# ARRAY {#array}
+
+## array {#array-1}
+
+<version since="2.0.0">
+
+</version>
+
+## Описание {#description}
+
+Создаёт массив. Функция принимает ноль или более параметров и возвращает массив, содержащий все входные элементы.
+
+## Синтаксис {#syntax}
+
+```sql
+array([element1, element2, ...])
+```
+
+### Параметры {#parameters}
+
+- `element1, element2, ...`: Элементы любого типа, которые нужно включить в массив. Поддерживается ноль или более параметров.
+
+**Поддерживаемые типы элементов:**
+- Числовые типы: TINYINT, SMALLINT, INT, BIGINT, LARGEINT, FLOAT, DOUBLE, DECIMAL
+- Строковые типы: CHAR, VARCHAR, STRING
+- Типы даты и времени: DATE, DATETIME, DATEV2, DATETIMEV2, TIMESTAMP_NS
+- Логический тип: BOOLEAN
+- Типы IP: IPV4, IPV6
+- UUID: [UUID](../../../basic-element/sql-data-types/uuid.md)
+- Сложные типы: ARRAY, MAP, STRUCT
+
+### Возвращаемое значение {#return-value}
+
+Тип возвращаемого значения: ARRAY<T>
+
+Описание возвращаемого значения:
+- Возвращает массив, содержащий все входные элементы
+- Пустой массив, если входные параметры не указаны
+
+Примечания по использованию:
+- Функция объединяет все входные элементы одного типа данных в массив. Если типы элементов несовместимы, функция попытается выполнить преобразование типов
+- Сложные и базовые типы несовместимы при объединении в массив; сложные типы также несовместимы между собой
+- Поддерживается ноль или более параметров
+
+**Примеры запросов:**
+
+Создание массива с несколькими элементами:
+```sql
+SELECT array(1, 2, 3, 4, 5);
++----------------------+
+| array(1, 2, 3, 4, 5) |
++----------------------+
+| [1, 2, 3, 4, 5] |
++----------------------+
+```
+
+Создание массива с элементами разных типов:
+```sql
+SELECT array(1, 'hello', 3.14, true);
++-------------------------------+
+| array(1, 'hello', 3.14, true) |
++-------------------------------+
+| ["1", "hello", "3.14", "1"] |
++-------------------------------+
+```
+
+Создание пустого массива:
+```sql
+SELECT array();
++----------+
+| array() |
++----------+
+| [] |
++----------+
+```
+
+Создание массива с элементами null:
+```sql
+SELECT array(1, null, 3, null, 5);
++--------------------------------+
+| array(1, null, 3, null, 5) |
++--------------------------------+
+| [1, null, 3, null, 5] |
++--------------------------------+
+```
+
+### Примеры со сложными типами {#complex-type-examples}
+
+Создание массива, содержащего массивы:
+```sql
+SELECT array([1,2], [3,4], [5,6]);
++----------------------------+
+| array([1,2], [3,4], [5,6]) |
++----------------------------+
+| [[1, 2], [3, 4], [5, 6]] |
++----------------------------+
+```
+
+Создание массива, содержащего отображения:
+```sql
+SELECT array({'a':1}, {'b':2}, {'c':3});
++----------------------------------+
+| array({'a':1}, {'b':2}, {'c':3}) |
++----------------------------------+
+| [{"a":1}, {"b":2}, {"c":3}] |
++----------------------------------+
+```
+
+Создание массива, содержащего структуры:
+```sql
+SELECT array(named_struct('name','Alice','age',20), named_struct('name','Bob','age',30));
++-----------------------------------------------------------------------------------+
+| array(named_struct('name','Alice','age',20), named_struct('name','Bob','age',30)) |
++-----------------------------------------------------------------------------------+
+| [{"name":"Alice", "age":20}, {"name":"Bob", "age":30}] |
++-----------------------------------------------------------------------------------+
+```
+
+Сочетание сложных и базовых типов приводит к ошибке:
+```sql
+SELECT array([1,2], 'hello');
+ERROR 1105 (HY000): errCode = 2, detailMessage = can not cast from origin type ARRAY<TINYINT> to target type=TEXT
+```
+
+Сочетание разных сложных типов приводит к ошибке:
+```sql
+SELECT array([1,2], named_struct('name','Alice','age',20));
+ERROR 1105 (HY000): errCode = 2, detailMessage = Can not find the compatibility function signature: array(ARRAY<TINYINT>, STRUCT<name:VARCHAR(5),age:TINYINT>)
+```
+
+### Ключевые слова {#keywords}
+
+ARRAY
diff --git a/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/array-functions/arrays-overlap.md b/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/array-functions/arrays-overlap.md
new file mode 100644
index 000000000000..0a0167cc52b0
--- /dev/null
+++ b/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/array-functions/arrays-overlap.md
@@ -0,0 +1,153 @@
+---
+{
+ "title": "ARRAYS_OVERLAP",
+ "language": "ru",
+ "description": "ARRAYSOVERLAP проверяет, есть ли у двух массивов хотя бы один общий элемент. Если есть, возвращает true, иначе возвращает false."
+}
+---
+
+## Назначение {#function}
+
+`ARRAYS_OVERLAP` проверяет, есть ли у двух массивов хотя бы один общий элемент. Если есть, возвращает `true`, иначе возвращает `false`.
+
+## Синтаксис {#syntax}
+
+```SQL
+ARRAYS_OVERLAP(arr1, arr2)
+```
+
+## Параметры {#parameters}
+
+- `arr1`: Первый массив типа `ARRAY<T>`.
+
+- `arr2`: Второй массив типа `ARRAY<T>`.
+
+ - Типы элементов `T` обоих массивов должны совпадать или допускать взаимное неявное преобразование.
+ - Тип элемента `T` может быть числовым, строковым, типом даты/времени, IP или UUID.
+
+## Возвращаемое значение {#return-value}
+
+- Возвращает значение типа `BOOLEAN`:
+
+ - Если у двух массивов есть общие элементы, возвращает `true`;
+ - Если общих элементов нет, возвращает `false`.
+
+## Примечания по использованию {#usage-notes}
+
+1. **Сравнение выполняется по равенству элементов (оператор `=`)**.
+2. **В этой функции `NULL` и `NULL` считаются равными** (см. пример).
+3. Можно **указать инвертированный индекс в операторе создания таблицы, чтобы ускорить выполнение** (см. пример).
+ - Если функция используется в условии предиката, инвертированный индекс ускоряет выполнение.
+ - Если функция используется в результате запроса, инвертированный индекс не ускоряет выполнение.
+4. Часто используется для очистки данных, сопоставления тегов и поиска пересечений в поведении пользователей.
+
+## Примеры {#examples}
+
+1. Простой пример
+
+ ```SQL
+ SELECT ARRAYS_OVERLAP(ARRAY('hello', 'aloha'), ARRAY('hello', 'hi', 'hey'));
+ +----------------------------------------------------------------------+
+ | ARRAYS_OVERLAP(ARRAY('hello', 'aloha'), ARRAY('hello', 'hi', 'hey')) |
+ +----------------------------------------------------------------------+
+ | 1 |
+ +----------------------------------------------------------------------+
+
+ SELECT ARRAYS_OVERLAP(ARRAY('Pinnacle', 'aloha'), ARRAY('hi', 'hey'));
+ +----------------------------------------------------------------+
+ | ARRAYS_OVERLAP(ARRAY('Pinnacle', 'aloha'), ARRAY('hi', 'hey')) |
+ +----------------------------------------------------------------+
+ | 0 |
+ +----------------------------------------------------------------+
+ ```
+
+2. Недопустимый тип параметра: при передаче неподдерживаемых типов возвращается `INVALID_ARGUMENT`
+
+ ```SQL
+ -- [INVALID_ARGUMENT] execute failed, unsupported types for function arrays_overlap
+ SELECT ARRAYS_OVERLAP(ARRAY(ARRAY('hello', 'aloha'), ARRAY('hi', 'hey')), ARRAY(ARRAY('hello', 'hi', 'hey'), ARRAY('aloha', 'hi')));
+ ```
+
+3. Если входной `ARRAY` равен `NULL`, возвращаемое значение равно `NULL`
+
+ ```SQL
+ SELECT ARRAYS_OVERLAP(ARRAY('HELLO', 'ALOHA'), NULL);
+ +-----------------------------------------------+
+ | ARRAYS_OVERLAP(ARRAY('HELLO', 'ALOHA'), NULL) |
+ +-----------------------------------------------+
+ | NULL |
+ +-----------------------------------------------+
+
+ SELECT ARRAYS_OVERLAP(NULL, NULL);
+ +----------------------------+
+ | ARRAYS_OVERLAP(NULL, NULL) |
+ +----------------------------+
+ | NULL |
+ +----------------------------+
+ ```
+
+4. Если входной `ARRAY` содержит `NULL`, значения `NULL` и `NULL` считаются равными
+
+ ```SQL
+ SELECT ARRAYS_OVERLAP(ARRAY('HELLO', 'ALOHA'), ARRAY('HELLO', NULL));
+ +---------------------------------------------------------------+
+ | ARRAYS_OVERLAP(ARRAY('HELLO', 'ALOHA'), ARRAY('HELLO', NULL)) |
+ +---------------------------------------------------------------+
+ | 1 |
+ +---------------------------------------------------------------+
+
+ SELECT ARRAYS_OVERLAP(ARRAY('PICKLE', 'ALOHA'), ARRAY('HELLO', NULL));
+ +----------------------------------------------------------------+
+ | ARRAYS_OVERLAP(ARRAY('PICKLE', 'ALOHA'), ARRAY('HELLO', NULL)) |
+ +----------------------------------------------------------------+
+ | 0 |
+ +----------------------------------------------------------------+
+
+ SELECT ARRAYS_OVERLAP(ARRAY(NULL), ARRAY('HELLO', NULL));
+ +---------------------------------------------------+
+ | ARRAYS_OVERLAP(ARRAY(NULL), ARRAY('HELLO', NULL)) |
+ +---------------------------------------------------+
+ | 1 |
+ +---------------------------------------------------+
+ ```
+
+5. Использование инвертированного индекса для ускорения запроса
+
+ ```SQL
+ -- Create table with inverted index
+ CREATE TABLE IF NOT EXISTS arrays_overlap_table (
+ id INT,
+ array_column ARRAY<STRING>,
+ INDEX idx_array_column (array_column) USING INVERTED -- only non-tokenized inverted indexes are allowed
+ ) ENGINE=OLAP
+ DUPLICATE KEY(id)
+ DISTRIBUTED BY HASH(id) BUCKETS 1
+ PROPERTIES (
+ "replication_num" = "1"
+ );
+
+ -- Insert two rows
+ INSERT INTO arrays_overlap_table (id, array_column) VALUES (1, ARRAY('HELLO', 'ALOHA')), (2, ARRAY('NO', 'WORLD'));
+ ```
+
+ - Если функция используется в условии предиката, инвертированный индекс ускоряет выполнение
+
+ ```SQL
+ SELECT * from arrays_overlap_table WHERE ARRAYS_OVERLAP(array_column, ARRAY('HELLO', 'PICKLE'));
+ +------+--------------------+
+ | id | array_column |
+ +------+--------------------+
+ | 1 | ["HELLO", "ALOHA"] |
+ +------+--------------------+
+
+- Если функция используется в результате запроса, инвертированный индекс не ускоряет выполнение
+
+ ```SQL
+ SELECT ARRAYS_OVERLAP(array_column, ARRAY('HELLO', 'PICKLE')) FROM arrays_overlap_table;
+ +--------------------------------------------------------+
+ | ARRAYS_OVERLAP(array_column, ARRAY('HELLO', 'PICKLE')) |
+ +--------------------------------------------------------+
+ | 1 |
+ | 0 |
+ +--------------------------------------------------------+
+ ```
diff --git a/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/array-functions/countequal.md b/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/array-functions/countequal.md
new file mode 100644
index 000000000000..d6c3cf894934
--- /dev/null
+++ b/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/array-functions/countequal.md
@@ -0,0 +1,43 @@
+---
+{
+ "title": "COUNTEQUAL",
+ "language": "ru",
+ "description": "Подсчитывает количество элементов массива, равных заданному целевому значению."
+}
+---
+
+## Функция {#function}
+
+Подсчитывает количество элементов массива, равных заданному целевому значению.
+
+## Синтаксис {#syntax}
+
+- `COUNTEQUAL(arr, target)`
+
+## Параметры {#parameters}
+
+- `arr`: `ARRAY<T>`, поддерживаются числовые, логические и строковые типы элементов, а также datetime, IP и UUID.
+- `target`: имеет тот же тип, что и элементы `arr`.
+
+## Возвращаемое значение {#return-value}
+
+- Возвращает `BIGINT`, представляющий количество равных элементов.
+
+## Примечания по использованию {#usage-notes}
+
+- В этой функции `NULL` равен `NULL` и учитывается при подсчёте.
+
+## Примеры {#examples}
+
+- Базовые примеры
+ - `COUNTEQUAL([1,2,3,2], 2)` -> `2`
+ - `COUNTEQUAL(['a','b','a'], 'a')` -> `2`
+ - `COUNTEQUAL([true,false,false], false)` -> `2`
+
+- `NULL` считается равным самому себе и учитывается при подсчёте
+ - `COUNTEQUAL([1,NULL,2,NULL], NULL)` -> `2`
+ - `COUNTEQUAL([1,NULL,1], 1)` -> `2`
+ - `COUNTEQUAL([1, 2], NULL)` -> `0`
+
+- Если массив равен `NULL`, возвращается `NULL`
+ - `COUNTEQUAL(NULL, 1)` -> `NULL`
diff --git a/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/array-functions/trim-array.md b/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/array-functions/trim-array.md
new file mode 100644
index 000000000000..ff8927b5233f
--- /dev/null
+++ b/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/array-functions/trim-array.md
@@ -0,0 +1,106 @@
+---
+{
+ "title": "Функция TRIM_ARRAY",
+ "language": "ru",
+ "description": "TRIM_ARRAY удаляет указанное количество элементов с конца массива, сохраняя порядок и тип оставшихся элементов."
+}
+---
+
+## trim_array {#trim_array}
+
+<version since="dev">
+
+</version>
+
+## Описание {#description}
+
+Удаляет `<size>` элементов с конца массива `<arr>`, сохраняя порядок оставшихся элементов.
+
+## Синтаксис {#syntax}
+
+```sql
+TRIM_ARRAY(<arr>, <size>)
+```
+
+## Параметры {#parameters}
+
+| Параметр | Описание |
+| -- | -- |
+| `<arr>` | Входной массив `ARRAY<T>`. `T` может быть числовым, логическим, строковым типом, типом даты/времени, типом IP-адреса или сложным типом. |
+| `<size>` | Неотрицательное значение `BIGINT`, задающее количество элементов, которые нужно удалить с конца массива. Оно не может превышать количество элементов в `<arr>`. |
+
+## Возвращаемое значение {#return-value}
+
+Возвращает массив `ARRAY<T>`, содержащий первые `cardinality(<arr>) - <size>` элементов массива `<arr>`.
+
+- Если `<size>` равен `0`, возвращает исходный массив без изменений.
+- Если `<size>` равен количеству элементов в массиве, возвращает пустой массив.
+- Если любой из аргументов равен `NULL`, возвращает `NULL`.
+- Элементы `NULL` внутри массива сохраняются.
+- Если `<size>` отрицателен или превышает количество элементов в массиве, возвращает ошибку.
+
+## Примеры {#examples}
+
+Удаление двух элементов с конца массива:
+
+```sql
+SELECT trim_array([1, 2, 3, 4], 2);
+```
+
+```text
+[1, 2]
+```
+
+При нулевом размере массив остаётся без изменений:
+
+```sql
+SELECT trim_array(['a', 'b', 'c'], 0);
+```
+
+```text
+["a", "b", "c"]
+```
+
+Удаление всех элементов:
+
+```sql
+SELECT trim_array([1, 2, 3], 3);
+```
+
+```text
+[]
+```
+
+Поддерживаются элементы `NULL` и вложенные массивы:
+
+```sql
+SELECT trim_array([[1, NULL], [2, 3], [4, 5]], 1);
+```
+
+```text
+[[1, null], [2, 3]]
+```
+
+Если аргумент равен `NULL`, возвращается `NULL`:
+
+```sql
+SELECT trim_array(CAST(NULL AS ARRAY<INT>), 0);
+```
+
+```text
+NULL
+```
+
+Если размер превышает количество элементов в массиве, возникает ошибка:
+
+```sql
+SELECT trim_array([1, 2, 3], 4);
+```
+
+```text
+ERROR 1105 (HY000): size must not exceed array cardinality 3: 4
+```
+
+### Ключевые слова {#keywords}
+
+ARRAY, TRIM, TRIM_ARRAY
diff --git a/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/binary-functions/from-base64-binary.md b/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/binary-functions/from-base64-binary.md
new file mode 100644
index 000000000000..ad04dee04e13
--- /dev/null
+++ b/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/binary-functions/from-base64-binary.md
@@ -0,0 +1,73 @@
+---
+{
+ "title": "FROM_BASE64_BINARY",
+ "language": "ru",
+ "description": "Функция FROMBASE64BINARY декодирует строку в кодировке Base64 и возвращает результат в виде значения VARBINARY."
+}
+---
+
+## Описание {#description}
+
+Функция FROM_BASE64_BINARY декодирует строку в кодировке Base64 и возвращает результат в виде значения VARBINARY.
+
+Особые случаи:
+
+- Если входная строка не является допустимой строкой в кодировке Base64, функция возвращает NULL.
+
+## Синтаксис {#syntax}
+
+```sql
+FROM_BASE64_BINARY ( <str> )
+```
+
+## Параметры {#parameters}
+
+| Параметр | Описание |
+| --------- | ------------------------------------------------------ |
+| `<str>` | Строка в кодировке Base64, которую нужно декодировать. |
+
+## Возвращаемое значение {#return-value}
+
+Значение параметра `<str>`, декодированное из Base64, в виде результата типа VARBINARY.
+
+Особые случаи:
+
+- Если входная строка недопустима (содержит символы, не входящие в алфавит Base64), функция возвращает NULL.
+
+## Пример {#example}
+
+```sql
+SELECT FROM_BASE64_BINARY('MQ==');
+```
+
+```text
++--------------------------------------------------------+
+| FROM_BASE64_BINARY('MQ==') |
++--------------------------------------------------------+
+| 0x31 |
++--------------------------------------------------------+
+```
+
+```sql
+SELECT FROM_BASE64_BINARY('MjM0');
+```
+
+```text
++--------------------------------------------------------+
+| FROM_BASE64_BINARY('MjM0') |
++--------------------------------------------------------+
+| 0x323334 |
++--------------------------------------------------------+
+```
+
+```sql
+SELECT FROM_BASE64_BINARY(NULL);
+```
+
+```text
++----------------------------------------------------+
+| FROM_BASE64_BINARY(NULL) |
++----------------------------------------------------+
+| NULL |
++----------------------------------------------------+
+```
diff --git a/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/binary-functions/from_hex.md b/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/binary-functions/from_hex.md
new file mode 100644
index 000000000000..dd8c580aad8d
--- /dev/null
+++ b/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/binary-functions/from_hex.md
@@ -0,0 +1,73 @@
+---
+{
+ "title": "FROM_HEX",
+ "language": "ru",
+ "description": "Преобразует входные двоичные данные в строку с использованием шестнадцатеричного кодирования."
+}
+---
+
+## Описание {#description}
+
+Преобразует входные двоичные данные в строку с использованием шестнадцатеричного кодирования.
+
+## Псевдоним {#alias}
+
+FROM_BINARY
+
+## Синтаксис {#syntax}
+
+```sql
+FROM_HEX ( <varbinary> )
+```
+
+## Параметры {#parameters}
+
+| Параметр | Описание |
+|-------|--------------|
+| `<varbinary>` | Двоичные данные, передаваемые в качестве входного параметра |
+
+## Возвращаемое значение {#return-value}
+
+Преобразует входные двоичные данные в строку с использованием шестнадцатеричного кодирования.
+
+## Пример {#example}
+
+```sql
+SELECT FROM_HEX(NULL);
+```
+
+```text
++----------------+
+| FROM_HEX(NULL) |
++----------------+
+| NULL |
++----------------+
+```
+
+```sql
+SELECT FROM_HEX(X'AB');
+```
+
+```text
++-----------------+
+| FROM_HEX(X'AB') |
++-----------------+
+| AB |
++-----------------+
+```
+
+```sql
+select *, from_binary(varbinary_c) from mysql_all_type_test.test_varbinary_db.test_varbinary
+```
+
+```text
++------+----------------------------+--------------------------+
+| id | varbinary_c | from_binary(varbinary_c) |
++------+----------------------------+--------------------------+
+| 1 | 0x48656C6C6F20576F726C64 | 48656C6C6F20576F726C64 |
+| 2 | 0x48656C6C6F20576F726C6421 | 48656C6C6F20576F726C6421 |
+| 3 | 0x48656C6C6F20576F726C6421 | 48656C6C6F20576F726C6421 |
+| 4 | NULL | NULL |
+| 5 | 0xAB | AB |
++------+----------------------------+--------------------------+
+```
diff --git a/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/binary-functions/sub-binary.md b/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/binary-functions/sub-binary.md
new file mode 100644
index 000000000000..086c7701e606
--- /dev/null
+++ b/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/binary-functions/sub-binary.md
@@ -0,0 +1,109 @@
+---
+{
+ "title": "SUB_BINARY",
+ "language": "ru",
+ "description": "Функция SUBBINARY извлекает двоичную подпоследовательность из значения VARBINARY. Можно указать начальную позицию и количество извлекаемых байтов."
+}
+---
+
+## Описание {#description}
+
+Функция SUB_BINARY извлекает двоичную подпоследовательность из значения VARBINARY. Можно указать начальную позицию и количество извлекаемых байтов. Первый байт двоичного значения находится в позиции 1.
+
+## Синтаксис {#syntax}
+
+```sql
+sub_binary(<bin>, <pos> [, <len>])
+```
+
+## Параметры {#parameters}
+
+| Параметр | Описание |
+| --------- | --------------------------------------------------------- |
+| `<bin>` | Исходное двоичное значение. Тип: VARBINARY |
+| `<pos>` | Начальная позиция байта, может быть отрицательной. Тип: INT |
+| `<len>` | Необязательный параметр: количество извлекаемых байтов. Тип: INT |
+
+## Возвращаемое значение {#return-value}
+
+Возвращает значение типа VARBINARY, представляющее извлечённую двоичную подпоследовательность.
+
+Особые случаи:
+
+- Если какой-либо параметр равен NULL, возвращает NULL.
+- Если pos равен 0, возвращает пустое двоичное значение.
+- Если pos отрицателен, отсчёт ведётся от конца двоичного значения в обратном направлении.
+- Если pos превышает длину двоичного значения, возвращает пустое двоичное значение.
+- Если len не указан, возвращает все байты от позиции pos до конца двоичного значения.
+
+## Пример {#example}
+
+1. Базовое использование (с указанием начальной позиции)
+
+```sql
+SELECT sub_binary(x'61626331', 2);
+```
+
+```text
++--------------------------------------------------------+
+| sub_binary(x'61626331', 2) |
++--------------------------------------------------------+
+| 0x626331 |
++--------------------------------------------------------+
+```
+
+2. Использование отрицательной позиции
+
+```sql
+SELECT sub_binary(x'61626331', -2);
+```
+
+```text
++----------------------------------------------------------+
+| sub_binary(x'61626331', -2) |
++----------------------------------------------------------+
+| 0x6331 |
++----------------------------------------------------------+
+```
+
+3. Случай, когда позиция равна 0
+
+```sql
+SELECT sub_binary(x'61626331', 0);
+```
+
+```text
++--------------------------------------------------------+
+| sub_binary(x'61626331', 0) |
++--------------------------------------------------------+
+| 0x |
++--------------------------------------------------------+
+```
+
+4. Позиция превышает длину двоичного значения
+
+```sql
+SELECT sub_binary(x'61626331', 5);
+```
+
+```text
++--------------------------------------------------------+
+| sub_binary(x'61626331', 5) |
++--------------------------------------------------------+
+| 0x |
++--------------------------------------------------------+
+```
+
+5. Указание параметра длины
+
+```sql
+SELECT sub_binary(x'61626331646566', 2, 2);
+```
+
+```text
++--------------------------------------------------------+
+| sub_binary(x'61626331646566', 2, 2) |
++--------------------------------------------------------+
+| 0x6263 |
++--------------------------------------------------------+
+```
diff --git a/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/binary-functions/to-base64-binary.md b/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/binary-functions/to-base64-binary.md
new file mode 100644
index 000000000000..db20a1fba0fe
--- /dev/null
+++ b/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/binary-functions/to-base64-binary.md
@@ -0,0 +1,56 @@
+---
+{
+ "title": "TO_BASE64_BINARY",
+ "language": "ru",
+ "description": "Функция TOBASE64BINARY преобразует входную двоичную строку в формат кодирования Base64."
+}
+---
+
+## Описание {#description}
+
+Функция TO_BASE64_BINARY преобразует входную двоичную строку в формат кодирования Base64. Кодирование Base64 преобразует произвольные двоичные данные в строку, состоящую из 64 символов.
+
+## Синтаксис {#syntax}
+
+```sql
+TO_BASE64_BINARY(<bin>)
+```
+
+## Параметры {#parameters}
+| Параметр | Описание |
+| --------- | ---------------------------------------------- |
+| `<bin>` | Двоичные данные для кодирования в Base64. Тип: VARBINARY |
+
+## Возвращаемое значение {#return-value}
+
+Возвращает значение типа VARCHAR, представляющее строку в кодировке Base64.
+
+Особые случаи:
+- Если входное значение равно NULL, возвращает NULL
+- Если входное значение — пустой VARBINARY (ноль байтов), возвращает пустую строку
+
+## Примеры {#examples}
+
+1. Кодирование одного символа
+```sql
+SELECT to_base64_binary(x'12');
+```
+```text
++-------------------------+
+| to_base64_binary(x'12') |
++-------------------------+
+| Eg== |
++-------------------------+
+```
+
+2. Кодирование нескольких символов
+```sql
+SELECT to_base64_binary(x'234AAA');
+```
+```text
++-----------------------------+
+| to_base64_binary(x'234AAA') |
++-----------------------------+
+| I0qq |
++-----------------------------+
+```
diff --git a/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/binary-functions/to_hex.md b/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/binary-functions/to_hex.md
new file mode 100644
index 000000000000..31fd7b15d2d0
--- /dev/null
+++ b/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/binary-functions/to_hex.md
@@ -0,0 +1,75 @@
+---
+{
+ "title": "TO_HEX",
+ "language": "ru",
+ "description": "Преобразует входную строку в соответствующую последовательность байтов в шестнадцатеричном представлении."
+}
+---
+
+## Описание {#description}
+
+Преобразует входную строку в соответствующую последовательность байтов в шестнадцатеричном представлении.
+
+## Псевдоним {#alias}
+
+TO_BINARY
+
+## Синтаксис {#syntax}
+
+```sql
+TO_HEX(<str>)
+```
+
+## Параметры {#parameters}
+
+| Параметр | Описание |
+| -- | -- |
+| `<str>` | Строковые данные для преобразования |
+
+## Возвращаемое значение {#return-value}
+
+Возвращает декодированное значение VARBINARY (отображается в шестнадцатеричном формате с префиксом 0x).
+Возвращает NULL, если выполняется любое из следующих условий:
+Входное значение равно NULL;
+Длина входного значения равна 0;
+Длина входного значения нечётная;
+Входное значение содержит символы, не входящие в набор [0-9a-fA-F];
+Длина декодированного результата равна 0 (ошибка декодирования).
+
+## Примеры {#examples}
+
+```sql
+select to_hex(NULL),to_hex('a');
+```
+
+```text
++----------------------------+--------------------------+
+| to_hex(NULL) | to_hex('a') |
++----------------------------+--------------------------+
+| NULL | NULL |
++----------------------------+--------------------------+
+```
+
+```sql
+select to_hex('ab');
+```
+
+```text
++----------------------------+
+| to_hex('ab') |
++----------------------------+
+| 0xAB |
++----------------------------+
+```
+
+```sql
+select to_hex('000A');
+```
+
+```text
++--------------------------------+
+| to_hex('000A') |
++--------------------------------+
+| 0x000A |
++--------------------------------+
+```
diff --git a/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/bitmap-functions/bitmap-and-count.md b/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/bitmap-functions/bitmap-and-count.md
new file mode 100644
index 000000000000..6079b2430663
--- /dev/null
+++ b/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/bitmap-functions/bitmap-and-count.md
@@ -0,0 +1,78 @@
+---
+{
+ "title": "BITMAP_AND_COUNT",
+ "language": "ru",
+ "description": "Вычисляет пересечение двух или более входных BITMAP и возвращает количество элементов в пересечении."
+}
+---
+
+## Описание {#description}
+
+Вычисляет пересечение двух или более входных BITMAP и возвращает количество элементов в пересечении.
+
+## Синтаксис {#syntax}
+
+```sql
+BITMAP_AND_COUNT(<bitmap>, <bitmap>,[, <bitmap>...])
+```
+
+## Параметры {#parameters}
+
+| Параметр | Описание |
+|------------|----------------------------------------------------------------|
+| `<bitmap>` | Один из исходных BITMAP, для которых вычисляется пересечение |
+
+## Возвращаемое значение {#return-value}
+
+Возвращает целое число
+- Если параметр имеет значение NULL, возвращает 0
+
+## Примеры {#examples}
+
+```sql
+select bitmap_and_count(bitmap_from_string('1,2,3'),bitmap_from_string('3,4,5')) as res;
+```
+
+```text
++------+
+| res |
++------+
+| 1 |
++------+
+```
+
+```sql
+select bitmap_and_count(bitmap_from_string('1,2,3'), bitmap_from_string('1,2'), bitmap_from_string('1,2,3,4,5')) as res;
+```
+
+```text
++------+
+| res |
++------+
+| 2 |
++------+
+```
+
+```sql
+select bitmap_and_count(bitmap_from_string('1,2,3'), bitmap_from_string('1,2'), bitmap_from_string('1,2,3,4,5'),bitmap_empty()) as res;
+```
+
+```text
++------+
+| res |
++------+
+| 0 |
++------+
+```
+
+```sql
+select bitmap_and_count(bitmap_from_string('1,2,3'), bitmap_from_string('1,2'), bitmap_from_string('1,2,3,4,5'), NULL) as res;
+```
+
+```text
++------+
+| res |
++------+
+| 0 |
++------+
+```
diff --git a/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/bitmap-functions/bitmap-and-not-count.md b/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/bitmap-functions/bitmap-and-not-count.md
new file mode 100644
index 000000000000..2fe456700613
--- /dev/null
+++ b/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/bitmap-functions/bitmap-and-not-count.md
@@ -0,0 +1,59 @@
+---
+{
+ "title": "BITMAP_AND_NOT_COUNT,BITMAP_ANDNOT_COUNT",
+ "language": "ru",
+ "description": "Выполняет операцию NOT над двумя BITMAP и возвращает количество элементов в результирующем множестве."
+}
+---
+
+## Описание {#description}
+
+Выполняет операцию NOT над двумя BITMAP и возвращает количество элементов в результирующем множестве. Первый входной параметр называется `base BITMAP`, а второй называется `exclusion BITMAP`.
+
+## Псевдоним {#alias}
+
+- BITMAP_ANDNOT_COUNT
+
+## Синтаксис {#syntax}
+
+```sql
+BITMAP_AND_NOT_COUNT(<bitmap1>, <bitmap2>)
+```
+
+## Параметры {#parameters}
+
+| Параметр | Описание |
+|-------------|----------------------------------|
+| `<bitmap1>` | `Base BITMAP`, к которому применяется операция NOT |
+| `<bitmap2>` | `Exclusion BITMAP`, к которому применяется операция NOT |
+
+## Возвращаемое значение {#return-value}
+
+Возвращает целое число.
+- Если параметр имеет значение NULL, возвращает 0
+
+## Примеры {#examples}
+
+```sql
+select bitmap_and_not_count(NULL, bitmap_from_string('1,2,3')) banc1, bitmap_and_not_count(bitmap_from_string('1,2,3'), NULL) banc2;
+```
+
+```text
++-------+-------+
+| banc1 | banc2 |
++-------+-------+
+| 0 | 0 |
++-------+-------+
+```
+
+```sql
+select bitmap_and_not_count(bitmap_from_string('1,2,3'), bitmap_from_string('3,4,5')) banc;
+```
+
+```text
++------+
+| banc |
++------+
+| 2 |
++------+
+```
diff --git a/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/bitmap-functions/bitmap-and-not.md b/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/bitmap-functions/bitmap-and-not.md
new file mode 100644
index 000000000000..dfbc074bd43f
--- /dev/null
+++ b/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/bitmap-functions/bitmap-and-not.md
@@ -0,0 +1,83 @@
+---
+{
+ "title": "BITMAP_AND_NOT,BITMAP_ANDNOT",
+ "language": "ru",
+ "description": "Выполняет операцию NOT над двумя BITMAP и возвращает результат. Первый входной параметр называется base BITMAP, а второй называется exclude BITMAP."
+}
+---
+
+## Описание {#description}
+
+Выполняет операцию NOT над двумя BITMAP и возвращает результат. Первый входной параметр называется `base BITMAP`, а второй называется `exclude BITMAP`.
+
+## Псевдоним {#alias}
+
+- BITMAP_ANDNOT
+
+## Синтаксис {#syntax}
+
+```sql
+BITMAP_AND_NOT(<bitmap1>, <bitmap2>)
+```
+
+## Параметры {#parameters}
+
+| Параметр | Описание |
+|-------------|----------------------------------|
+| `<bitmap1>` | `Base BITMAP`, к которому применяется отрицание |
+| `<bitmap2>` | `Exclusion BITMAP`, к которому применяется отрицание |
+
+## Возвращаемое значение {#return-value}
+
+Возвращает BITMAP.
+- Если параметр имеет значение NULL, возвращает NULL
+
+## Примеры {#examples}
+
+```sql
+select bitmap_count(bitmap_and_not(bitmap_from_string('1,2,3'),bitmap_from_string('3,4,5'))) cnt;
+```
+
+```text
++------+
+| cnt |
++------+
+| 2 |
++------+
+```
+
+```sql
+select bitmap_to_string(bitmap_and_not(bitmap_from_string('1,2,3'),bitmap_from_string('3,4,5'))) as cnt;
+```
+
+```text
++------+
+| cnt |
++------+
+| 1,2 |
++------+
+```
+
+```sql
+select bitmap_to_string(bitmap_and_not(bitmap_from_string('1,2,3'),bitmap_empty())) cnt;
+```
+
+```text
++-------+
+| cnt |
++-------+
+| 1,2,3 |
++-------+
+```
+
+```sql
+select bitmap_to_string(bitmap_and_not(bitmap_from_string('1,2,3'),NULL)) as res;
+```
+
+```text
++------+
+| res |
++------+
+| NULL |
++------+
+```
diff --git a/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/bitmap-functions/bitmap-and.md b/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/bitmap-functions/bitmap-and.md
new file mode 100644
index 000000000000..494be846828f
--- /dev/null
+++ b/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/bitmap-functions/bitmap-and.md
@@ -0,0 +1,66 @@
+---
+{
+ "title": "BITMAP_AND",
+ "language": "ru",
+ "description": "Вычисляет пересечение двух или более входных BITMAP и возвращает новый BITMAP."
+}
+---
+
+## Описание {#description}
+
+Вычисляет пересечение двух или более входных BITMAP и возвращает новый BITMAP.
+
+## Синтаксис {#syntax}
+
+```sql
+BITMAP_AND(<bitmap>, <bitmap>,[, <bitmap>...])
+```
+
+## Параметры {#parameters}
+
+| Параметр | Описание |
+|------------|----------------------------------------------------------------|
+| `<bitmap>` | Один из исходных BITMAP, пересечение которых требуется найти |
+
+## Возвращаемое значение {#return-value}
+
+Возвращает BITMAP
+- Если параметр имеет значение NULL, возвращает NULL
+
+## Примеры {#examples}
+
+```sql
+select bitmap_to_string(bitmap_and(bitmap_from_string('1,2,3'), bitmap_from_string('1,2'), bitmap_from_string('1,2,3,4,5'))) as res;
+```
+
+```text
++------+
+| res |
++------+
+| 1,2 |
++------+
+```
+
+```sql
+select bitmap_to_string(bitmap_and(bitmap_from_string('1,2,3'), bitmap_from_string('1,2'), bitmap_from_string('1,2,3,4,5'),bitmap_empty())) as res;
+```
+
+```text
++------+
+| res |
++------+
+| |
++------+
+```
+
+```sql
+select bitmap_to_string(bitmap_and(bitmap_from_string('1,2,3'), bitmap_from_string('1,2'), bitmap_from_string('1,2,3,4,5'),NULL)) as res;
+```
+
+```text
++------+
+| res |
++------+
+| NULL |
++------+
+```
diff --git a/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/bitmap-functions/bitmap-contains.md b/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/bitmap-functions/bitmap-contains.md
new file mode 100644
index 000000000000..75b2ec0b3e55
--- /dev/null
+++ b/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/bitmap-functions/bitmap-contains.md
@@ -0,0 +1,55 @@
+---
+{
+ "title": "BITMAP_CONTAINS",
+ "language": "ru",
+ "description": "Проверяет, содержится ли входное значение в BITMAP, и возвращает логическое значение."
+}
+---
+
+## Описание {#description}
+
+Проверяет, содержится ли входное значение в BITMAP, и возвращает логическое значение.
+
+## Синтаксис {#syntax}
+
+```sql
+BITMAP_CONTAINS(<bitmap>, <bigint>)
+```
+
+## Параметры {#parameters}
+
+| Параметр | Описание |
+|------------|-----------------------------------------|
+| `<bitmap>` | Коллекция BITMAP |
+| `<bitint>` | Целое число для проверки наличия |
+
+## Возвращаемое значение {#return-value}
+
+Возвращает логическое значение.
+- Если параметр равен NULL, возвращает NULL
+
+## Примеры {#examples}
+
+```sql
+select bitmap_contains(to_bitmap(1),2) cnt1, bitmap_contains(to_bitmap(1),1) cnt2;
+```
+
+```text
++------+------+
+| cnt1 | cnt2 |
++------+------+
+| 0 | 1 |
++------+------+
+```
+
+```sql
+select bitmap_contains(NULL,2) cnt1, bitmap_contains(to_bitmap(1),NULL) cnt2;
+```
+
+```text
++------+------+
+| cnt1 | cnt2 |
++------+------+
+| NULL | NULL |
++------+------+
+```
diff --git a/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/bitmap-functions/bitmap-count.md b/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/bitmap-functions/bitmap-count.md
new file mode 100644
index 000000000000..e2a26c6ced8a
--- /dev/null
+++ b/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/bitmap-functions/bitmap-count.md
@@ -0,0 +1,53 @@
+---
+{
+ "title": "BITMAP_COUNT",
+ "language": "ru",
+ "description": "Подсчитывает количество элементов во входном BITMAP"
+}
+---
+
+## Описание {#description}
+
+Подсчитывает количество элементов во входном BITMAP
+
+## Синтаксис {#syntax}
+
+```sql
+BITMAP_COUNT(<bitmap>)
+```
+
+## Параметры {#parameters}
+
+| Параметр | Описание |
+|------------|-------------|
+| `<bitmap>` | Значение BITMAP |
+
+## Возвращаемое значение {#return-value}
+
+Возвращает целое число
+
+## Примеры {#examples}
+
+```sql
+select bitmap_count(to_bitmap(1)) cnt;
+```
+
+```text
++------+
+| cnt |
++------+
+| 1 |
++------+
+```
+
+```sql
+select bitmap_count(bitmap_empty()) cnt;
+```
+
+```text
++------+
+| cnt |
++------+
+| 0 |
++------+
+```
diff --git a/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/bitmap-functions/bitmap-empty.md b/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/bitmap-functions/bitmap-empty.md
new file mode 100644
index 000000000000..fd3267a6639d
--- /dev/null
+++ b/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/bitmap-functions/bitmap-empty.md
@@ -0,0 +1,51 @@
+---
+{
+ "title": "BITMAP_EMPTY",
+ "language": "ru",
+ "description": "Создаёт пустой BITMAP. В основном используется для подстановки значений по умолчанию при вставке или загрузке через Stream Load. Например:"
+}
+---
+
+## Описание {#description}
+
+Создаёт пустой BITMAP. В основном используется для подстановки значений по умолчанию при вставке или загрузке через Stream Load. Например:
+
+```
+cat data | curl --location-trusted -u user:passwd -T - -H "columns: dt,page,v1,v2=bitmap_empty()" http://127.0.0.1:8040/api/test_database/test_table/_stream_load
+```
+
+## Синтаксис {#syntax}
+
+```sql
+BITMAP_EMPTY()
+```
+
+## Возвращаемое значение {#return-value}
+
+Возвращает пустой массив без элементов
+
+## Примеры {#examples}
+
+```sql
+select bitmap_to_string(bitmap_empty());
+```
+
+```text
++----------------------------------+
+| bitmap_to_string(bitmap_empty()) |
++----------------------------------+
+| |
++----------------------------------+
+```
+
+```sql
+select bitmap_count(bitmap_empty());
+```
+
+```text
++------------------------------+
+| bitmap_count(bitmap_empty()) |
++------------------------------+
+| 0 |
++------------------------------+
+```
diff --git a/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/bitmap-functions/bitmap-from-array.md b/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/bitmap-functions/bitmap-from-array.md
new file mode 100644
index 000000000000..9b435d5848ea
--- /dev/null
+++ b/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/bitmap-functions/bitmap-from-array.md
@@ -0,0 +1,67 @@
+---
+{
+ "title": "BITMAP_FROM_ARRAY",
+ "language": "ru",
+ "description": "Преобразует массив элементов типа TINYINT/SMALLINT/INT/BIGINT в BITMAP. Если входное поле содержит недопустимое значение, возвращается NULL."
+}
+---
+
+## Описание {#description}
+
+Преобразует массив элементов типа TINYINT/SMALLINT/INT/BIGINT в BITMAP. Если входное поле содержит недопустимое значение, возвращается NULL.
+
+## Синтаксис {#syntax}
+
+```sql
+BITMAP_FROM_ARRAY(<arr>)
+```
+
+## Параметры {#parameters}
+
+| Параметр | Описание |
+|-----------|---------------|
+| `<arr>` | массив целых чисел |
+
+## Возвращаемое значение {#return-value}
+
+Возвращает BITMAP
+- Если входное поле содержит недопустимое значение, возвращается NULL
+
+## Примеры {#examples}
+
+```sql
+SELECT bitmap_to_string(bitmap_from_array(array(1, 0, 1, 1, 0, 1, 0))) AS bs;
+```
+
+```text
++------+
+| bs |
++------+
+| 0,1 |
++------+
+```
+
+
+```sql
+SELECT bitmap_to_string(bitmap_from_array(NULL)) AS bs;
+```
+
+```text
++------+
+| bs |
++------+
+| NULL |
++------+
+```
+
+```sql
+select bitmap_to_string(bitmap_from_array([1,2,3,-1]));
+```
+
+```text
++-------------------------------------------------+
+| bitmap_to_string(bitmap_from_array([1,2,3,-1])) |
++-------------------------------------------------+
+| NULL |
++-------------------------------------------------+
+```
diff --git a/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/bitmap-functions/bitmap-from-base64.md b/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/bitmap-functions/bitmap-from-base64.md
new file mode 100644
index 000000000000..868f4eaaffe7
--- /dev/null
+++ b/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/bitmap-functions/bitmap-from-base64.md
@@ -0,0 +1,79 @@
+---
+{
+ "title": "BITMAP_FROM_BASE64",
+ "language": "ru",
+ "description": "Преобразует строку base64 (которую можно получить с помощью функции bitmaptobase64) в BITMAP. Возвращает NULL, если входная строка некорректна."
+}
+---
+
+## Описание {#description}
+
+Преобразует строку base64 (которую можно получить с помощью функции `bitmap_to_base64`) в BITMAP. Возвращает NULL, если входная строка некорректна.
+
+## Синтаксис {#syntax}
+
+```sql
+ BITMAP_FROM_BASE64(<base64_str>)
+```
+
+## Параметры {#parameters}
+
+| Параметр | Описание |
+|----------------|-----------------------------------------------------------------|
+| `<base64_str>` | Строка base64 (можно получить с помощью функции `bitmap_to_base64`) |
+
+## Возвращаемое значение {#return-value}
+
+Возвращает BITMAP
+- Если входное поле некорректно, результатом будет NULL
+
+## Примеры {#examples}
+
+
+```sql
+select bitmap_to_string(bitmap_from_base64("invalid")) bts;
+```
+
+```text
++------+
+| bts |
++------+
+| NULL |
++------+
+```
+
+```sql
+select bitmap_to_string(bitmap_from_base64("AA==")) bts;
+```
+
+```text
++------+
+| bts |
++------+
+| |
++------+
+```
+
+```sql
+select bitmap_to_string(bitmap_from_base64("AQEAAAA=")) bts;
+```
+
+```text
++------+
+| bts |
++------+
+| 1 |
++------+
+```
+
+```sql
+select bitmap_to_string(bitmap_from_base64("AjowAAACAAAAAAAAAJgAAAAYAAAAGgAAAAEAf5Y=")) bts;
+```
+
+```text
++-----------+
+| bts |
++-----------+
+| 1,9999999 |
++-----------+
+```
diff --git a/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/bitmap-functions/bitmap-from-string.md b/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/bitmap-functions/bitmap-from-string.md
new file mode 100644
index 000000000000..7922b025de64
--- /dev/null
+++ b/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/bitmap-functions/bitmap-from-string.md
@@ -0,0 +1,91 @@
+---
+{
+ "title": "BITMAP_FROM_STRING",
+ "language": "ru",
+ "description": "Преобразует строку в BITMAP. Строка состоит из набора беззнаковых чисел типа bigint, разделённых запятыми."
+}
+---
+
+## Описание {#description}
+
+Преобразует строку в BITMAP. Строка состоит из набора беззнаковых чисел типа bigint, разделённых запятыми. (Значения чисел находятся в диапазоне: 0 ~ 18446744073709551615)
+Например, строка "0, 1, 2" будет преобразована в Bitmap, в котором установлены биты с номерами 0, 1 и 2. Если входное поле содержит недопустимое значение, возвращается NULL.
+
+## Синтаксис {#syntax}
+
+```sql
+ BITMAP_FROM_STRING(<str>)
+```
+
+## Параметры {#parameters}
+
+| Параметр | Описание |
+|-----------|------------------------------------------------------------------------------------------------|
+| `<str>` | Строковое представление массива. Например, строка "0, 1, 2" будет преобразована в Bitmap с установленными битами 0, 1, 2 |
+
+## Возвращаемое значение {#return-value}
+
+Возвращает BITMAP.
+- Если входное поле содержит недопустимое значение, результатом будет NULL.
+
+## Примеры {#examples}
+
+```sql
+select bitmap_to_string(bitmap_from_string("0, 1, 2")) bts;
+```
+
+```text
++-------+
+| bts |
++-------+
+| 0,1,2 |
++-------+
+```
+
+```sql
+select bitmap_to_string(bitmap_from_string("-1, 0, 1, 2")) bfs;
+```
+
+```text
++------+
+| bfs |
++------+
+| NULL |
++------+
+```
+
+```sql
+select bitmap_to_string(bitmap_from_string(NULL)) bfs;
+```
+
+```text
++------+
+| bfs |
++------+
+| NULL |
++------+
+```
+
+```sql
+select bitmap_to_string(bitmap_from_string("18446744073709551616, 1")) bfs;
+```
+
+```text
++------+
+| bfs |
++------+
+| NULL |
++------+
+```
+
+```sql
+select bitmap_to_string(bitmap_from_string("0, 1, 18446744073709551615")) bts;
+```
+
+```text
++--------------------------+
+| bts |
++--------------------------+
+| 0,1,18446744073709551615 |
++--------------------------+
+```
diff --git a/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/bitmap-functions/bitmap-has-all.md b/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/bitmap-functions/bitmap-has-all.md
new file mode 100644
index 000000000000..e6e30b8e1779
--- /dev/null
+++ b/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/bitmap-functions/bitmap-has-all.md
@@ -0,0 +1,80 @@
+---
+{
+ "title": "BITMAP_HAS_ALL",
+ "language": "ru",
+ "description": "Определяет, содержит ли один Bitmap все элементы другого Bitmap."
+}
+---
+
+## Описание {#description}
+
+Определяет, содержит ли один Bitmap все элементы другого Bitmap.
+
+## Синтаксис {#syntax}
+
+```sql
+BITMAP_HAS_ALL(<bitmap1>, <bitmap2>)
+```
+
+## Параметры {#parameters}
+
+| Параметр | Описание |
+|-------------|-------------------|
+| `<bitmap1>` | Первый Bitmap |
+| `<bitmap2>` | Второй Bitmap |
+
+## Возвращаемое значение {#return-value}
+
+Возвращает `true`, если `<bitmap1>` содержит все элементы `<bitmap2>`;
+Возвращает `true`, если `<bitmap2>` не содержит элементов;
+В противном случае возвращает `false`.
+- Если параметр имеет значение NULL, возвращает NULL
+
+## Примеры {#examples}
+
+Чтобы проверить, содержит ли один Bitmap все элементы другого Bitmap:
+
+```sql
+select bitmap_has_all(bitmap_from_string('0, 1, 2'), bitmap_from_string('1, 2')) as res;
+```
+
+Результат будет следующим:
+
+```text
++------+
+| res |
++------+
+| 1 |
++------+
+```
+
+Чтобы проверить, содержит ли пустой Bitmap все элементы другого Bitmap:
+
+```sql
+select bitmap_has_all(bitmap_empty(), bitmap_from_string('1, 2')) as res;
+```
+
+Результат будет следующим:
+
+```text
++------+
+| res |
++------+
+| 0 |
++------+
+```
+
+
+```sql
+select bitmap_has_all(bitmap_empty(), NULL) as res;
+```
+
+Результат будет следующим:
+
+```text
++------+
+| res |
++------+
+| NULL |
++------+
+```
diff --git a/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/bitmap-functions/bitmap-has-any.md b/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/bitmap-functions/bitmap-has-any.md
new file mode 100644
index 000000000000..c3a551c50832
--- /dev/null
+++ b/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/bitmap-functions/bitmap-has-any.md
@@ -0,0 +1,68 @@
+---
+{
+ "title": "BITMAP_HAS_ANY",
+ "language": "ru",
+ "description": "Определяет, есть ли у двух Bitmap общие элементы."
+}
+---
+
+## Описание {#description}
+
+Определяет, есть ли у двух Bitmap общие элементы.
+
+## Синтаксис {#syntax}
+
+```sql
+BITMAP_HAS_ANY(<bitmap1>, <bitmap2>)
+```
+
+## Параметры {#parameters}
+
+| Параметр | Описание |
+|-------------|----------------------|
+| `<bitmap1>` | Первый Bitmap |
+| `<bitmap2>` | Второй Bitmap |
+
+## Возвращаемое значение {#return-value}
+
+Возвращает true, если у двух Bitmap есть общие элементы;
+Возвращает false, если у двух Bitmap нет общих элементов.
+- Если значение параметра равно NULL, возвращает NULL
+
+## Примеры {#examples}
+
+```sql
+select bitmap_has_any(to_bitmap(1), to_bitmap(2)) res;
+```
+
+```text
++------+
+| res |
++------+
+| 0 |
++------+
+```
+
+```sql
+select bitmap_has_any(bitmap_from_string('1,2,3'), to_bitmap(1)) res;
+```
+
+```text
++------+
+| res |
++------+
+| 1 |
++------+
+```
+
+```sql
+select bitmap_has_any(bitmap_from_string('1,2,3'), NULL) as res;
+```
+
+```text
++------+
+| res |
++------+
+| NULL |
++------+
+```
diff --git a/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/bitmap-functions/bitmap-hash.md b/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/bitmap-functions/bitmap-hash.md
new file mode 100644
index 000000000000..e4fd5433e4b5
--- /dev/null
+++ b/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/bitmap-functions/bitmap-hash.md
@@ -0,0 +1,88 @@
+---
+{
+ "title": "BITMAP_HASH",
+ "language": "ru",
+ "description": "Вычисляет 32-битное хеш-значение входных данных любого типа и возвращает Bitmap, содержащий это хеш-значение."
+}
+---
+
+## Описание {#description}
+
+Вычисляет 32-битное хеш-значение входных данных любого типа и возвращает Bitmap, содержащий это хеш-значение.
+
+## Синтаксис {#syntax}
+
+```sql
+BITMAP_HASH(<expr>)
+```
+
+## Параметры {#parameters}
+
+| Параметр | Описание |
+|-----------|-----------------------|
+| `<expr>` | Любое значение или выражение с полями |
+
+## Возвращаемое значение {#return-value}
+
+Возвращает Bitmap, содержащий 32-битное хеш-значение параметра `<expr>`.
+- Если параметр имеет значение NULL, возвращается пустой Bitmap
+
+::: note
+
+Используемый алгоритм хеширования: MurMur3.
+MurMur3 представляет собой высокопроизводительный алгоритм хеширования с низкой вероятностью коллизий, который формирует значения с распределением, близким к случайному, и может проходить проверки по критерию хи-квадрат. Обратите внимание, что вычисленные хеш-значения могут различаться в зависимости от аппаратной платформы и начальных значений.
+Подробнее о производительности этого алгоритма см. в результатах тестирования [Smhasher](http://rurban.github.io/smhasher/).
+
+:::
+
+## Примеры {#examples}
+
+Для вычисления хеша MurMur3 для значения можно использовать:
+
+```sql
+select bitmap_to_array(bitmap_hash('hello'))[1];
+```
+
+Результат будет следующим:
+
+```text
++-------------------------------------------------------------+
+| %element_extract%(bitmap_to_array(bitmap_hash('hello')), 1) |
++-------------------------------------------------------------+
+| 1321743225 |
++-------------------------------------------------------------+
+```
+
+Для подсчёта уникальных значений в столбце можно использовать Bitmap, что в некоторых сценариях эффективнее, чем `count distinct`. В приведённом ниже примере таблица `words` заполняется 6 строками, содержащими 4 уникальных значения; в масштабах корпуса документов реальный запрос такого вида может возвращать значения, исчисляемые миллионами:
+
+```sql
+CREATE TABLE `words` (`word` VARCHAR(64))
+DISTRIBUTED BY HASH(`word`) BUCKETS 1
+PROPERTIES ("replication_num" = "1");
+
+INSERT INTO `words` VALUES ('apple'), ('banana'), ('cherry'), ('apple'), ('date'), ('banana');
+
+select bitmap_count(bitmap_union(bitmap_hash(`word`))) from `words`;
+```
+
+```text
++-------------------------------------------------+
+| bitmap_count(bitmap_union(bitmap_hash(`word`))) |
++-------------------------------------------------+
+| 4 |
++-------------------------------------------------+
+```
+
+```sql
+select bitmap_to_string(bitmap_hash(NULL)) AS res;
+```
+
+Результат будет следующим:
+
+```text
++------+
+| res |
++------+
+| |
++------+
+```
diff --git a/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/bitmap-functions/bitmap-hash64.md b/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/bitmap-functions/bitmap-hash64.md
new file mode 100644
index 000000000000..caf30d7a004c
--- /dev/null
+++ b/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/bitmap-functions/bitmap-hash64.md
@@ -0,0 +1,60 @@
+---
+{
+ "title": "BITMAP_HASH64",
+ "language": "ru",
+ "description": "Вычисляет 64-битное хеш-значение входного значения любого типа и возвращает Bitmap, содержащий это хеш-значение."
+}
+---
+
+## Описание {#description}
+
+Вычисляет 64-битное хеш-значение входного значения любого типа и возвращает Bitmap, содержащий это хеш-значение.
+
+## Синтаксис {#syntax}
+
+```sql
+BITMAP_HASH64(<expr>)
+```
+
+## Параметры {#parameters}
+
+| Параметр | Описание |
+|-----------|-----------------------|
+| `<expr>` | Любое значение или выражение поля |
+
+## Возвращаемое значение {#return-value}
+
+Возвращает Bitmap, содержащий 64-битное хеш-значение параметра `<expr>`.
+- Если значение параметра равно NULL, возвращает пустой Bitmap
+
+## Примеры {#examples}
+
+Чтобы вычислить 64-битное хеш-значение, можно использовать:
+
+```sql
+select bitmap_to_string(bitmap_hash64('hello'));
+```
+
+Результат:
+
+```text
++------------------------------------------+
+| bitmap_to_string(bitmap_hash64('hello')) |
++------------------------------------------+
+| 15231136565543391023 |
++------------------------------------------+
+```
+
+```sql
+select bitmap_to_string(bitmap_hash64(NULL));
+```
+
+Результат:
+
+```text
++---------------------------------------+
+| bitmap_to_string(bitmap_hash64(NULL)) |
++---------------------------------------+
+| |
++---------------------------------------+
+```
diff --git a/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/bitmap-functions/bitmap-max.md b/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/bitmap-functions/bitmap-max.md
new file mode 100644
index 000000000000..6c0b24567c40
--- /dev/null
+++ b/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/bitmap-functions/bitmap-max.md
@@ -0,0 +1,76 @@
+---
+{
+ "title": "BITMAP_MAX",
+ "language": "ru",
+ "description": "Вычисляет и возвращает максимальное значение в Bitmap."
+}
+---
+
+## Описание {#description}
+
+Вычисляет и возвращает максимальное значение в Bitmap.
+
+## Синтаксис {#syntax}
+
+```sql
+BITMAP_MAX(<bitmap>)
+```
+
+## Параметры {#parameters}
+
+| Параметр | Описание |
+|------------|---------------------------------|
+| `<bitmap>` | Столбец или выражение типа Bitmap |
+
+## Возвращаемое значение {#return-value}
+
+Максимальное значение в Bitmap.
+Возвращает `NULL`, если Bitmap пуст или имеет значение NULL.
+
+## Примеры {#examples}
+
+Чтобы вычислить максимальное значение в пустом Bitmap:
+
+```sql
+select bitmap_max(bitmap_from_string('')) value;
+```
+
+Результат будет следующим:
+
+```text
++-------+
+| value |
++-------+
+| NULL |
++-------+
+```
+
+Чтобы вычислить максимальное значение в Bitmap с несколькими элементами:
+
+```sql
+select bitmap_max(bitmap_from_string('1,9999999999')) value;
+```
+
+Результат будет следующим:
+
+```text
++------------+
+| value |
++------------+
+| 9999999999 |
++------------+
+```
+
+```sql
+select bitmap_max(bitmap_empty()) res1, bitmap_max(NULL) res2;
+```
+
+Результат будет следующим:
+
+```text
++------+------+
+| res1 | res2 |
++------+------+
+| NULL | NULL |
++------+------+
+```
diff --git a/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/bitmap-functions/bitmap-min.md b/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/bitmap-functions/bitmap-min.md
new file mode 100644
index 000000000000..db343f3d26ad
--- /dev/null
+++ b/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/bitmap-functions/bitmap-min.md
@@ -0,0 +1,76 @@
+---
+{
+ "title": "BITMAP_MIN",
+ "language": "ru",
+ "description": "Вычисляет и возвращает минимальное значение в Bitmap."
+}
+---
+
+## Описание {#description}
+
+Вычисляет и возвращает минимальное значение в Bitmap.
+
+## Синтаксис {#syntax}
+
+```sql
+BITMAP_MIN(<bitmap>)
+```
+
+## Параметры {#parameters}
+
+| Параметр | Описание |
+|------------|---------------------------------|
+| `<bitmap>` | Столбец или выражение типа Bitmap |
+
+## Возвращаемое значение {#return-value}
+
+Минимальное значение в Bitmap.
+Возвращает `NULL`, если Bitmap пуст или имеет значение NULL.
+
+## Примеры {#examples}
+
+Чтобы вычислить минимальное значение в пустом Bitmap:
+
+```sql
+select bitmap_min(bitmap_from_string('')) value;
+```
+
+Результат будет следующим:
+
+```text
++-------+
+| value |
++-------+
+| NULL |
++-------+
+```
+
+Чтобы вычислить минимальное значение в Bitmap с несколькими элементами:
+
+```sql
+select bitmap_min(bitmap_from_string('1,9999999999')) value;
+```
+
+Результат будет следующим:
+
+```text
++-------+
+| value |
++-------+
+| 1 |
++-------+
+```
+
+```sql
+select bitmap_min(bitmap_empty()) res1,bitmap_min(NULL) res2;
+```
+
+Результат будет следующим:
+
+```text
++------+------+
+| res1 | res2 |
++------+------+
+| NULL | NULL |
++------+------+
+```
diff --git a/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/bitmap-functions/bitmap-not.md b/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/bitmap-functions/bitmap-not.md
new file mode 100644
index 000000000000..a66e305b3ee5
--- /dev/null
+++ b/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/bitmap-functions/bitmap-not.md
@@ -0,0 +1,75 @@
+---
+{
+ "title": "BITMAP_NOT",
+ "language": "ru",
+ "description": "Вычисляет разность первого и второго Bitmap и возвращает результат в виде нового Bitmap."
+}
+---
+
+## Описание {#description}
+
+Вычисляет разность первого и второго Bitmap и возвращает результат в виде нового Bitmap.
+
+## Синтаксис {#syntax}
+
+```sql
+BITMAP_NOT(<bitmap1>, <bitmap2>)
+```
+
+## Параметры {#parameters}
+
+| Параметр | Описание |
+|-------------|----------------------|
+| `<bitmap1>` | Первый Bitmap |
+| `<bitmap2>` | Второй Bitmap |
+
+## Возвращаемое значение {#return-value}
+
+Bitmap, содержащий элементы из `<bitmap1>`, которые отсутствуют в `<bitmap2>`.
+- Если параметр имеет значение NULL, возвращается NULL
+
+## Примеры {#examples}
+
+Чтобы вычислить разность двух Bitmap:
+
+```sql
+select bitmap_to_string(bitmap_not(bitmap_from_string('2,3'), bitmap_from_string('1,2,3,4'))) as res;
+```
+
+Результатом будет пустой Bitmap, поскольку все элементы из `<bitmap1>` также присутствуют в `<bitmap2>`:
+
+```text
++------+
+| res |
++------+
+| |
++------+
+```
+
+Чтобы вычислить разность, когда в `<bitmap1>` есть элементы, отсутствующие в `<bitmap2>`:
+
+```sql
+select bitmap_to_string(bitmap_not(bitmap_from_string('2,3,5'), bitmap_from_string('1,2,3,4'))) as res;
+```
+
+Результатом будет Bitmap, содержащий элемент `5`:
+
+```text
++------+
+| res |
++------+
+| 5 |
++------+
+```
+
+```sql
+select bitmap_to_string(bitmap_not(bitmap_from_string('2,3,5'), NULL)) as res;
+```
+
+```text
++------+
+| res |
++------+
+| NULL |
++------+
+```
diff --git a/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/bitmap-functions/bitmap-or-count.md b/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/bitmap-functions/bitmap-or-count.md
new file mode 100644
index 000000000000..0ee7c153ef3b
--- /dev/null
+++ b/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/bitmap-functions/bitmap-or-count.md
@@ -0,0 +1,112 @@
+---
+{
+ "title": "BITMAP_OR_COUNT",
+ "language": "ru",
+ "description": "Вычисляет объединение двух или более входных Bitmap и возвращает количество элементов в объединении."
+}
+---
+
+## Описание {#description}
+
+Вычисляет объединение двух или более входных Bitmap и возвращает количество элементов в объединении.
+
+## Синтаксис {#syntax}
+
+```sql
+BITMAP_OR_COUNT(<bitmap1>, <bitmap2>, ..., <bitmapN>)
+```
+
+## Параметры {#parameters}
+
+| Параметр | Описание |
+|-------------|----------------|
+| `<bitmap1>` | Первый Bitmap |
+| `<bitmap2>` | Второй Bitmap |
+| ... | ... |
+| `<bitmapN>` | N-й Bitmap |
+
+## Возвращаемое значение {#return-value}
+
+Количество элементов в объединении нескольких Bitmap.
+
+## Примеры {#examples}
+
+Чтобы вычислить количество элементов в объединении непустого Bitmap и пустого Bitmap:
+
+```sql
+select bitmap_or_count(bitmap_from_string('1,2,3'), bitmap_empty()) res;
+```
+
+Результат:
+
+```text
++------+
+| res |
++------+
+| 3 |
++------+
+```
+
+Чтобы вычислить количество элементов в объединении двух одинаковых Bitmap:
+
+```sql
+select bitmap_or_count(bitmap_from_string('1,2,3'), bitmap_from_string('1,2,3')) res;
+```
+
+Результат:
+
+```text
++------+
+| res |
++------+
+| 3 |
++------+
+```
+
+Чтобы вычислить количество элементов в объединении двух разных Bitmap:
+
+```sql
+select bitmap_or_count(bitmap_from_string('1,2,3'), bitmap_from_string('3,4,5')) res;
+```
+
+Результат:
+
+```text
++------+
+| res |
++------+
+| 5 |
++------+
+```
+
+Чтобы вычислить количество элементов в объединении нескольких Bitmap, включая пустой Bitmap:
+
+```sql
+select bitmap_or_count(bitmap_from_string('1,2,3'), bitmap_from_string('3,4,5'), to_bitmap(100), bitmap_empty()) res;
+```
+
+Результат:
+
+```text
++------+
+| res |
++------+
+| 6 |
++------+
+```
+
+Чтобы вычислить количество элементов в объединении нескольких Bitmap, включая значение `NULL`:
+
+```sql
+select bitmap_or_count(bitmap_from_string('1,2,3'), bitmap_from_string('3,4,5'), to_bitmap(100), NULL) res;
+```
+
+Результат:
+
+```text
++------+
+| res |
++------+
+| 6 |
++------+
+```
diff --git a/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/bitmap-functions/bitmap-or.md b/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/bitmap-functions/bitmap-or.md
new file mode 100644
index 000000000000..1039399ea43e
--- /dev/null
+++ b/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/bitmap-functions/bitmap-or.md
@@ -0,0 +1,144 @@
+---
+{
+ "title": "BITMAP_OR",
+ "language": "ru",
+ "description": "Вычисляет объединение двух или более объектов Bitmap и возвращает новый объект Bitmap."
+}
+---
+
+## Описание {#description}
+
+Вычисляет объединение двух или более объектов Bitmap и возвращает новый объект Bitmap.
+
+## Синтаксис {#syntax}
+
+```sql
+BITMAP_OR(<bitmap1>, <bitmap2>, ..., <bitmapN>)
+```
+
+## Параметры {#parameters}
+
+| Параметр | Описание |
+|-------------|----------------|
+| `<bitmap1>` | Первый объект Bitmap |
+| `<bitmap2>` | Второй объект Bitmap |
+| ... | ... |
+| `<bitmapN>` | N-й объект Bitmap |
+
+## Возвращаемое значение {#return-value}
+
+Объект Bitmap, представляющий объединение нескольких объектов Bitmap.
+
+## Примеры {#examples}
+
+Вычисление объединения двух одинаковых объектов Bitmap:
+
+```sql
+select bitmap_count(bitmap_or(to_bitmap(1), to_bitmap(1))) cnt;
+```
+
+Результат будет следующим:
+
+```text
++------+
+| cnt |
++------+
+| 1 |
++------+
+```
+
+Преобразование объединения двух одинаковых объектов Bitmap в строку:
+
+```sql
+select bitmap_to_string(bitmap_or(to_bitmap(1), to_bitmap(1))) as res;
+```
+
+Результат будет следующим:
+
+```text
++------+
+| res |
++------+
+| 1 |
++------+
+```
+
+Вычисление объединения двух разных объектов Bitmap:
+
+```sql
+select bitmap_count(bitmap_or(to_bitmap(1), to_bitmap(2))) cnt;
+```
+
+Результат будет следующим:
+
+```text
++------+
+| cnt |
++------+
+| 2 |
++------+
+```
+
+Преобразование объединения двух разных объектов Bitmap в строку:
+
+```sql
+select bitmap_to_string(bitmap_or(to_bitmap(1), to_bitmap(2))) res;
+```
+
+Результат будет следующим:
+
+```text
++------+
+| res |
++------+
+| 1,2 |
++------+
+```
+
+Вычисление объединения нескольких объектов Bitmap, включая значение `NULL`:
+
+```sql
+select bitmap_to_string(bitmap_or(to_bitmap(1), to_bitmap(2), to_bitmap(10), to_bitmap(0), NULL)) res;
+```
+
+Результат будет следующим:
+
+```text
++----------+
+| res |
++----------+
+| 0,1,2,10 |
++----------+
+```
+
+Вычисление объединения нескольких объектов Bitmap, включая пустой объект Bitmap:
+
+```sql
+select bitmap_to_string(bitmap_or(to_bitmap(1), to_bitmap(2), to_bitmap(10), to_bitmap(0), bitmap_empty())) res;
+```
+
+Результат будет следующим:
+
+```text
++----------+
+| res |
++----------+
+| 0,1,2,10 |
++----------+
+```
+
+Вычисление объединения объектов Bitmap, созданных из строк и отдельных значений:
+
+```sql
+select bitmap_to_string(bitmap_or(to_bitmap(10), bitmap_from_string('1,2'), bitmap_from_string('1,2,3,4,5'))) res;
+```
+
+Результат будет следующим:
+
+```text
++--------------+
+| res |
++--------------+
+| 1,2,3,4,5,10 |
++--------------+
+```
diff --git a/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/bitmap-functions/bitmap-remove.md b/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/bitmap-functions/bitmap-remove.md
new file mode 100644
index 000000000000..d65e8834f5b8
--- /dev/null
+++ b/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/bitmap-functions/bitmap-remove.md
@@ -0,0 +1,65 @@
+---
+{
+ "title": "BITMAP_REMOVE",
+ "language": "ru",
+ "description": "Удаляет указанное значение из столбца Bitmap."
+}
+---
+
+## Описание {#description}
+
+Удаляет указанное значение из столбца Bitmap.
+
+## Синтаксис {#syntax}
+
+```sql
+BITMAP_REMOVE(<bitmap>, <value>)
+```
+
+## Параметры {#parameters}
+
+| Параметр | Описание |
+|-------------|----------------|
+| `<bitmap>` | Значение Bitmap |
+| `<value>` | Значение для удаления |
+
+## Возвращаемое значение {#return-value}
+
+Возвращает Bitmap после удаления указанного значения.
+
+Возвращает исходный Bitmap, если удаляемое значение отсутствует;
+Возвращает `NULL`, если удаляемое значение равно `NULL`.
+
+## Примеры {#examples}
+
+Удаление значения из Bitmap:
+
+```sql
+select bitmap_to_string(bitmap_remove(bitmap_from_string('1, 2, 3'), 3)) res;
+```
+
+Результат:
+
+```text
++------+
+| res |
++------+
+| 1,2 |
++------+
+```
+
+Удаление значения `NULL` из Bitmap:
+
+```sql
+select bitmap_to_string(bitmap_remove(bitmap_from_string('1, 2, 3'), null)) res;
+```
+
+Результат:
+
+```text
++------+
+| res |
++------+
+| NULL |
++------+
+```
diff --git a/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/bitmap-functions/bitmap-subset-in-range.md b/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/bitmap-functions/bitmap-subset-in-range.md
new file mode 100644
index 000000000000..9e7e4cc82364
--- /dev/null
+++ b/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/bitmap-functions/bitmap-subset-in-range.md
@@ -0,0 +1,94 @@
+---
+{
+ "title": "BITMAP_SUBSET_IN_RANGE",
+ "language": "ru",
+ "description": "Возвращает подмножество Bitmap в указанном диапазоне (исключая его правую границу)."
+}
+---
+
+## Описание {#description}
+
+Возвращает подмножество Bitmap в указанном диапазоне (исключая его правую границу).
+
+## Синтаксис {#syntax}
+
+```sql
+BITMAP_SUBSET_IN_RANGE(<bitmap>, <range_start_include>, <range_end_exclude>)
+```
+
+## Параметры {#parameters}
+
+| Параметр | Описание |
+|-----------------------|-------------------------------|
+| `<bitmap>` | Значение Bitmap |
+| `<range_start_include>` | Начало диапазона (включительно) |
+| `<range_end_exclude>` | Конец диапазона (не включается) |
+
+## Возвращаемое значение {#return-value}
+
+Подмножество Bitmap в указанном диапазоне.
+- Если параметр имеет значение NULL или указан недопустимый диапазон, возвращается NULL
+
+## Примеры {#examples}
+
+Чтобы получить подмножество Bitmap в диапазоне от 0 до 9:
+
+```sql
+select bitmap_to_string(bitmap_subset_in_range(bitmap_from_string('1,2,3,4,5'), 0, 9)) value;
+```
+
+Результат:
+
+```text
++-----------+
+| value |
++-----------+
+| 1,2,3,4,5 |
++-----------+
+```
+
+Чтобы получить подмножество Bitmap в диапазоне от 2 до 3:
+
+```sql
+select bitmap_to_string(bitmap_subset_in_range(bitmap_from_string('1,2,3,4,5'), 2, 3)) value;
+```
+
+Результат:
+
+```text
++-------+
+| value |
++-------+
+| 2 |
++-------+
+```
+
+
+```sql
+select bitmap_to_string(bitmap_subset_in_range(bitmap_from_string('1,2,3,4,5'), 2, NULL)) value;
+```
+
+Результат:
+
+```text
++-------+
+| value |
++-------+
+| NULL |
++-------+
+```
+
+
+```sql
+select bitmap_to_string(bitmap_subset_in_range(bitmap_from_string('1,2,3,4,5'), 2, -10000)) value;
+```
+
+Результат:
+
+```text
++-------+
+| value |
++-------+
+| NULL |
++-------+
+```
diff --git a/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/bitmap-functions/bitmap-subset-limit.md b/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/bitmap-functions/bitmap-subset-limit.md
new file mode 100644
index 000000000000..dbf61b403e74
--- /dev/null
+++ b/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/bitmap-functions/bitmap-subset-limit.md
@@ -0,0 +1,107 @@
+---
+{
+ "title": "BITMAP_SUBSET_LIMIT",
+ "language": "ru",
+ "description": "Извлекает подмножество элементов Bitmap, начиная с указанной позиции, с учётом заданного ограничения на количество элементов,"
+}
+---
+
+## Описание {#description}
+
+Извлекает подмножество элементов Bitmap, начиная с указанной позиции, с учётом заданного ограничения на количество элементов и возвращает подмножество в виде нового Bitmap.
+
+## Синтаксис {#syntax}
+
+```sql
+BITMAP_SUBSET_LIMIT(<bitmap>, <position>, <cardinality_limit>)
+```
+
+## Параметры {#parameters}
+
+| Параметр | Описание |
+|-----------------------|-------------------------------|
+| `<bitmap>` | Значение Bitmap |
+| `<position>` | Начальная позиция (включительно) |
+| `<cardinality_limit>` | Максимальное количество элементов |
+
+## Возвращаемое значение {#return-value}
+
+Подмножество Bitmap, соответствующее заданному диапазону и ограничению.
+- Если параметр имеет значение NULL или недопустимое значение, возвращается NULL
+
+## Примеры {#examples}
+
+Чтобы получить подмножество Bitmap, начиная с позиции 0, с ограничением количества элементов 3:
+
+```sql
+select bitmap_to_string(bitmap_subset_limit(bitmap_from_string('1,2,3,4,5'), 0, 3)) value;
+```
+
+Результат:
+
+```text
++-----------+
+| value |
++-----------+
+| 1,2,3 |
++-----------+
+```
+
+Чтобы получить подмножество Bitmap, начиная с позиции 4, с ограничением количества элементов 3:
+
+```sql
+select bitmap_to_string(bitmap_subset_limit(bitmap_from_string('1,2,3,4,5'), 4, 3)) value;
+```
+
+Результат:
+
+```text
++-------+
+| value |
++-------+
+| 4,5 |
++-------+
+```
+
+
+```sql
+select bitmap_to_string(bitmap_subset_limit(bitmap_from_string('1,2,3,4,5'), 4, NULL)) value;
+```
+
+Результат:
+
+```text
++-------+
+| value |
++-------+
+| NULL |
++-------+
+```
+
+```sql
+select bitmap_to_string(bitmap_subset_limit(bitmap_from_string('1,2,3,4,5'), -4, 3)) value;
+```
+
+Результат:
+
+```text
++-------+
+| value |
++-------+
+| NULL |
++-------+
+```
+
+```sql
+select bitmap_to_string(bitmap_subset_limit(bitmap_from_string('1,2,3,4,5'), 4, -3)) value;
+```
+
+Результат:
+
+```text
++-------+
+| value |
++-------+
+| NULL |
++-------+
+```
diff --git a/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/bitmap-functions/bitmap-to-array.md b/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/bitmap-functions/bitmap-to-array.md
new file mode 100644
index 000000000000..b813c8bd469a
--- /dev/null
+++ b/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/bitmap-functions/bitmap-to-array.md
@@ -0,0 +1,94 @@
+---
+{
+ "title": "BITMAP_TO_ARRAY",
+ "language": "ru",
+ "description": "Преобразует Bitmap в Array."
+}
+---
+
+## Описание {#description}
+
+Преобразует Bitmap в Array.
+
+## Синтаксис {#syntax}
+
+```sql
+BITMAP_TO_ARRAY(<bitmap>)
+```
+
+## Параметры {#parameters}
+
+| Параметр | Описание |
+|------------|---------------------------------|
+| `<bitmap>` | Столбец или выражение типа Bitmap |
+
+## Возвращаемое значение {#return-value}
+
+Массив, содержащий все позиции битов в Bitmap.
+Возвращает `NULL`, если Bitmap равен `NULL`.
+
+## Примеры {#examples}
+
+Преобразование Bitmap со значением `NULL` в массив:
+
+```sql
+select bitmap_to_array(null);
+```
+
+Результат:
+
+```text
++------------------------+
+| bitmap_to_array(NULL) |
++------------------------+
+| NULL |
++------------------------+
+```
+
+Преобразование пустого Bitmap в массив:
+
+```sql
+select bitmap_to_array(bitmap_empty());
+```
+
+Результат:
+
+```text
++---------------------------------+
+| bitmap_to_array(bitmap_empty()) |
++---------------------------------+
+| [] |
++---------------------------------+
+```
+
+Преобразование Bitmap с одним элементом в массив:
+
+```sql
+select bitmap_to_array(to_bitmap(1));
+```
+
+Результат:
+
+```text
++-------------------------------+
+| bitmap_to_array(to_bitmap(1)) |
++-------------------------------+
+| [1] |
++-------------------------------+
+```
+
+Преобразование Bitmap с несколькими элементами в массив:
+
+```sql
+select bitmap_to_array(bitmap_from_string('1,2,3,4,5'));
+```
+
+Результат:
+
+```text
++--------------------------------------------------+
+| bitmap_to_array(bitmap_from_string('1,2,3,4,5')) |
++--------------------------------------------------+
+| [1, 2, 3, 4, 5] |
++--------------------------------------------------+
+```
diff --git a/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/bitmap-functions/bitmap-to-base64.md b/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/bitmap-functions/bitmap-to-base64.md
new file mode 100644
index 000000000000..c33b51da02d9
--- /dev/null
+++ b/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/bitmap-functions/bitmap-to-base64.md
@@ -0,0 +1,101 @@
+---
+{
+ "title": "BITMAP_TO_BASE64",
+ "language": "ru",
+ "description": "Преобразует Bitmap в строку в кодировке Base64."
+}
+---
+
+## Описание {#description}
+
+Преобразует Bitmap в строку в кодировке Base64.
+
+## Синтаксис {#syntax}
+
+```sql
+BITMAP_TO_BASE64(<bitmap>)
+```
+
+## Параметры {#parameters}
+
+| Параметр | Описание |
+|------------|---------------------------------|
+| `<bitmap>` | Столбец или выражение типа Bitmap |
+
+## Возвращаемое значение {#return-value}
+
+Строка в кодировке Base64, представляющая Bitmap.
+Возвращает `NULL`, если Bitmap имеет значение `NULL`.
+
+::: note
+
+Параметр конфигурации BE `enable_set_in_bitmap_value` изменяет формат представления значений bitmap в памяти, что влияет на результат этой функции.
+Порядок элементов в bitmap не гарантирован, поэтому для одного и того же содержимого могут генерироваться разные строки Base64. Однако после декодирования с помощью `bitmap_from_base64` результатом будет один и тот же bitmap.
+
+:::
+
+## Примеры {#examples}
+
+Чтобы преобразовать Bitmap со значением `NULL` в строку Base64:
+
+```sql
+select bitmap_to_base64(null);
+```
+
+Результат:
+
+```text
++------------------------+
+| bitmap_to_base64(NULL) |
++------------------------+
+| NULL |
++------------------------+
+```
+
+Чтобы преобразовать пустой Bitmap в строку Base64:
+
+```sql
+select bitmap_to_base64(bitmap_empty());
+```
+
+Результат:
+
+```text
++----------------------------------+
+| bitmap_to_base64(bitmap_empty()) |
++----------------------------------+
+| AA== |
++----------------------------------+
+```
+
+Чтобы преобразовать Bitmap с одним элементом в строку Base64:
+
+```sql
+select bitmap_to_base64(to_bitmap(1));
+```
+
+Результат:
+
+```text
++--------------------------------+
+| bitmap_to_base64(to_bitmap(1)) |
++--------------------------------+
+| BQEBAAAAAAAAAA== |
++--------------------------------+
+```
+
+Чтобы преобразовать Bitmap с несколькими элементами в строку Base64:
+
+```sql
+select bitmap_to_base64(bitmap_from_string("1,9999999"));
+```
+
+Результат:
+
+```text
++---------------------------------------------------------+
+| bitmap_to_base64(bitmap_from_string("1,9999999")) |
++---------------------------------------------------------+
+| BQIBAAAAAAAAAH+WmAAAAAAA |
++---------------------------------------------------------+
+```
diff --git a/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/bitmap-functions/bitmap-to-string.md b/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/bitmap-functions/bitmap-to-string.md
new file mode 100644
index 000000000000..e99a77d5d495
--- /dev/null
+++ b/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/bitmap-functions/bitmap-to-string.md
@@ -0,0 +1,94 @@
+---
+{
+ "title": "BITMAP_TO_STRING",
+ "language": "ru",
+ "description": "Преобразует Bitmap в строку, содержащую позиции всех установленных битов через запятую."
+}
+---
+
+## Описание {#description}
+
+Преобразует Bitmap в строку, содержащую позиции всех установленных битов через запятую.
+
+## Синтаксис {#syntax}
+
+```sql
+BITMAP_TO_STRING(<bitmap>)
+```
+
+## Параметры {#parameters}
+
+| Параметр | Описание |
+|------------|---------------------------------|
+| `<bitmap>` | Столбец типа Bitmap или выражение |
+
+## Возвращаемое значение {#return-value}
+
+Строка, содержащая позиции всех установленных битов в Bitmap, разделённые запятыми.
+Возвращает `NULL`, если Bitmap имеет значение `NULL`.
+
+## Примеры {#examples}
+
+Преобразование Bitmap со значением `NULL` в строку:
+
+```sql
+select bitmap_to_string(null);
+```
+
+Результат:
+
+```text
++------------------------+
+| bitmap_to_string(NULL) |
++------------------------+
+| NULL |
++------------------------+
+```
+
+Преобразование пустого Bitmap в строку:
+
+```sql
+select bitmap_to_string(bitmap_empty());
+```
+
+Результат:
+
+```text
++----------------------------------+
+| bitmap_to_string(bitmap_empty()) |
++----------------------------------+
+| |
++----------------------------------+
+```
+
+Преобразование Bitmap с одним элементом в строку:
+
+```sql
+select bitmap_to_string(to_bitmap(1));
+```
+
+Результат:
+
+```text
++--------------------------------+
+| bitmap_to_string(to_bitmap(1)) |
++--------------------------------+
+| 1 |
++--------------------------------+
+```
+
+Преобразование Bitmap с несколькими элементами в строку:
+
+```sql
+select bitmap_to_string(bitmap_or(to_bitmap(1), to_bitmap(2)));
+```
+
+Результат:
+
+```text
++---------------------------------------------------------+
+| bitmap_to_string(bitmap_or(to_bitmap(1), to_bitmap(2))) |
++---------------------------------------------------------+
+| 1,2 |
++---------------------------------------------------------+
+```
diff --git a/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/bitmap-functions/bitmap-xor-count.md b/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/bitmap-functions/bitmap-xor-count.md
new file mode 100644
index 000000000000..0ae167f57e07
--- /dev/null
+++ b/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/bitmap-functions/bitmap-xor-count.md
@@ -0,0 +1,129 @@
+---
+{
+ "title": "BITMAP_XOR_COUNT",
+ "language": "ru",
+ "description": "Вычисляет симметрическую разность (операция XOR) двух или более множеств Bitmap и возвращает количество элементов в результирующем множестве."
+}
+---
+
+## Описание {#description}
+
+Вычисляет симметрическую разность (операция XOR) двух или более множеств Bitmap и возвращает количество элементов в результирующем множестве.
+
+## Синтаксис {#syntax}
+
+```sql
+BITMAP_XOR_COUNT(<bitmap1>, <bitmap2>, ..., <bitmapN>)
+```
+
+## Параметры {#parameters}
+
+| Параметр | Описание |
+|-------------|-------------------|
+| `<bitmap1>` | Первый Bitmap |
+| `<bitmap2>` | Второй Bitmap |
+| ... | ... |
+| `<bitmapN>` | N-й Bitmap |
+
+## Возвращаемое значение {#return-value}
+
+Количество элементов в Bitmap, полученном в результате операции XOR над несколькими Bitmap.
+Возвращает 0, если хотя бы один из входных параметров Bitmap равен `NULL`.
+
+## Примеры {#examples}
+
+Чтобы вычислить количество элементов в симметрической разности двух Bitmap:
+
+```sql
+select bitmap_xor_count(bitmap_from_string('1,2,3'), bitmap_from_string('3,4,5')) res;
+```
+
+Результат будет следующим:
+
+```text
++------+
+| res |
++------+
+| 4 |
++------+
+```
+
+Чтобы вычислить количество элементов в симметрической разности двух одинаковых Bitmap:
+
+```sql
+select bitmap_xor_count(bitmap_from_string('1,2,3'), bitmap_from_string('1,2,3')) res;
+```
+
+Результат будет следующим:
+
+```text
++------+
+| res |
++------+
+| 0 |
++------+
+```
+
+Чтобы вычислить количество элементов в симметрической разности двух разных Bitmap:
+
+```sql
+select bitmap_xor_count(bitmap_from_string('1,2,3'), bitmap_from_string('4,5,6')) res;
+```
+
+Результат будет следующим:
+
+```text
++------+
+| res |
++------+
+| 6 |
++------+
+```
+
+Чтобы вычислить количество элементов в симметрической разности трёх Bitmap:
+
+```sql
+select bitmap_xor_count(bitmap_from_string('2,3'), bitmap_from_string('1,2,3,4'), bitmap_from_string('3,4,5')) res;
+```
+
+Результат будет следующим:
+
+```text
++------+
+| res |
++------+
+| 3 |
++------+
+```
+
+Чтобы вычислить количество элементов в симметрической разности нескольких Bitmap, включая пустой Bitmap:
+
+```sql
+select bitmap_xor_count(bitmap_from_string('2,3'), bitmap_from_string('1,2,3,4'), bitmap_from_string('3,4,5'), bitmap_empty());
+```
+
+Результат будет следующим:
+
+```text
++------+
+| res |
++------+
+| 3 |
++------+
+```
+
+Чтобы вычислить количество элементов в симметрической разности нескольких Bitmap, включая значение `NULL`:
+
+```sql
+select bitmap_xor_count(bitmap_from_string('2,3'), bitmap_from_string('1,2,3,4'), bitmap_from_string('3,4,5'), NULL) res;
+```
+
+Результат будет следующим:
+
+```text
++------+
+| res |
++------+
+| 0 |
++------+
+```
diff --git a/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/bitmap-functions/bitmap-xor.md b/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/bitmap-functions/bitmap-xor.md
new file mode 100644
index 000000000000..a3b9909fe702
--- /dev/null
+++ b/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/bitmap-functions/bitmap-xor.md
@@ -0,0 +1,113 @@
+---
+{
+ "title": "BITMAP_XOR",
+ "language": "ru",
+ "description": "Вычисляет симметрическую разность (операция XOR) двух или более входных Bitmap и возвращает новый Bitmap."
+}
+---
+
+## Описание {#description}
+
+Вычисляет симметрическую разность (операция XOR) двух или более входных Bitmap и возвращает новый Bitmap.
+
+## Синтаксис {#syntax}
+
+```sql
+BITMAP_XOR(<bitmap1>, <bitmap2>, ..., <bitmapN>)
+```
+
+## Параметры {#parameters}
+
+| Параметр | Описание |
+|-------------|-------------------|
+| `<bitmap1>` | Первый Bitmap |
+| `<bitmap2>` | Второй Bitmap |
+| ... | ... |
+| `<bitmapN>` | N-й Bitmap |
+
+## Возвращаемое значение {#return-value}
+
+Bitmap, представляющий симметрическую разность нескольких Bitmap.
+- Если параметр имеет значение NULL, возвращается NULL
+
+## Примеры {#examples}
+
+Вычисление симметрической разности двух Bitmap:
+
+```sql
+select bitmap_count(bitmap_xor(bitmap_from_string('2,3'), bitmap_from_string('1,2,3,4'))) cnt;
+```
+
+Результат:
+
+```text
++------+
+| cnt |
++------+
+| 2 |
++------+
+```
+
+Преобразование симметрической разности двух Bitmap в строку:
+
+```sql
+select bitmap_to_string(bitmap_xor(bitmap_from_string('2,3'), bitmap_from_string('1,2,3,4'))) res;
+```
+
+Результат:
+
+```text
++------+
+| res |
++------+
+| 1,4 |
++------+
+```
+
+Вычисление симметрической разности трёх Bitmap:
+
+```sql
+select bitmap_to_string(bitmap_xor(bitmap_from_string('2,3'), bitmap_from_string('1,2,3,4'), bitmap_from_string('3,4,5'))) res;
+```
+
+Результат:
+
+```text
++-------+
+| res |
++-------+
+| 1,3,5 |
++-------+
+```
+
+Вычисление симметрической разности нескольких Bitmap, включая пустой Bitmap:
+
+```sql
+select bitmap_to_string(bitmap_xor(bitmap_from_string('2,3'), bitmap_from_string('1,2,3,4'), bitmap_from_string('3,4,5'), bitmap_empty())) res;
+```
+
+Результат:
+
+```text
++-------+
+| res |
++-------+
+| 1,3,5 |
++-------+
+```
+
+Вычисление симметрической разности нескольких Bitmap, включая значение `NULL`:
+
+```sql
+select bitmap_to_string(bitmap_xor(bitmap_from_string('2,3'), bitmap_from_string('1,2,3,4'), bitmap_from_string('3,4,5'), NULL)) res;
+```
+
+Результат:
+
+```text
++------+
+| res |
++------+
+| NULL |
++------+
+```
diff --git a/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/bitmap-functions/sub-bitmap.md b/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/bitmap-functions/sub-bitmap.md
new file mode 100644
index 000000000000..a2e840e86412
--- /dev/null
+++ b/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/bitmap-functions/sub-bitmap.md
@@ -0,0 +1,95 @@
+---
+{
+ "title": "SUB_BITMAP",
+ "language": "ru",
+ "description": "Извлекает подмножество элементов Bitmap, начиная с указанной позиции и ограничивая их количество заданным пределом,"
+}
+---
+
+## Описание {#description}
+
+Извлекает подмножество элементов Bitmap, начиная с указанной позиции и ограничивая их количество заданным пределом, и возвращает это подмножество в виде нового Bitmap.
+
+## Синтаксис {#syntax}
+
+```sql
+SUB_BITMAP(<bitmap>, <position>, <cardinality_limit>)
+```
+
+## Параметры {#parameters}
+
+| Параметр | Описание |
+|-----------------------|-------------------------------|
+| `<bitmap>` | Значение Bitmap |
+| `<position>` | Начальная позиция (включительно). При отрицательной индексации последний элемент имеет индекс -1. |
+| `<cardinality_limit>` | Максимальное количество элементов |
+
+## Возвращаемое значение {#return-value}
+
+Bitmap, содержащий подмножество элементов в заданном диапазоне с учётом ограничения на их количество.
+- Если параметр равен NULL, возвращает NULL
+
+
+## Примеры {#examples}
+
+Чтобы получить подмножество Bitmap с позиции 0 и с ограничением количества элементов до 3:
+
+```sql
+select bitmap_to_string(sub_bitmap(bitmap_from_string('1,0,1,2,3,1,5'), 0, 3)) value;
+```
+
+Результат:
+
+```text
++-------+
+| value |
++-------+
+| 0,1,2 |
++-------+
+```
+
+Чтобы получить подмножество Bitmap с позиции -3 и с ограничением количества элементов до 2:
+
+```sql
+select bitmap_to_string(sub_bitmap(bitmap_from_string('1,0,1,2,3,1,5'), -3, 2)) value;
+```
+
+Результат:
+
+```text
++-------+
+| value |
++-------+
+| 2,3 |
++-------+
+```
+
+Чтобы получить подмножество Bitmap с позиции 2 и с ограничением количества элементов до 100:
+
+```sql
+select bitmap_to_string(sub_bitmap(bitmap_from_string('1,0,1,2,3,1,5'), 2, 100)) value;
+```
+
+Результат:
+
+```text
++-------+
+| value |
++-------+
+| 2,3,5 |
++-------+
+```
+
+```sql
+select bitmap_to_string(sub_bitmap(bitmap_from_string('1,0,1,2,3,1,5'), 2, NULL)) value;
+```
+
+Результат:
+
+```text
++-------+
+| value |
++-------+
+| NULL |
++-------+
+```
diff --git a/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/bitmap-functions/to-bitmap.md b/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/bitmap-functions/to-bitmap.md
new file mode 100644
index 000000000000..33d7a934a6c3
--- /dev/null
+++ b/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/bitmap-functions/to-bitmap.md
@@ -0,0 +1,107 @@
+---
+{
+ "title": "TO_BITMAP",
+ "language": "ru",
+ "description": "Преобразует беззнаковое значение bigint в Bitmap."
+}
+---
+
+## Описание {#description}
+
+Преобразует беззнаковое значение bigint в Bitmap.
+
+На вход подаётся беззнаковое значение bigint в диапазоне от 0 до 18446744073709551615, а на выходе получается Bitmap, содержащий этот элемент.
+
+## Синтаксис {#syntax}
+
+```sql
+TO_BITMAP(<expr>)
+```
+
+## Параметры {#parameters}
+
+| Параметр | Описание |
+|-----------|----------------------------------------------------|
+| `<expr>` | Беззнаковое значение bigint или число, представленное строкой, в диапазоне от 0 до 18446744073709551615 |
+
+## Возвращаемое значение {#return-value}
+
+Bitmap, содержащий соответствующее значение bigint.
+Возвращает пустой Bitmap, если входное значение выходит за указанный диапазон.
+
+## Примеры {#examples}
+
+Чтобы преобразовать целое число в Bitmap и подсчитать количество элементов в Bitmap:
+
+```sql
+select bitmap_to_string(to_bitmap(10)),bitmap_count(to_bitmap(10));
+```
+
+Результат:
+
+```text
++---------------------------------+-----------------------------+
+| bitmap_to_string(to_bitmap(10)) | bitmap_count(to_bitmap(10)) |
++---------------------------------+-----------------------------+
+| 10 | 1 |
++---------------------------------+-----------------------------+
+```
+
+```sql
+select bitmap_to_string(to_bitmap("123")),bitmap_count(to_bitmap("123"));
+```
+
+Результат:
+
+```text
++------------------------------------+--------------------------------+
+| bitmap_to_string(to_bitmap("123")) | bitmap_count(to_bitmap("123")) |
++------------------------------------+--------------------------------+
+| 123 | 1 |
++------------------------------------+--------------------------------+
+```
+
+Чтобы преобразовать отрицательное целое число, выходящее за допустимый диапазон, в Bitmap, а затем в строку:
+
+```sql
+select bitmap_to_string(to_bitmap(-1)),bitmap_count(to_bitmap(-1));
+```
+
+Результат:
+
+```text
++---------------------------------+-----------------------------+
+| bitmap_to_string(to_bitmap(-1)) | bitmap_count(to_bitmap(-1)) |
++---------------------------------+-----------------------------+
+| | 0 |
++---------------------------------+-----------------------------+
+```
+
+```sql
+select bitmap_to_string(to_bitmap("123ABC")),bitmap_count(to_bitmap("123ABC"));
+```
+
+Результат:
+
+```text
++---------------------------------------+-----------------------------------+
+| bitmap_to_string(to_bitmap("123ABC")) | bitmap_count(to_bitmap("123ABC")) |
++---------------------------------------+-----------------------------------+
+| | 0 |
++---------------------------------------+-----------------------------------+
+```
+
+
+```sql
+select bitmap_to_string(to_bitmap(NULL)),bitmap_count(to_bitmap(NULL));
+```
+
+Результат:
+
+```text
++-----------------------------------+-------------------------------+
+| bitmap_to_string(to_bitmap(NULL)) | bitmap_count(to_bitmap(NULL)) |
++-----------------------------------+-------------------------------+
+| | 0 |
++-----------------------------------+-------------------------------+
+```
diff --git a/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/bitwise-functions/bit-length.md b/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/bitwise-functions/bit-length.md
new file mode 100644
index 000000000000..bed72319baae
--- /dev/null
+++ b/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/bitwise-functions/bit-length.md
@@ -0,0 +1,48 @@
+---
+{
+ "title": "BIT_LENGTH",
+ "language": "ru",
+ "description": "Возвращает длину строки или двоичного значения в битах (то есть длину в байтах × 8)."
+}
+---
+
+## Описание {#description}
+
+Возвращает длину строки или двоичного значения в битах (то есть длину в байтах × 8).
+
+## Синтаксис {#syntax}
+```sql
+BIT_LENGTH(<str>)
+```
+
+## Параметры {#parameters}
+- `<str>` Строковое значение, длину которого в битах необходимо вернуть.
+
+## Возвращаемое значение {#return-value}
+
+Возвращает количество битов, занимаемых `<str>` в двоичном представлении, с учётом всех битов `0` и `1`.
+
+## Примеры {#examples}
+1. Пример 1
+ ```sql
+ select BIT_LENGTH("abc"), BIT_LENGTH("中国"), BIT_LENGTH(123);
+ ```
+
+ ```text
+ +-------------------+----------------------+-----------------+
+ | BIT_LENGTH("abc") | BIT_LENGTH("中国") | BIT_LENGTH(123) |
+ +-------------------+----------------------+-----------------+
+ | 24 | 48 | 24 |
+ +-------------------+----------------------+-----------------+
+ ```
+2. Аргумент NULL
+ ```sql
+ select BIT_LENGTH(NULL);
+ ```
+ ```text
+ +------------------+
+ | BIT_LENGTH(NULL) |
+ +------------------+
+ | NULL |
+ +------------------+
+ ```
diff --git a/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/bitwise-functions/bit-test.md b/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/bitwise-functions/bit-test.md
new file mode 100644
index 000000000000..aaf8bc64987e
--- /dev/null
+++ b/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/bitwise-functions/bit-test.md
@@ -0,0 +1,58 @@
+---
+{
+ "title": "BIT_TEST",
+ "language": "ru",
+ "description": "Преобразует значение <x> в двоичное представление и возвращает значение для указанных позиций <bits>, где нумерация <bits> начинается с 0 (крайний правый бит)."
+}
+---
+
+## Описание {#description}
+Преобразует значение `<x>` в двоичное представление и возвращает значение для указанных позиций `<bits>`, где нумерация `<bits>` начинается с 0 (крайний правый бит).
+
+Если `<bits>` содержит несколько значений, значения битов в этих позициях объединяются с помощью оператора AND, и возвращается итоговый результат.
+
+Если какое-либо значение в `<bits>` отрицательно или превышает общее число битов в `<x>`, результат равен 0.
+
+Поддерживаемые целочисленные типы для `<x>`: TINYINT, SMALLINT, INT, BIGINT, LARGEINT.
+
+## Псевдоним {#alias}
+- BIT_TEST_ALL
+
+## Синтаксис {#syntax}
+```sql
+BIT_TEST(<x>, <bits>[, <bits> ... ])
+```
+
+## Параметры {#parameters}
+- `<x>`
+- `<bits>`
+
+## Возвращаемое значение {#return-value}
+
+Возвращает значение для указанных позиций.
+
+## Примеры {#examples}
+1. Пример 1
+ ```sql
+ select BIT_TEST(43, 1), BIT_TEST(43, -1), BIT_TEST(43, 2), BIT_TEST(43, 0, 1, 3, 5), BIT_TEST(43, 0, 1, 3, 5, 2);
+ ```
+ ```text
+ +-----------------+------------------+-----------------+--------------------------+-----------------------------+
+ | BIT_TEST(43, 1) | BIT_TEST(43, -1) | BIT_TEST(43, 2) | BIT_TEST(43, 0, 1, 3, 5) | BIT_TEST(43, 0, 1, 3, 5, 2) |
+ +-----------------+------------------+-----------------+--------------------------+-----------------------------+
+ | 1 | 0 | 0 | 1 | 0 |
+ +-----------------+------------------+-----------------+--------------------------+-----------------------------+
+ ```
+ > Двоичное представление числа 43 — "101011", поэтому `BIT_TEST(43, 1)` возвращает 1, `BIT_TEST(43, 2)` возвращает 0, а `BIT_TEST(43, 0, 1, 3, 5)` возвращает 1.
+ > `BIT_TEST(43, 0, 1, 3, 5, 2)` возвращает 0.
+2. Аргумент NULL
+ ```sql
+ select BIT_TEST(NULL, 1), BIT_TEST(43, NULL), BIT_TEST(NULL, NULL);
+ ```
+ ```text
+ +-------------------+--------------------+----------------------+
+ | BIT_TEST(NULL, 1) | BIT_TEST(43, NULL) | BIT_TEST(NULL, NULL) |
+ +-------------------+--------------------+----------------------+
+ | NULL | NULL | NULL |
+ +-------------------+--------------------+----------------------+
+ ```
diff --git a/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/bitwise-functions/bitand.md b/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/bitwise-functions/bitand.md
new file mode 100644
index 000000000000..f30ce92641f5
--- /dev/null
+++ b/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/bitwise-functions/bitand.md
@@ -0,0 +1,49 @@
+---
+{
+ "title": "BITAND",
+ "language": "ru",
+ "description": "Выполняет побитовую операцию AND. При побитовой операции AND сравниваются соответствующие биты двух целых чисел; результат равен 1, только если оба соответствующих бита равны 1,"
+}
+---
+
+## Описание {#description}
+Выполняет побитовую операцию AND. При побитовой операции AND сравниваются соответствующие биты двух целых чисел; результат равен 1, только если оба соответствующих бита равны 1, иначе результат равен 0.
+
+Поддерживаемые целочисленные типы: TINYINT, SMALLINT, INT, BIGINT, LARGEINT
+
+## Синтаксис {#syntax}
+```sql
+BITAND(<lhs>, <rhs>)
+```
+
+## Параметры {#parameters}
+- `<lhs>`: Первое целое число для побитовой операции AND.
+- `<rhs>`: Второе целое число для побитовой операции AND.
+
+## Возвращаемое значение {#return-value}
+Возвращает результат побитовой операции AND над двумя целыми числами.
+
+
+## Примеры {#examples}
+1. Пример 1
+ ```sql
+ select BITAND(3,5), BITAND(5, 10), BITAND(7, 10);
+ ```
+ ```text
+ +-------------+---------------+---------------+
+ | BITAND(3,5) | BITAND(5, 10) | BITAND(7, 10) |
+ +-------------+---------------+---------------+
+ | 1 | 0 | 2 |
+ +-------------+---------------+---------------+
+ ```
+2. Аргумент NULL
+ ```sql
+ select BITAND(1, null), BITAND(null, 1), BITAND(null, null);
+ ```
+ ```text
+ +-----------------+-----------------+--------------------+
+ | BITAND(1, null) | BITAND(null, 1) | BITAND(null, null) |
+ +-----------------+-----------------+--------------------+
+ | NULL | NULL | NULL |
+ +-----------------+-----------------+--------------------+
+ ```
diff --git a/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/bitwise-functions/bitcount.md b/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/bitwise-functions/bitcount.md
new file mode 100644
index 000000000000..98d8ec7cdd65
--- /dev/null
+++ b/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/bitwise-functions/bitcount.md
@@ -0,0 +1,47 @@
+---
+{
+ "title": "BIT_COUNT",
+ "language": "ru",
+ "description": "Возвращает количество битов со значением 1 в двоичном представлении целого числа."
+}
+---
+
+## Описание {#description}
+
+Возвращает количество битов со значением 1 в двоичном представлении целого числа. Эта функция позволяет быстро подсчитать «активные» биты в двоичном представлении целого числа, что часто полезно при анализе распределения данных или выполнении определённых побитовых операций.
+
+## Синтаксис {#syntax}
+```sql
+BIT_COUNT(<x>)
+```
+
+## Параметры {#parameters}
+- `<x>`: Целое число, в двоичном представлении которого подсчитываются биты со значением 1. Поддерживаемые типы: TINYINT, SMALLINT, INT, BIGINT, LARGEINT.
+
+## Возвращаемое значение {#return-value}
+
+Возвращает количество битов со значением 1 в двоичном представлении `<x>`.
+
+## Примеры {#examples}
+1. Пример 1
+ ```sql
+ select BIT_COUNT(0), BIT_COUNT(8), BIT_COUNT(-1);
+ ```
+ ```text
+ +--------------+--------------+---------------+
+ | BIT_COUNT(0) | BIT_COUNT(8) | BIT_COUNT(-1) |
+ +--------------+--------------+---------------+
+ | 0 | 1 | 8 |
+ +--------------+--------------+---------------+
+ ```
+2. Аргумент NULL
+ ```sql
+ select BIT_COUNT(NULL);
+ ```
+ ```text
+ +-----------------+
+ | BIT_COUNT(NULL) |
+ +-----------------+
+ | NULL |
+ +-----------------+
+ ```
diff --git a/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/bitwise-functions/bitnot.md b/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/bitwise-functions/bitnot.md
new file mode 100644
index 000000000000..a24d6e403d1d
--- /dev/null
+++ b/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/bitwise-functions/bitnot.md
@@ -0,0 +1,47 @@
+---
+{
+ "title": "BITNOT",
+ "language": "ru",
+ "description": "Выполняет побитовую операцию NOT над целым числом."
+}
+---
+
+## Описание {#description}
+Выполняет побитовую операцию NOT над целым числом.
+
+Поддерживаемые целочисленные типы: TINYINT, SMALLINT, INT, BIGINT, LARGEINT.
+
+## Синтаксис {#syntax}
+```sql
+BITNOT(<x>)
+```
+
+## Параметры {#parameters}
+- `<x>`: Целое число, над которым выполняется операция.
+
+## Возвращаемое значение {#return-value}
+Возвращает результат побитовой операции NOT над целым числом.
+
+## Примеры {#examples}
+1. Пример 1
+ ```sql
+ select BITNOT(7), BITNOT(-127);
+ ```
+ ```text
+ +-----------+--------------+
+ | BITNOT(7) | BITNOT(-127) |
+ +-----------+--------------+
+ | -8 | 126 |
+ +-----------+--------------+
+ ```
+2. Аргумент со значением NULL
+ ```sql
+ select BITNOT(NULL);
+ ```
+ ```text
+ +--------------+
+ | BITNOT(NULL) |
+ +--------------+
+ | NULL |
+ +--------------+
+ ```
diff --git a/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/bitwise-functions/bitor.md b/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/bitwise-functions/bitor.md
new file mode 100644
index 000000000000..14e373fdadd3
--- /dev/null
+++ b/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/bitwise-functions/bitor.md
@@ -0,0 +1,49 @@
+---
+{
+ "title": "BITOR",
+ "language": "ru",
+ "description": "Выполняет побитовую операцию OR над двумя целыми числами."
+}
+---
+
+## Описание {#description}
+Выполняет побитовую операцию OR над двумя целыми числами.
+
+Поддерживаемые целочисленные типы: TINYINT, SMALLINT, INT, BIGINT, LARGEINT
+
+## Синтаксис {#syntax}
+```sql
+BITOR(<lhs>, <rhs>)
+```
+
+## Параметры {#parameters}
+- `<lhs>`: Первое целое число для операции.
+- `<rhs>`: Второе целое число для операции.
+
+## Возвращаемое значение {#return-value}
+
+Возвращает результат побитовой операции OR над двумя целыми числами.
+
+## Примеры {#examples}
+1. Пример 1
+ ```sql
+ select BITOR(3,5), BITOR(4,7);
+ ```
+ ```text
+ +------------+------------+
+ | BITOR(3,5) | BITOR(4,7) |
+ +------------+------------+
+ | 7 | 7 |
+ +------------+------------+
+ ```
+2. Аргумент NULL
+ ```sql
+ select BITOR(3, NULL), BITOR(NULL, 5), BITOR(NULL, NULL);
+ ```
+ ```text
+ +----------------+----------------+-------------------+
+ | BITOR(3, NULL) | BITOR(NULL, 5) | BITOR(NULL, NULL) |
+ +----------------+----------------+-------------------+
+ | NULL | NULL | NULL |
+ +----------------+----------------+-------------------+
+ ```
diff --git a/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/bitwise-functions/bitshiftleft.md b/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/bitwise-functions/bitshiftleft.md
new file mode 100644
index 000000000000..1305ea113c21
--- /dev/null
+++ b/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/bitwise-functions/bitshiftleft.md
@@ -0,0 +1,48 @@
+---
+{
+ "title": "BIT_SHIFT_LEFT",
+ "language": "ru",
+ "description": "Выполняет операцию сдвига влево, при которой все биты двоичного числа сдвигаются влево на указанное число позиций."
+}
+---
+
+## Описание {#description}
+Выполняет операцию сдвига влево, при которой все биты двоичного числа сдвигаются влево на указанное число позиций. Это побитовая операция, которая часто используется для обработки двоичных данных или эффективного выполнения математических вычислений.
+
+Для максимального значения типа BIGINT (9223372036854775807) сдвиг влево на одну позицию даёт -2.
+## Синтаксис {#syntax}
+```sql
+BIT_SHIFT_LEFT(<x>, <bits>)
+```
+
+## Параметры {#parameters}
+- `<x>`: Число, к которому применяется сдвиг.
+- `<bits>`: Количество позиций для сдвига влево. Это целое число, определяющее, на сколько позиций будет сдвинуто число `<x>`.
+
+## Возвращаемое значение {#return-value}
+Возвращает целое число, представляющее результат операции сдвига влево.
+
+## Примеры {#examples}
+1. Пример 1
+ ```sql
+ select BIT_SHIFT_LEFT(5, 2), BIT_SHIFT_LEFT(-5, 2), BIT_SHIFT_LEFT(9223372036854775807, 1);
+ ```
+
+ ```text
+ +----------------------+-----------------------+----------------------------------------+
+ | BIT_SHIFT_LEFT(5, 2) | BIT_SHIFT_LEFT(-5, 2) | BIT_SHIFT_LEFT(9223372036854775807, 1) |
+ +----------------------+-----------------------+----------------------------------------+
+ | 20 | -20 | -2 |
+ +----------------------+-----------------------+----------------------------------------+
+ ```
+2. Аргумент NULL
+ ```sql
+ select BIT_SHIFT_LEFT(5, NULL), BIT_SHIFT_LEFT(NULL, 2), BIT_SHIFT_LEFT(NULL, NULL);
+ ```
+ ```text
+ +-------------------------+-------------------------+----------------------------+
+ | BIT_SHIFT_LEFT(5, NULL) | BIT_SHIFT_LEFT(NULL, 2) | BIT_SHIFT_LEFT(NULL, NULL) |
+ +-------------------------+-------------------------+----------------------------+
+ | NULL | NULL | NULL |
+ +-------------------------+-------------------------+----------------------------+
+ ```
diff --git a/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/bitwise-functions/bitshiftright.md b/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/bitwise-functions/bitshiftright.md
new file mode 100644
index 000000000000..959a5eb648b8
--- /dev/null
+++ b/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/bitwise-functions/bitshiftright.md
@@ -0,0 +1,52 @@
+---
+{
+ "title": "BIT_SHIFT_RIGHT",
+ "language": "ru",
+ "description": "Выполняет побитовый сдвиг вправо, при котором все биты двоичного числа сдвигаются вправо на заданное количество позиций."
+}
+---
+
+## Описание {#description}
+Выполняет побитовый сдвиг вправо, при котором все биты двоичного числа сдвигаются вправо на заданное количество позиций. Эта операция обычно используется для обработки двоичных данных или эффективного выполнения математических вычислений (например, деления).
+
+Логический сдвиг числа -1 вправо на одну позицию даёт BIGINT_MAX (9223372036854775807).
+
+Сдвиг числа вправо на отрицательное количество позиций всегда даёт 0.
+
+## Синтаксис {#syntax}
+```sql
+BIT_SHIFT_RIGHT(<x>, <bits>)
+```
+
+
+## Параметры {#parameters}
+- `<x>`: Число, к которому применяется сдвиг.
+- `<bits>`: Количество позиций для сдвига вправо. Это целое число, определяющее, на сколько позиций будет сдвинуто число `<x>`.
+
+## Возвращаемое значение {#return-value}
+
+Возвращает целое число, представляющее результат операции сдвига вправо.
+
+## Примеры {#examples}
+1. Пример 1
+ ```sql
+ select BIT_SHIFT_RIGHT(1024,3), BIT_SHIFT_RIGHT(-1,1), BIT_SHIFT_RIGHT(100, -1);
+ ```
+ ```text
+ +-------------------------+-----------------------+--------------------------+
+ | BIT_SHIFT_RIGHT(1024,3) | BIT_SHIFT_RIGHT(-1,1) | BIT_SHIFT_RIGHT(100, -1) |
+ +-------------------------+-----------------------+--------------------------+
+ | 128 | 9223372036854775807 | 0 |
+ +-------------------------+-----------------------+--------------------------+
+ ```
+2. Аргумент NULL
+ ```sql
+ select BIT_SHIFT_RIGHT(1024, NULL), BIT_SHIFT_RIGHT(NULL, 3), BIT_SHIFT_RIGHT(NULL, NULL);
+ ```
+ ```text
+ +-----------------------------+--------------------------+-----------------------------+
+ | BIT_SHIFT_RIGHT(1024, NULL) | BIT_SHIFT_RIGHT(NULL, 3) | BIT_SHIFT_RIGHT(NULL, NULL) |
+ +-----------------------------+--------------------------+-----------------------------+
+ | NULL | NULL | NULL |
+ +-----------------------------+--------------------------+-----------------------------+
+ ```
diff --git a/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/bitwise-functions/xor.md b/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/bitwise-functions/xor.md
new file mode 100644
index 000000000000..6e5a233c91b9
--- /dev/null
+++ b/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/bitwise-functions/xor.md
@@ -0,0 +1,49 @@
+---
+{
+ "title": "XOR | Побитовые функции",
+ "language": "ru",
+ "description": "Выполняет побитовую операцию XOR над двумя значениями BOOLEAN.",
+ "sidebar_label": "XOR"
+}
+---
+
+# XOR {#xor}
+
+## Описание {#description}
+Выполняет побитовую операцию XOR над двумя значениями BOOLEAN.
+
+## Синтаксис {#syntax}
+```sql
+<lhs> XOR <rhs>
+```
+
+## Параметры {#parameters}
+- `<lhs>`: Первое значение BOOLEAN для побитовой операции XOR.
+- `<rhs>`: Второе значение BOOLEAN для побитовой операции XOR.
+
+## Возвращаемое значение {#return-value}
+Возвращает результат операции XOR над двумя значениями BOOLEAN.
+
+## Примеры {#examples}
+1. Пример 1
+ ```sql
+ select true XOR false, true XOR true;
+ ```
+ ```text
+ +----------------+---------------+
+ | true XOR false | true XOR true |
+ +----------------+---------------+
+ | 1 | 0 |
+ +----------------+---------------+
+ ```
+2. Аргумент NULL
+ ```sql
+ select true XOR NULL, NULL XOR true, false XOR NULL, NULL XOR false, NULL XOR NULL;
+ ```
+ ```text
+ +---------------+---------------+----------------+----------------+---------------+
+ | true XOR NULL | NULL XOR true | false XOR NULL | NULL XOR false | NULL XOR NULL |
+ +---------------+---------------+----------------+----------------+---------------+
+ | NULL | NULL | NULL | NULL | NULL |
+ +---------------+---------------+----------------+----------------+---------------+
+ ```
diff --git a/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/conditional-functions/coalesce.md b/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/conditional-functions/coalesce.md
new file mode 100644
index 000000000000..3945513a0d36
--- /dev/null
+++ b/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/conditional-functions/coalesce.md
@@ -0,0 +1,63 @@
+---
+{
+ "title": "COALESCE",
+ "language": "ru",
+ "description": "Вычисляет выражения в списке аргументов слева направо и возвращает первое из них со значением, отличным от NULL. Если все аргументы равны NULL, возвращает NULL."
+}
+---
+
+## Описание {#description}
+
+Вычисляет выражения в списке аргументов слева направо и возвращает первое из них со значением, отличным от NULL. Если все аргументы равны NULL, возвращает NULL.
+
+## Синтаксис {#syntax}
+
+```sql
+COALESCE( <expr1> [ , ... , <exprN> ] )
+```
+
+## Параметры {#parameters}
+### Обязательный параметр {#required-parameter}
+- `<expr1>`: Выражение любого типа.
+### Переменное число параметров {#variadic-parameters}
+- Функция `COALESCE` поддерживает переменное число параметров.
+
+## Возвращаемое значение {#return-value}
+Возвращает первое выражение в списке аргументов со значением, отличным от NULL. Если все аргументы равны NULL, возвращает NULL.
+
+## Примечания по использованию {#usage-notes}
+1. Типы аргументов должны по возможности совпадать.
+2. Если типы аргументов различаются, функция попытается привести их к одному типу. Правила преобразования см. в разделе [Преобразование типов](../../../basic-element/sql-data-types/conversion/overview.md)
+3. В настоящее время в качестве аргументов поддерживаются только следующие типы:
+ * Строковые типы (String/VARCHAR/CHAR)
+ * Логический тип (Boolean)
+ * Числовые типы (TinyInt, SmallInt, Int, BigInt, LargeInt, Float, Double, Decimal)
+ * Типы даты и времени (Date, DateTime, TimestampNs)
+ * Тип Bitmap (Bitmap)
+ * Полуструктурированные типы (JSON, Array, MAP, Struct)
+
+## Примеры {#examples}
+1. Преобразование типов аргументов
+ ```sql
+ select coalesce(null, 2, 1.234);
+ ```
+ ```text
+ +--------------------------+
+ | coalesce(null, 2, 1.234) |
+ +--------------------------+
+ | 2.000 |
+ +--------------------------+
+ ```
+ > Поскольку третий аргумент "1.234" имеет тип Decimal, аргумент "2" преобразуется в тип Decimal.
+
+2. Все аргументы равны NULL
+ ```sql
+ select coalesce(null, null, null);
+ ```
+ ```text
+ +----------------------------+
+ | coalesce(null, null, null) |
+ +----------------------------+
+ | NULL |
+ +----------------------------+
+ ```
diff --git a/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/conditional-functions/greatest.md b/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/conditional-functions/greatest.md
new file mode 100644
index 000000000000..4d8edbbe8f20
--- /dev/null
+++ b/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/conditional-functions/greatest.md
@@ -0,0 +1,78 @@
+---
+{
+ "title": "GREATEST",
+ "language": "ru",
+ "description": "Сравнивает несколько выражений и возвращает наибольшее из их значений. Если хотя бы один аргумент равен NULL, возвращает NULL."
+}
+---
+
+## Описание {#description}
+
+Сравнивает несколько выражений и возвращает наибольшее из их значений. Если хотя бы один аргумент равен `NULL`, возвращает `NULL`.
+
+## Синтаксис {#syntax}
+
+```sql
+GREATEST(<expr> [, ...])
+```
+
+## Параметры {#parameters}
+### Обязательный параметр {#required-parameter}
+- `<expr>`: Поддерживает типы `TINYINT`, `SMALLINT`, `INT`, `BIGINT`, `LARGEINT`, `FLOAT`, `DOUBLE`, `STRING`, `DATETIME`, `TIMESTAMP_NS` и `DECIMAL`.
+### Необязательные параметры {#optional-parameters}
+- Поддерживается передача нескольких аргументов.
+
+## Возвращаемое значение {#return-value}
+- Возвращает наибольшее значение среди заданных выражений.
+- Если хотя бы один аргумент равен `NULL`, возвращает `NULL`.
+
+## Примечания по использованию {#usage-notes}
+1. Рекомендуется передавать аргументы одного типа. Если типы аргументов различаются, функция попытается привести их к одному типу. Правила преобразования см. в разделе [Преобразование типов](../../../basic-element/sql-data-types/conversion/overview.md).
+2. Если хотя бы один аргумент равен NULL, результатом будет NULL.
+
+## Примеры {#examples}
+1. Пример 1
+ ```sql
+ SELECT GREATEST(-1, 0, 5, 8);
+ ```
+ ```text
+ +-----------------------+
+ | GREATEST(-1, 0, 5, 8) |
+ +-----------------------+
+ | 8 |
+ +-----------------------+
+ ```
+2. Аргумент NULL
+ ```sql
+ SELECT GREATEST(-1, 0, 5, NULL);
+ ```
+ ```text
+ +--------------------------+
+ | GREATEST(-1, 0, 5, NULL) |
+ +--------------------------+
+ | NULL |
+ +--------------------------+
+ ```
+3. Преобразование типов
+ ```sql
+ SELECT GREATEST(6, 4.29, 7);
+ ```
+ ```text
+ +----------------------+
+ | GREATEST(6, 4.29, 7) |
+ +----------------------+
+ | 7.00 |
+ +----------------------+
+ ```
+ > Третий аргумент "7" преобразуется в тип Decimal.
+4. Тип даты
+ ```sql
+ SELECT GREATEST('2022-02-26 20:02:11', '2020-01-23 20:02:11', '2020-06-22 20:02:11');
+ ```
+ ```text
+ +-------------------------------------------------------------------------------+
+ | GREATEST('2022-02-26 20:02:11', '2020-01-23 20:02:11', '2020-06-22 20:02:11') |
+ +-------------------------------------------------------------------------------+
+ | 2022-02-26 20:02:11 |
+ +-------------------------------------------------------------------------------+
+ ```
diff --git a/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/conditional-functions/if.md b/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/conditional-functions/if.md
new file mode 100644
index 000000000000..5502d3d352a1
--- /dev/null
+++ b/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/conditional-functions/if.md
@@ -0,0 +1,72 @@
+---
+{
+ "title": "IF",
+ "language": "ru",
+ "description": "Если выражение <condition> истинно, возвращает <valuetrue>; в противном случае возвращает <valuefalseornull>."
+}
+---
+
+## Описание {#description}
+
+Если выражение `<condition>` истинно, возвращает `<value_true>`; в противном случае возвращает `<value_false_or_null>`.
+Тип возвращаемого значения: тип результата выражения `<value_true>`.
+
+## Синтаксис {#syntax}
+
+```sql
+IF(<condition>, <value_true>, <value_false_or_null>)
+```
+## Параметры {#parameters}
+- `<condition>`: Выражение типа Boolean, определяющее, истинно ли условие.
+- `<value_true>`: Значение, возвращаемое, когда `<condition>` истинно.
+- `<value_false_or_null>`: Значение, возвращаемое, когда `<condition>` ложно или равно NULL.
+
+## Примеры {#examples}
+0. Подготовка данных
+ ```sql
+ create table test_if(
+ user_id int
+ ) properties('replication_num' = '1');
+ insert into test_if values(1),(2),(null);
+ ```
+1. Пример 1
+ ```sql
+ SELECT user_id, IF(user_id = 1, "true", "false") AS test_if FROM test_if;
+ ```
+ ```text
+ +---------+---------+
+ | user_id | test_if |
+ +---------+---------+
+ | NULL | false |
+ | 1 | true |
+ | 2 | false |
+ +---------+---------+
+ ```
+2. Преобразование типов
+ ```sql
+ SELECT user_id, IF(user_id = 1, 2, 3.14) AS test_if FROM test_if;
+ ```
+ ```text
+ +---------+---------+
+ | user_id | test_if |
+ +---------+---------+
+ | NULL | 3.14 |
+ | 1 | 2.00 |
+ | 2 | 3.14 |
+ +---------+---------+
+ ```
+ > Второй аргумент "2" преобразуется к типу третьего аргумента "3.14" (Decimal).
+
+3. Аргумент NULL
+ ```sql
+ SELECT user_id, IF(user_id = 1, 2, NULL) AS test_if FROM test_if;
+ ```
+ ```text
+ +---------+---------+
+ | user_id | test_if |
+ +---------+---------+
+ | NULL | NULL |
+ | 1 | 2 |
+ | 2 | NULL |
+ +---------+---------+
+ ```
diff --git a/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/conditional-functions/ifnull.md b/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/conditional-functions/ifnull.md
new file mode 100644
index 000000000000..69c1e7c67515
--- /dev/null
+++ b/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/conditional-functions/ifnull.md
@@ -0,0 +1,64 @@
+---
+{
+ "title": "IFNULL",
+ "language": "ru",
+ "description": "Если значение <expr1> не равно NULL, возвращает <expr1>; в противном случае возвращает <expr2>."
+}
+---
+
+## Описание {#description}
+
+Если значение `<expr1>` не равно `NULL`, возвращает `<expr1>`; в противном случае возвращает `<expr2>`.
+
+## Псевдоним {#alias}
+
+- NVL
+
+## Синтаксис {#syntax}
+
+```sql
+IFNULL(<expr1>, <expr2>)
+```
+
+## Параметры {#parameters}
+- `<expr1>`: Выражение для проверки на `NULL`.
+- `<expr2>`: Значение, возвращаемое, если `<expr1>` равно `NULL`.
+
+## Возвращаемое значение {#return-value}
+- Если `<expr1>` не равно `NULL`, возвращает `<expr1>`.
+- В противном случае возвращает `<expr2>`.
+
+## Примеры {#examples}
+1. Пример 1
+ ```sql
+ SELECT IFNULL(1, 0);
+ ```
+ ```text
+ +--------------+
+ | IFNULL(1, 0) |
+ +--------------+
+ | 1 |
+ +--------------+
+ ```
+2. Пример 2
+ ```sql
+ SELECT IFNULL(NULL, 10);
+ ```
+ ```text
+ +------------------+
+ | IFNULL(NULL, 10) |
+ +------------------+
+ | 10 |
+ +------------------+
+ ```
+3. Оба аргумента равны NULL
+ ```sql
+ SELECT IFNULL(NULL, NULL);
+ ```
+ ```text
+ +--------------------+
+ | IFNULL(NULL, NULL) |
+ +--------------------+
+ | NULL |
+ +--------------------+
+ ```
diff --git a/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/conditional-functions/least.md b/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/conditional-functions/least.md
new file mode 100644
index 000000000000..55bc0b5d7196
--- /dev/null
+++ b/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/conditional-functions/least.md
@@ -0,0 +1,79 @@
+---
+{
+ "title": "LEAST",
+ "language": "ru",
+ "description": "Сравнивает несколько выражений и возвращает наименьшее из их значений. Если хотя бы один аргумент равен NULL, возвращает NULL."
+}
+---
+
+## Описание {#description}
+
+Сравнивает несколько выражений и возвращает наименьшее из их значений. Если хотя бы один аргумент равен `NULL`, возвращает `NULL`.
+
+## Синтаксис {#syntax}
+
+```sql
+LEAST(<expr> [, ...])
+```
+
+## Параметры {#parameters}
+### Обязательный параметр {#required-parameter}
+- `<expr>`: Поддерживает типы `TINYINT`, `SMALLINT`, `INT`, `BIGINT`, `LARGEINT`, `FLOAT`, `DOUBLE`, `STRING`, `DATETIME`, `TIMESTAMP_NS` и `DECIMAL`.
+### Необязательные параметры {#optional-parameters}
+- Поддерживается несколько аргументов.
+
+## Возвращаемое значение {#return-value}
+- Возвращает наименьшее из значений заданных выражений.
+- Если хотя бы один аргумент равен `NULL`, возвращает `NULL`.
+
+## Примечания по использованию {#usage-notes}
+1. Рекомендуется передавать аргументы одного типа. Если типы аргументов различаются, функция попытается привести их к одному типу. Правила преобразования см. в разделе: [Преобразование типов](../../../basic-element/sql-data-types/conversion/overview.md)
+2. Если хотя бы один аргумент равен NULL, результат будет NULL.
+
+
+## Примеры {#examples}
+1. Пример 1
+ ```sql
+ SELECT LEAST(-1, 0, 5, 8);
+ ```
+ ```text
+ +--------------------+
+ | LEAST(-1, 0, 5, 8) |
+ +--------------------+
+ | -1 |
+ +--------------------+
+ ```
+2. Аргумент NULL
+ ```sql
+ SELECT LEAST(-1, 0, 5, NULL);
+ ```
+ ```text
+ +-----------------------+
+ | LEAST(-1, 0, 5, NULL) |
+ +-----------------------+
+ | NULL |
+ +-----------------------+
+ ```
+3. Преобразование типов
+ ```sql
+ SELECT LEAST(6, 9.29, 7);
+ ```
+ ```text
+ +-------------------+
+ | LEAST(6, 9.29, 7) |
+ +-------------------+
+ | 6.00 |
+ +-------------------+
+ ```
+ > Первый аргумент "6" преобразуется в тип Decimal.
+4. Тип даты
+ ```sql
+ SELECT LEAST('2022-02-26 20:02:11', '2020-01-23 20:02:11', '2020-06-22 20:02:11');
+ ```
+ ```text
+ +----------------------------------------------------------------------------+
+ | LEAST('2022-02-26 20:02:11', '2020-01-23 20:02:11', '2020-06-22 20:02:11') |
+ +----------------------------------------------------------------------------+
+ | 2020-01-23 20:02:11 |
+ +----------------------------------------------------------------------------+
+ ```
diff --git a/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/conditional-functions/not-null-or-empty.md b/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/conditional-functions/not-null-or-empty.md
new file mode 100644
index 000000000000..7eb838e1b56a
--- /dev/null
+++ b/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/conditional-functions/not-null-or-empty.md
@@ -0,0 +1,36 @@
+---
+{
+ "title": "NOT_NULL_OR_EMPTY",
+ "language": "ru",
+ "description": "Функция notnullorempty проверяет, что заданное значение не равно NULL и не является пустым. Если входное значение не равно NULL и не является пустым,"
+}
+---
+
+## Описание {#description}
+
+Функция `not_null_or_empty` проверяет, что заданное значение не равно NULL и не является пустым. Если входное значение не равно NULL и не является пустым, функция возвращает true; в противном случае возвращает false.
+
+## Синтаксис {#syntax}
+
+```sql
+NOT_NULL_OR_EMPTY (<str>)
+```
+
+## Параметры {#parameters}
+- `<str>`: Строковый тип, строка для проверки на NULL или пустое значение.
+
+## Возвращаемое значение {#return-value}
+Возвращает false, если строка пустая или равна NULL; в противном случае возвращает true.
+
+## Примеры {#examples}
+1. Пример 1
+ ```sql
+ select not_null_or_empty(null), not_null_or_empty(""), not_null_or_empty(" ");
+ ```
+ ```text
+ +-------------------------+-----------------------+------------------------+
+ | not_null_or_empty(null) | not_null_or_empty("") | not_null_or_empty(" ") |
+ +-------------------------+-----------------------+------------------------+
+ | 0 | 0 | 1 |
+ +-------------------------+-----------------------+------------------------+
+ ```
diff --git a/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/conditional-functions/null-or-empty.md b/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/conditional-functions/null-or-empty.md
new file mode 100644
index 000000000000..1d93c8ee5a18
--- /dev/null
+++ b/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/conditional-functions/null-or-empty.md
@@ -0,0 +1,36 @@
+---
+{
+ "title": "NULL_OR_EMPTY",
+ "language": "ru",
+ "description": "Функция nullorempty проверяет, является ли заданное значение NULL или пустым. Если входное значение NULL или пустое,"
+}
+---
+
+## Описание {#description}
+
+Функция `null_or_empty` проверяет, является ли заданное значение NULL или пустым. Если входное значение NULL или пустое, функция возвращает true; в противном случае возвращает false.
+
+## Синтаксис {#syntax}
+
+```sql
+NULL_OR_EMPTY (<str>)
+```
+
+## Параметры {#parameters}
+- `<str>`: Тип String; строка, которую нужно проверить на NULL или пустоту.
+
+## Возвращаемое значение {#return-value}
+Возвращает true, если строка пустая или равна NULL; в противном случае возвращает false.
+
+## Примеры {#examples}
+1. Пример 1
+ ```sql
+ select null_or_empty(null), null_or_empty(""), null_or_empty(" ");
+ ```
+ ```text
+ +---------------------+-------------------+--------------------+
+ | null_or_empty(null) | null_or_empty("") | null_or_empty(" ") |
+ +---------------------+-------------------+--------------------+
+ | 1 | 1 | 0 |
+ +---------------------+-------------------+--------------------+
+ ```
diff --git a/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/conditional-functions/nullif.md b/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/conditional-functions/nullif.md
new file mode 100644
index 000000000000..f829554add60
--- /dev/null
+++ b/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/conditional-functions/nullif.md
@@ -0,0 +1,63 @@
+---
+{
+ "title": "NULLIF",
+ "language": "ru",
+ "description": "Если два входных значения равны, возвращает NULL; в противном случае возвращает первое входное значение."
+}
+---
+
+## Описание {#description}
+
+Если два входных значения равны, возвращает `NULL`; в противном случае возвращает первое входное значение. Эта функция эквивалентна следующему выражению `CASE WHEN`:
+
+```sql
+CASE
+ WHEN <expr1> = <expr2> THEN NULL
+ ELSE <expr1>
+END
+```
+
+## Синтаксис {#syntax}
+
+```sql
+NULLIF(<expr1>, <expr2>)
+```
+
+## Параметры {#parameters}
+- `<expr1>`: Первое входное значение для сравнения. Поддерживаемые типы перечислены ниже в разделе «Примечания по использованию».
+- `<expr2>`: Второе значение для сравнения с первым входным значением. Поддерживаемые типы перечислены ниже в разделе «Примечания по использованию».
+
+## Примечания по использованию {#usage-notes}
+Поддерживаемые типы параметров:
+1. Boolean
+2. Числовые типы (TinyInt, SmallInt, Int, BigInt, LargeInt, Float, Double, Decimal)
+3. Типы даты и времени (Date, DateTime, TimestampNs, Time)
+4. Строковые типы (String, VARCHAR, CHAR)
+
+## Возвращаемое значение {#return-value}
+- Если `<expr1>` равно `<expr2>`, возвращает `NULL`.
+- В противном случае возвращает значение `<expr1>`.
+
+## Примеры {#examples}
+1. Пример 1
+ ```sql
+ SELECT NULLIF(1, 1);
+ ```
+ ```text
+ +--------------+
+ | NULLIF(1, 1) |
+ +--------------+
+ | NULL |
+ +--------------+
+ ```
+2. Пример 2
+ ```sql
+ SELECT NULLIF(1, 0);
+ ```
+ ```text
+ +--------------+
+ | NULLIF(1, 0) |
+ +--------------+
+ | 1 |
+ +--------------+
+ ```
diff --git a/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/conditional-functions/overview.md b/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/conditional-functions/overview.md
new file mode 100644
index 000000000000..b42adce4ba8e
--- /dev/null
+++ b/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/conditional-functions/overview.md
@@ -0,0 +1,90 @@
+---
+{
+ "title": "Обзор условных функций",
+ "language": "ru",
+ "description": "Условные функции — это встроенные функции для реализации условной логики и ветвления в SQL-запросах."
+}
+---
+
+# Обзор условных функций {#conditional-functions-overview}
+
+Условные функции — это встроенные функции для реализации условной логики и ветвления в SQL-запросах. Они позволяют выполнять различные операции в зависимости от заданных условий, например выбирать значения, обрабатывать значения NULL и реализовывать логику выбора по нескольким условиям.
+
+## Векторизованное выполнение и условные функции {#vectorized-execution-and-conditional-functions}
+
+Doris — это движок с векторизованным выполнением. Однако поведение условных функций может показаться неожиданным.
+
+Рассмотрим следующий пример:
+
+```sql
+mysql> set enable_strict_cast = true;
+Query OK, 0 rows affected (0.00 sec)
+
+mysql> select count(
+ -> if(number < 128 ,
+ -> cast(number as tinyint),
+ -> cast(number as String))
+ -> ) from numbers("number" = "300");
+ERROR 1105 (HY000): errCode = 2, detailMessage = (127.0.0.1)[INVALID_ARGUMENT]Value 128 out of range for type tinyint
+```
+
+В этом примере ошибка возникает, хотя приведение к `tinyint` в функции `number < 128` выполняется только при выполнении условия `if`.
+
+Это связано с тем, как традиционно выполнялись условные функции, такие как `if(cond, colA, colB)`:
+
+1. Сначала полностью вычисляются оба выражения: `colA` и `colB`
+2. Затем на основе значения `cond` выбирается и возвращается соответствующий результат
+
+Поэтому, даже если значение `colA` на практике не используется, полное вычисление `colA` всё равно приведёт к ошибке.
+
+Функции `if`, `ifnull`, `case` и `coalesce` ведут себя аналогичным образом.
+
+Обратите внимание, что у таких функций, как `LEAST`, этой проблемы нет, поскольку для сравнения значений им в любом случае необходимо вычислить все параметры.
+
+## Вычисление по короткой схеме {#short-circuit-evaluation}
+
+В Doris 4.0.4 мы улучшили логику выполнения условных функций, добавив поддержку вычисления по короткой схеме.
+
+```sql
+mysql> set short_circuit_evaluation = true;
+Query OK, 0 rows affected (0.00 sec)
+
+mysql> select count(
+ -> if(number < 128 ,
+ -> cast(number as tinyint),
+ -> cast(number as String))
+ -> ) from numbers("number" = "300");
++--------------------------------------------------------------------------+
+| count(if(number < 128, cast(number as tinyint), cast(number as String))) |
++--------------------------------------------------------------------------+
+| 300 |
++--------------------------------------------------------------------------+
+```
+
+При включённом вычислении по короткой схеме такие функции, как `if`, `ifnull`, `case` и `coalesce`, во многих случаях позволяют избежать ненужных вычислений, предотвращая ошибки и повышая производительность.
+
+### Включение вычисления по короткой схеме {#enabling-short-circuit-evaluation}
+
+Чтобы включить вычисление по короткой схеме, задайте переменную сеанса:
+
+```sql
+SET short_circuit_evaluation = true;
+```
+
+### Преимущества вычисления по короткой схеме {#benefits-of-short-circuit-evaluation}
+
+1. **Предотвращение ошибок**: ветви, которые могли бы вызвать ошибки, не выполняются, если условия исключают их выполнение
+2. **Повышение производительности**: вычисляются только действительно необходимые ветви, что сокращает объём ненужных вычислений
+3. **Более интуитивное поведение**: поведение условных функций становится ближе к поведению условных конструкций в традиционных языках программирования
+
+## Распространённые условные функции {#common-conditional-functions}
+
+К распространённым условным функциям, для которых полезно вычисление по короткой схеме, относятся:
+
+- `IF`: возвращает одно из двух значений в зависимости от условия
+- `IFNULL`: возвращает первый аргумент, если он не равен NULL, иначе возвращает второй аргумент
+- `CASE`: предоставляет несколько условных ветвей, аналогично конструкциям switch-case
+- `COALESCE`: возвращает первое значение из списка аргументов, отличное от NULL
+- `NULLIF`: возвращает NULL, если два аргумента равны, иначе возвращает первый аргумент
+
+Подробные сведения о каждой функции приведены на соответствующих страницах документации.
diff --git a/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/date-time-functions/add-time.md b/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/date-time-functions/add-time.md
new file mode 100644
index 000000000000..e6e9a80ab1dd
--- /dev/null
+++ b/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/date-time-functions/add-time.md
@@ -0,0 +1,112 @@
+---
+{
+ "title": "ADD_TIME",
+ "language": "ru",
+ "description": "Добавляет указанный временной интервал к выражению даты и времени или выражению времени. Если второй параметр отрицательный,"
+}
+---
+
+## Описание {#description}
+
+Добавляет указанный временной интервал к выражению даты и времени или выражению времени. Если второй параметр отрицательный, это эквивалентно вычитанию интервала из первого параметра.
+
+## Синтаксис {#syntax}
+
+```sql
+ADD_TIME(`<date_or_time_expr>`, `<time>`)
+```
+
+## Параметры {#parameters}
+
+| Параметр | Описание |
+| ---------------------| ----------- |
+| `<date_or_time_expr>`| Допустимое выражение даты. Поддерживаются входные значения типов TIMESTAMPTZ/TIMESTAMP_NS/DATETIME/DATE/TIME. Значение типа date преобразуется во время начала дня (00:00:00). Подробные сведения о форматах см. в разделах [Преобразование timestamptz](../../../../sql-manual/basic-element/sql-data-types/conversion/timestamptz-conversion), [Преобразование datetime](../../../../sql-manual/basic-element/sql-data-types/conversion/datetime-conversion) и [Преобразование ti [...]
+| `<time>` | Допустимое выражение времени, представляющее значение времени, которое нужно прибавить к `<date_or_time_expr>`. Отрицательное значение означает вычитание. Поддерживаются входные значения типа time. |
+
+## Возвращаемое значение {#return-value}
+
+Для входного значения типа `TIMESTAMP_NS` возвращается значение типа `TIMESTAMP_NS` с фиксированной точностью дробной части секунды до девяти знаков. Результаты проверяются на соответствие диапазону возвращаемого типа; для `TIMESTAMP_NS` используется диапазон `[1677-09-21 00:12:43.145224192, 2262-04-11 23:47:16.854775807]`.
+
+Возвращает результат прибавления `<time>` к `<date_or_time_expr>`. Тип возвращаемого значения зависит от типа первого параметра:
+
+- Если первый параметр имеет тип timestamptz, возвращается значение типа timestamptz.
+- Если первый параметр имеет тип datetime, возвращается значение типа datetime.
+- Если первый параметр имеет тип time, возвращается значение типа time.
+
+Особые случаи:
+
+- Если какой-либо входной параметр равен NULL, возвращается NULL.
+- Если первый параметр имеет тип time и результат выходит за пределы диапазона типа time, возвращается максимальное (или минимальное) значение времени.
+- Если первый параметр имеет тип datetime или timestamptz и результат выходит за пределы диапазона типа datetime, возникает ошибка.
+
+## Примеры {#examples}
+
+```sql
+-- Add time when the first parameter is datetime type
+SELECT ADD_TIME('2025-09-19 12:00:00', '01:30:00');
++---------------------------------------------+
+| ADD_TIME('2025-09-19 12:00:00', '01:30:00') |
++---------------------------------------------+
+| 2025-09-19 13:30:00 |
++---------------------------------------------+
+
+-- Add time when the first parameter is time type
+SELECT ADD_TIME(cast('12:15:20' as time), '00:10:40');
++------------------------------------------------+
+| ADD_TIME(cast('12:15:20' as time), '00:10:40') |
++------------------------------------------------+
+| 12:26:00 |
++------------------------------------------------+
+
+-- SET time_zone = '+08:00';
+SELECT ADD_TIME('2025-10-10 11:22:33.1234567+03:00', '01:02:03');
++-----------------------------------------------------------+
+| ADD_TIME('2025-10-10 11:22:33.1234567+03:00', '01:02:03') |
++-----------------------------------------------------------+
+| 2025-10-10 17:24:36.123457+08:00 |
++-----------------------------------------------------------+
+
+-- NULL parameter test
+SELECT ADD_TIME(NULL, '01:00:00');
++----------------------------+
+| ADD_TIME(NULL, '01:00:00') |
++----------------------------+
+| NULL |
++----------------------------+
+
+SELECT ADD_TIME('2025-09-19 12:00:00', NULL);
++---------------------------------------+
+| ADD_TIME('2025-09-19 12:00:00', NULL) |
++---------------------------------------+
+| NULL |
++---------------------------------------+
+
+SELECT ADD_TIME(NULL, NULL);
++----------------------+
+| ADD_TIME(NULL, NULL) |
++----------------------+
+| NULL |
++----------------------+
+
+-- Time type out-of-range test (returns max/min value)
+SELECT ADD_TIME(cast('835:30:00' as time), '21:00:00');
++-------------------------------------------------+
+| ADD_TIME(cast('835:30:00' as time), '21:00:00') |
++-------------------------------------------------+
+| 838:59:59 |
++-------------------------------------------------+
+
+SELECT ADD_TIME(cast('-832:30:00' as time), '-31:00:00');
++---------------------------------------------------+
+| ADD_TIME(cast('-832:30:00' as time), '-31:00:00') |
++---------------------------------------------------+
+| -838:59:59 |
++---------------------------------------------------+
+
+-- Datetime type out-of-range test (throws error)
+SELECT ADD_TIME('9999-12-31 23:59:59', '00:00:01');
+ERROR 1105 (HY000): errCode = 2, detailMessage = (10.16.10.3)[INVALID_ARGUMENT]datetime value is out of range in function add_time
+
+SELECT ADD_TIME('0000-01-01 00:00:00', '-00:00:01');
+ERROR 1105 (HY000): errCode = 2, detailMessage = (10.16.10.3)[INVALID_ARGUMENT]datetime value is out of range in function add_time
+```
diff --git a/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/date-time-functions/century.md b/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/date-time-functions/century.md
new file mode 100644
index 000000000000..890bf63246db
--- /dev/null
+++ b/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/date-time-functions/century.md
@@ -0,0 +1,61 @@
+---
+{
+ "title": "CENTURY",
+ "language": "ru",
+ "description": "Возвращает век, к которому относится указанная дата. Если входное значение некорректно или выходит за пределы поддерживаемого диапазона, возвращает NULL."
+}
+---
+
+## Описание {#description}
+Возвращает век, к которому относится указанная дата.
+Если входное значение некорректно или выходит за пределы поддерживаемого диапазона, возвращает NULL.
+
+## Синтаксис {#syntax}
+```sql
+CENTURY(`<date_or_time_expr>`)
+```
+
+## Параметры {#parameters}
+| Параметр | Описание |
+| ------------- | ------------------------------------------------------------- |
+| `<date_or_time_expr>` | Выражение типа `DATE`, `DATETIME` или `TIMESTAMP_NS`. |
+
+## Возвращаемое значение {#return-value}
+Возвращает целое число (INT), обозначающее век, к которому относится входная дата. Например, годы с 1901 по 2000 относятся к 20-му веку. Возвращает NULL, если входное значение равно NULL или содержит некорректную дату.
+
+## Примеры {#examples}
+```sql
+-- Extract the century from a DATE type
+SELECT CENTURY('2024-01-01') AS century_date;
++-----------------+
+| century_date |
++-----------------+
+| 21 |
++-----------------+
+
+-- Extract the century from a DATETIME type (ignoring hours, minutes, and seconds)
+SELECT CENTURY('2024-05-20 14:30:25') AS century_datetime;
++----------------------+
+| century_datetime |
++----------------------+
+| 21 |
++----------------------+
+
+-- Input is NULL (returns NULL)
+SELECT CENTURY(NULL) AS null_input;
++----------------+
+| null_input |
++----------------+
+| NULL |
++----------------+
+
+-- Invalid date input (returns NULL)
+SELECT CENTURY('10000-01-01') AS invalid_date;
++-------------------+
+| invalid_date |
++-------------------+
+| NULL |
++-------------------+
+
+
+```
diff --git a/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/date-time-functions/convert-tz.md b/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/date-time-functions/convert-tz.md
new file mode 100644
index 000000000000..618f6dec8c7d
--- /dev/null
+++ b/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/date-time-functions/convert-tz.md
@@ -0,0 +1,106 @@
+---
+{
+ "title": "CONVERT_TZ",
+ "language": "ru",
+ "description": "Преобразует значение даты и времени из указанного часового пояса fromtz в указанный часовой пояс totz и возвращает результат. Для настройки часовых поясов,"
+}
+---
+
+## Описание {#description}
+
+Преобразует значение даты и времени из указанного часового пояса from_tz в указанный часовой пояс to_tz и возвращает результат. Сведения о настройках часовых поясов см. в документации [Управление часовыми поясами](../../../../admin-manual/cluster-management/time-zone).
+
+Эта функция соответствует [функции convert_tz](https://dev.mysql.com/doc/refman/8.4/en/date-and-time-functions.html#function_convert_tz) в MySQL.
+
+## Синтаксис {#syntax}
+
+```sql
+CONVERT_TZ(<dt>, <from_tz>, <to_tz>)
+```
+
+## Параметры {#parameters}
+
+| Параметр | Описание |
+| -- | -- |
+| `<dt>` | Значение для преобразования. Поддерживаются `DATE`, `DATETIME` и `TIMESTAMP_NS`. |
+| `<from_tz>` | Исходный часовой пояс значения dt. Этот параметр имеет тип `varchar` |
+| `<to_tz>` | Целевой часовой пояс для преобразования. Этот параметр имеет тип `varchar` |
+
+## Возвращаемое значение {#return-value}
+
+При входном значении типа `TIMESTAMP_NS` возвращается значение типа `TIMESTAMP_NS` с фиксированной точностью дробной части секунды до девяти знаков. Результаты проверяются на соответствие диапазону возвращаемого типа; для `TIMESTAMP_NS` используется диапазон `[1677-09-21 00:12:43.145224192, 2262-04-11 23:47:16.854775807]`.
+
+- Преобразованное значение типа datetime
+- Число знаков дробной части результата совпадает с числом знаков дробной части входного значения
+ - Если входное значение datetime не содержит дробной части, результат также не содержит дробной части
+ - Если входное значение содержит дробную часть, результат имеет то же число знаков дробной части
+
+Особые случаи:
+- Если какой-либо параметр равен NULL, возвращается NULL.
+- Если указан недопустимый часовой пояс, возвращается ошибка. Сведения о настройках часовых поясов см. в разделе [Управление часовыми поясами](../../../../admin-manual/cluster-management/time-zone).
+- Для входного значения типа date время автоматически устанавливается в 00:00:00
+
+## Примеры {#examples}
+
+
+```sql
+-- Convert time from Shanghai, China to Los Angeles, USA
+mysql> select CONVERT_TZ(CAST('2019-08-01 13:21:03' AS DATETIME), 'Asia/Shanghai', 'America/Los_Angeles');
++---------------------------------------------------------------------------+
+| CONVERT_TZ('2019-08-01 13:21:03', 'Asia/Shanghai', 'America/Los_Angeles') |
++---------------------------------------------------------------------------+
+| 2019-07-31 22:21:03 |
++---------------------------------------------------------------------------+
+
+-- Convert the time '2019-08-01 13:21:03' in UTC+8 (+08:00) to Los Angeles, USA
+mysql> select CONVERT_TZ(CAST('2019-08-01 13:21:03' AS DATETIME), '+08:00', 'America/Los_Angeles');
+
++--------------------------------------------------------------------+
+| convert_tz('2019-08-01 13:21:03', '+08:00', 'America/Los_Angeles') |
++--------------------------------------------------------------------+
+| 2019-07-31 22:21:03 |
++--------------------------------------------------------------------+
+
+-- For date type input,return datetime type value, the time part is automatically converted to 00:00:00
+mysql> select CONVERT_TZ(CAST('2019-08-01 13:21:03' AS DATE), 'Asia/Shanghai', 'America/Los_Angeles');
++-------------------------------------------------------------------------------------------+
+| CONVERT_TZ(CAST('2019-08-01 13:21:03' AS DATE), 'Asia/Shanghai', 'America/Los_Angeles') |
++-------------------------------------------------------------------------------------------+
+| 2019-07-31 09:00:00 |
++-------------------------------------------------------------------------------------------+
+
+-- When conversion time is NULL, output NULL
+mysql> select CONVERT_TZ(NULL, 'Asia/Shanghai', 'America/New_York');
++-------------------------------------------------------+
+| CONVERT_TZ(NULL, 'Asia/Shanghai', 'America/New_York') |
++-------------------------------------------------------+
+| NULL |
++-------------------------------------------------------+
+
+-- When any time zone is NULL, return NULL
+mysql> select CONVERT_TZ('2019-08-01 13:21:03', NULL, 'America/Los_Angeles');
++----------------------------------------------------------------+
+| CONVERT_TZ('2019-08-01 13:21:03', NULL, 'America/Los_Angeles') |
++----------------------------------------------------------------+
+| NULL |
++----------------------------------------------------------------+
+
+mysql> select CONVERT_TZ('2019-08-01 13:21:03', '+08:00', NULL);
++---------------------------------------------------+
+| CONVERT_TZ('2019-08-01 13:21:03', '+08:00', NULL) |
++---------------------------------------------------+
+| NULL |
++---------------------------------------------------+
+
+-- Time with scale
+mysql> select CONVERT_TZ('2019-08-01 13:21:03.636', '+08:00', 'America/Los_Angeles');
++------------------------------------------------------------------------+
+| CONVERT_TZ('2019-08-01 13:21:03.636', '+08:00', 'America/Los_Angeles') |
++------------------------------------------------------------------------+
+| 2019-07-31 22:21:03.636 |
++------------------------------------------------------------------------+
+
+-- When the input time zone is invalid, an error is returned.
+select CONVERT_TZ(CAST('2019-08-01 13:21:03' AS DATETIME), '+08:00', 'America/Los_Anges');
+ERROR 1105 (HY000): errCode = 2, detailMessage = (10.16.10.3)[INVALID_ARGUMENT][E33] Operation convert_tz invalid timezone: America/Los_Anges
+```
diff --git a/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/date-time-functions/curdate.md b/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/date-time-functions/curdate.md
new file mode 100644
index 000000000000..d40dee9df942
--- /dev/null
+++ b/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/date-time-functions/curdate.md
@@ -0,0 +1,40 @@
+---
+{
+ "title": "CURDATE,CURRENT_DATE",
+ "language": "ru",
+ "description": "Возвращает текущую дату в виде значения типа DATE."
+}
+---
+
+## Описание {#description}
+
+Возвращает текущую дату в виде значения типа DATE.
+
+Эта функция соответствует [функции curdate](https://dev.mysql.com/doc/refman/8.4/en/date-and-time-functions.html#function_curdate) в MySQL.
+
+## Псевдонимы {#aliases}
+
+- current_date
+
+## Синтаксис {#syntax}
+
+```sql
+CURDATE()
+```
+
+## Возвращаемое значение {#return-value}
+
+Текущая дата. Возвращаемое значение имеет тип DATE.
+
+## Примеры {#examples}
+
+```sql
+-- Get the current date
+SELECT CURDATE();
+
++------------+
+| CURDATE() |
++------------+
+| 2019-12-20 |
++------------+
+```
diff --git a/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/date-time-functions/curtime.md b/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/date-time-functions/curtime.md
new file mode 100644
index 000000000000..a2fdc9697b7c
--- /dev/null
+++ b/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/date-time-functions/curtime.md
@@ -0,0 +1,68 @@
+---
+{
+ "title": "CURTIME,CURRENT_TIME",
+ "language": "ru",
+ "description": "Получает текущее время и возвращает его в виде значения типа TIME."
+}
+---
+
+## Описание {#description}
+
+Получает текущее время и возвращает его в виде значения типа TIME.
+
+Поведение этой функции соответствует [функции curtime](https://dev.mysql.com/doc/refman/8.4/en/date-and-time-functions.html#function_curtime) в MySQL.
+
+## Псевдонимы {#aliases}
+
+- CURRENT_TIME
+
+## Синтаксис {#syntax}
+
+```sql
+CURTIME([<precision>])
+```
+
+## Параметры {#parameters}
+
+| Параметр | Описание |
+|---------------|----------------------------------------------------------------------------------------------------------------------------------------------|
+| `<precision>` | Необязательный параметр, задающий точность дробной части секунд возвращаемого значения. Должен быть константой в диапазоне от 0 до 6. Значение по умолчанию равно 0, что означает отсутствие дробной части секунд. |
+
+## Возвращаемое значение {#return-value}
+
+Возвращает текущее время в виде значения типа TIME.
+
+## Примеры {#examples}
+
+```sql
+mysql> select curtime();
+
++----------------+
+| curtime() |
++----------------+
+| 15:25:47 |
++----------------+
+```
+
+```sql
+mysql> select curtime(0);
++------------+
+| curtime(0) |
++------------+
+| 13:15:27 |
++------------+
+```
+
+```sql
+mysql> select curtime(4);
++---------------+
+| curtime(4) |
++---------------+
+| 15:31:03.8958 |
++---------------+
+```
+
+```sql
+mysql> select curtime(7);
+ERROR 1105 (HY000): errCode = 2, detailMessage = The precision must be between 0 and 6
+```
diff --git a/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/date-time-functions/date-add.md b/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/date-time-functions/date-add.md
new file mode 100644
index 000000000000..4680a2224414
--- /dev/null
+++ b/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/date-time-functions/date-add.md
@@ -0,0 +1,224 @@
+---
+{
+ "title": "DATE_ADD",
+ "language": "ru",
+ "description": "Функция DATEADD добавляет заданный временной интервал к указанному значению даты или времени и возвращает результат вычисления."
+}
+---
+
+## Описание {#description}
+
+Функция DATE_ADD добавляет заданный временной интервал к указанному значению даты или времени и возвращает результат вычисления.
+
+- Поддерживаемые типы входных значений даты: DATE, DATETIME, TIMESTAMP_NS, TIMESTAMPTZ (например, '2023-12-31', '2023-12-31 23:59:59', '2023-12-31 23:59:59+08:00').
+- Временной интервал задаётся числовым значением (`expr`) и единицей измерения (`time_unit`). Положительное значение `expr` означает прибавление, а отрицательное эквивалентно вычитанию соответствующего интервала.
+
+Поведение этой функции соответствует поведению [функции date_add](https://dev.mysql.com/doc/refman/8.4/en/date-and-time-functions.html#function_date-add) в MySQL.
+
+## Псевдонимы {#aliases}
+
+- days_add
+- adddate
+
+## Синтаксис {#syntax}
+
+```sql
+DATE_ADD(<date_or_time_expr>, INTERVAL <expr> <time_unit>)
+```
+
+## Параметры {#parameters}
+
+| Параметр | Описание |
+| -- | -- |
+| `<date_or_time_expr>` | Обрабатываемое значение даты/времени. Поддерживаются `DATE`, `DATETIME`, `TIMESTAMP_NS` и `TIMESTAMPTZ`. |
+| `<expr>` | Добавляемый временной интервал. Для простых единиц (например, `YEAR`) используется тип `INT`; для составных единиц (например, `YEAR_MONTH`) используется тип `STRING`, и в качестве разделителей допускаются любые нецифровые символы. Поэтому, например, `INTERVAL 6/4 HOUR_MINUTE` распознаётся Doris как 6 часов 4 минуты, а не как 1 час 30 минут (6/4 == 1.5). Для составных единиц, если во входном значении интервала недостаточно компонентов, значение более крупной единицы устанавли [...]
+| `<time_unit>` | Значения перечисления: YEAR, QUARTER, MONTH, WEEK, DAY, HOUR, MINUTE, SECOND, YEAR_MONTH, DAY_HOUR, DAY_MINUTE, DAY_SECOND, DAY_MICROSECOND, HOUR_MINUTE, HOUR_SECOND, HOUR_MICROSECOND, MINUTE_SECOND, MINUTE_MICROSECOND, SECOND_MICROSECOND |
+
+| time_unit | Ожидаемый формат (в качестве разделителей допускаются любые нецифровые символы) |
+| ------------------ | ----------------------------------------- |
+| YEAR | 'YEARS' |
+| QUARTER | 'QUARTERS' |
+| MONTH | 'MONTHS' |
+| WEEK | 'WEEKS' |
+| DAY | 'DAYS' |
+| HOUR | 'HOURS' |
+| MINUTE | 'MINUTES' |
+| SECOND | 'SECONDS' |
+| MICROSECOND | 'MICROSECONDS' |
+| YEAR_MONTH | 'YEARS-MONTHS' |
+| DAY_HOUR | 'DAYS HOURS' |
+| DAY_MINUTE | 'DAYS HOURS:MINUTES' |
+| DAY_SECOND | 'DAYS HOURS:MINUTES:SECONDS' |
+| DAY_MICROSECOND | 'DAYS HOURS:MINUTES:SECONDS.MICROSECONDS' |
+| HOUR_MINUTE | 'HOURS:MINUTES' |
+| HOUR_SECOND | 'HOURS:MINUTES:SECONDS' |
+| HOUR_MICROSECOND | 'HOURS:MINUTES:SECONDS.MICROSECONDS' |
+| MINUTE_SECOND | 'MINUTES:SECONDS' |
+| MINUTE_MICROSECOND | 'MINUTES:SECONDS.MICROSECONDS' |
+| SECOND_MICROSECOND | 'SECONDS.MICROSECONDS' |
+
+## Возвращаемое значение {#return-value}
+
+При входном значении типа `TIMESTAMP_NS` возвращается `TIMESTAMP_NS` с фиксированной точностью в девять знаков дробной части секунды. Результат проверяется на соответствие диапазону возвращаемого типа; для `TIMESTAMP_NS` используется диапазон `[1677-09-21 00:12:43.145224192, 2262-04-11 23:47:16.854775807]`.
+
+Возвращается результат того же типа, что и <date_or_time_expr>:
+- При входном значении типа DATE возвращается DATE (только дата);
+- При входном значении типа DATETIME возвращается DATETIME (дата и время);
+- При входном значении типа TIMESTAMPTZ возвращается TIMESTAMPTZ (дата, время и смещение часового пояса).
+- Количество знаков дробной части входного значения сохраняется: `DATETIME` и `TIMESTAMPTZ` поддерживают до шести знаков дробной части секунды, а `TIMESTAMP_NS` имеет фиксированную точность в девять знаков.
+
+Особые случаи:
+- Если любой из параметров равен NULL, возвращается NULL;
+- Если указана недопустимая единица измерения или нечисловое значение expr, возвращается ошибка;
+- Для составных единиц, если во входном значении слишком много компонентов или значение любого компонента превышает допустимый максимум 922337203685477579, возвращается ошибка.
+- Если результат вычисления выходит за пределы диапазона типа даты (например, раньше '0000-00-00 23:59:59' или позже '9999-12-31 23:59:59'), возвращается ошибка.
+- Если в следующем месяце нет дня, соответствующего дню входной даты, автоматически выбирается последний день следующего месяца.
+
+## Примеры {#examples}
+
+```sql
+-- Add days
+select date_add(cast('2010-11-30 23:59:59' as datetime), INTERVAL 2 DAY);
+
++-------------------------------------------------+
+| date_add('2010-11-30 23:59:59', INTERVAL 2 DAY) |
++-------------------------------------------------+
+| 2010-12-02 23:59:59 |
++-------------------------------------------------+
+
+-- Add quarters
+mysql> select DATE_ADD(cast('2023-01-01' as date), INTERVAL 1 QUARTER);
++--------------------------------------------+
+| DATE_ADD('2023-01-01', INTERVAL 1 QUARTER) |
++--------------------------------------------+
+| 2023-04-01 |
++--------------------------------------------+
+
+-- Add weeks
+mysql> select DATE_ADD('2023-01-01', INTERVAL 1 WEEK);
++-----------------------------------------+
+| DATE_ADD('2023-01-01', INTERVAL 1 WEEK) |
++-----------------------------------------+
+| 2023-01-08 |
++-----------------------------------------+
+
+-- Add months, since February 2023 only has 28 days, January 31 plus one month returns February 28
+mysql> select DATE_ADD('2023-01-31', INTERVAL 1 MONTH);
++------------------------------------------+
+| DATE_ADD('2023-01-31', INTERVAL 1 MONTH) |
++------------------------------------------+
+| 2023-02-28 |
++------------------------------------------+
+
+-- Negative number test
+mysql> select DATE_ADD('2019-01-01', INTERVAL -3 DAY);
++-----------------------------------------+
+| DATE_ADD('2019-01-01', INTERVAL -3 DAY) |
++-----------------------------------------+
+| 2018-12-29 |
++-----------------------------------------+
+
+-- Cross-year hour addition
+mysql> select DATE_ADD('2023-12-31 23:00:00', INTERVAL 2 HOUR);
++--------------------------------------------------+
+| DATE_ADD('2023-12-31 23:00:00', INTERVAL 2 HOUR) |
++--------------------------------------------------+
+| 2024-01-01 01:00:00 |
++--------------------------------------------------+
+
+-- Add DAY_SECOND
+mysql> select DATE_ADD('2025-10-23 10:10:10', INTERVAL '1 1:2:3' DAY_SECOND);
++-------------------------------------------------------------------+
+| DATE_ADD('2025-10-23 10:10:10', INTERVAL '1 1:2:3' DAY_SECOND) |
++-------------------------------------------------------------------+
+| 2025-10-24 11:12:13 |
++-------------------------------------------------------------------+
+
+-- Add DAY_HOUR
+mysql> select DATE_ADD('2025-10-23 10:10:10', INTERVAL '1 2' DAY_HOUR);
++----------------------------------------------------------+
+| DATE_ADD('2025-10-23 10:10:10', INTERVAL '1 2' DAY_HOUR) |
++----------------------------------------------------------+
+| 2025-10-24 12:10:10 |
++----------------------------------------------------------+
+
+-- For compound units, accept all non-numeric characters as separators.
+select DATE_ADD('2025-10-23 10:10:10', INTERVAL ' *1@#$2' DAY_HOUR);
++----------------------------------------------------------------+
+| DATE_ADD('2025-10-23 10:10:10', INTERVAL ' *1@#$2' DAY_HOUR) |
++----------------------------------------------------------------+
+| 2025-10-24 12:10:10 |
++----------------------------------------------------------------+
+
+-- Add MINUTE_SECOND
+mysql> select DATE_ADD('2025-10-23 10:10:10', INTERVAL '1:1' MINUTE_SECOND);
++---------------------------------------------------------------+
+| DATE_ADD('2025-10-23 10:10:10', INTERVAL '1:1' MINUTE_SECOND) |
++---------------------------------------------------------------+
+| 2025-10-23 10:11:11 |
++---------------------------------------------------------------+
+
+-- Add SECOND_MICROSECOND
+mysql> select date_add("2025-10-10 10:10:10.123456", INTERVAL "1.1" SECOND_MICROSECOND);
++---------------------------------------------------------------------------+
+| date_add("2025-10-10 10:10:10.123456", INTERVAL "1.1" SECOND_MICROSECOND) |
++---------------------------------------------------------------------------+
+| 2025-10-10 10:10:11.223456 |
++---------------------------------------------------------------------------+
+
+-- For composite units, the sign of the time interval is determined only by whether the first non-digit character is `-`
+-- All subsequent `-` are considered part of the delimiter
+select
+ DATE_ADD('2025-10-23 10:10:10', INTERVAL '#-1:-1' MINUTE_SECOND) AS first_not_sub,
+ DATE_ADD('2025-10-23 10:10:10', INTERVAL ' -1:1' MINUTE_SECOND) AS first_sub;
++---------------------+---------------------+
+| first_not_sub | first_sub |
++---------------------+---------------------+
+| 2025-10-23 10:11:11 | 2025-10-23 10:09:09 |
++---------------------+---------------------+
+
+-- For composite units, if the input time interval is too short, the value of the larger unit will be set to 0.
+select DATE_ADD('2025-10-23 10:10:10', INTERVAL '1' MINUTE_SECOND) AS minute_interval_is_zero
++-------------------------+
+| minute_interval_is_zero |
++-------------------------+
+| 2025-10-23 10:10:11 |
++-------------------------+
+
+-- Example of TimestampTz type, SET time_zone = '+08:00'
+select DATE_ADD('2023-01-01 23:22:33+03:00', INTERVAL 1 DAY);
++-------------------------------------------------------+
+| DATE_ADD('2023-01-01 23:22:33+03:00', INTERVAL 1 DAY) |
++-------------------------------------------------------+
+| 2023-01-03 04:22:33+08:00 |
++-------------------------------------------------------+
+
+-- If the number of time intervals input is excessive, return an error
+select DATE_ADD('2025-10-23 10:10:10', INTERVAL '1:2:3.4' SECOND_MICROSECOND);
+-- ERROR 1105 (HY000): errCode = 2, detailMessage = (10.16.10.3)[INVALID_ARGUMENT]Operation second_microsecond_add of 1:2:3.4 is invalid
+
+-- For composite units, if the value of any part exceeds the maximum value of 922337203685477580
+-- return an error
+select DATE_ADD('2025-10-10 1:2:3', INTERVAL '922337203685477580' DAY_MICROSECOND);
+-- ERROR 1105 (HY000): errCode = 2, detailMessage = (10.16.10.3)[E-218]Operation day_microsecond_add of 2025-10-10 01:02:03, 922337203685477580 out of range
+
+-- Illegal unit
+select DATE_ADD('2023-12-31 23:00:00', INTERVAL 2 sa);
+ERROR 1105 (HY000): errCode = 2, detailMessage =
+mismatched input 'sa' expecting {'.', '[', 'AND', 'BETWEEN', 'COLLATE', 'DAY', 'DIV', 'HOUR', 'IN', 'IS', 'LIKE', 'MATCH', 'MATCH_ALL', 'MATCH_ANY', 'MATCH_PHRASE', 'MATCH_PHRASE_EDGE', 'MATCH_PHRASE_PREFIX', 'MATCH_REGEXP', 'MINUTE', 'MONTH', 'NOT', 'OR', 'QUARTER', 'REGEXP', 'RLIKE', 'SECOND', 'WEEK', 'XOR', 'YEAR', EQ, '<=>', NEQ, '<', LTE, '>', GTE, '+', '-', '*', '/', '%', '&', '&&', '|', '||', '^'}(line 1, pos 50)
+
+-- Parameter is NULL, returns NULL
+mysql> select DATE_ADD(NULL, INTERVAL 1 MONTH);
++----------------------------------+
+| DATE_ADD(NULL, INTERVAL 1 MONTH) |
++----------------------------------+
+| NULL |
++----------------------------------+
+
+-- Calculated result is not in date range [0000,9999], returns error
+mysql> select DATE_ADD('0001-01-28', INTERVAL -2 YEAR);
+ERROR 1105 (HY000): errCode = 2, detailMessage = (10.16.10.2)[E-218]Operation years_add of 0001-01-28, -2 out of range
+
+mysql> select DATE_ADD('9999-01-28', INTERVAL 2 YEAR);
+ERROR 1105 (HY000): errCode = 2, detailMessage = (10.16.10.2)[E-218]Operation years_add of 9999-01-28, 2 out of range
+```
diff --git a/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/date-time-functions/date-ceil.md b/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/date-time-functions/date-ceil.md
new file mode 100644
index 000000000000..9cb0cda9cca4
--- /dev/null
+++ b/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/date-time-functions/date-ceil.md
@@ -0,0 +1,163 @@
+---
+{
+ "title": "DATE_CEIL",
+ "language": "ru",
+ "description": "Функция dateceil округляет указанное значение даты или времени вверх до ближайшего начала заданного временного периода."
+}
+---
+
+## Описание {#description}
+
+
+Функция date_ceil округляет указанное значение даты или времени вверх до ближайшего начала заданного временного периода. Поддерживаются входные значения типов `DATE`, `DATETIME`, `TIMESTAMP_NS` и `TIMESTAMPTZ`. Правила округления задаются параметрами period (количество единиц) и type (единица измерения), а отсчёт ведётся от фиксированной начальной точки 0001-01-01 00:00:00.
+
+Формула расчёта даты:
+$$
+\begin{aligned}
+&\text{date\_ceil}(\langle\text{date\_or\_time\_expr}\rangle, \langle\text{period}\rangle, \langle\text{type}\rangle) = \\
+&\min\{\langle\text{origin}\rangle + k \times \langle\text{period}\rangle \times \text{type} \mid \\
+&k \in \mathbb{Z} \land \langle\text{origin}\rangle + k \times \langle\text{period}\rangle \times \text{type} \geq \langle\text{date\_or\_time\_expr}\rangle\}
+\end{aligned}
+$$
+$k$ обозначает количество периодов, необходимое для достижения целевого времени от начальной точки отсчёта.
+
+$type$ обозначает единицу измерения периода
+
+## Синтаксис {#syntax}
+
+`DATE_CEIL(<datetime>, INTERVAL <period> <type>)`
+
+## Параметры {#parameters}
+
+| Параметр | Описание |
+| -- | -- |
+| `date_or_time_expr` | Корректное выражение даты. Поддерживаются типы `DATE`, `DATETIME`, `TIMESTAMP_NS` и `TIMESTAMPTZ`. Подробнее о форматах см. в разделах [преобразование timestamptz](../../../../sql-manual/basic-element/sql-data-types/conversion/timestamptz-conversion), [преобразование datetime](../../../../sql-manual/basic-element/sql-data-types/conversion/datetime-conversion) и [преобразование date](../../../../sql-manual/basic-element/sql-data-types/conversion/date-conversion). |
+| `period` | Задаёт количество единиц в каждом периоде; имеет тип INT. Начальная точка отсчёта: 0001-01-01T00:00:00 |
+| `type` | Допустимые значения: YEAR, QUARTER, MONTH, WEEK, DAY, HOUR, MINUTE, SECOND |
+
+## Возвращаемое значение {#return-value}
+
+Для входного значения `TIMESTAMP_NS` возвращается значение `TIMESTAMP_NS` с фиксированной точностью до девяти знаков в дробной части секунды. Результаты проверяются на соответствие диапазону возвращаемого типа; для `TIMESTAMP_NS` используется диапазон `[1677-09-21 00:12:43.145224192, 2262-04-11 23:47:16.854775807]`.
+
+Если `<origin>` не указан для входного значения `TIMESTAMP_NS`, описанная в документации начальная точка по умолчанию используется только как внутренняя точка отсчёта для выравнивания; она не обязана находиться в диапазоне значений, которые может хранить `TIMESTAMP_NS`.
+
+Возвращаемый тип: TIMESTAMPTZ, TIMESTAMP_NS, DATETIME или DATE. Возвращается значение даты или времени, полученное округлением входного значения вверх до указанной единицы измерения.
+
+Тип округлённого результата соответствует типу `<date_or_time_expr>`:
+- Если входное значение имеет тип TIMESTAMPTZ, оно сначала преобразуется в local_time (например, `2025-12-31 23:59:59+05:00` соответствует local_time `2026-01-01 02:59:59`, если переменная сеанса равна `+08:00`), после чего выполняется вычисление DATE_CEIL.
+- Для входного значения типа DATE возвращается DATE (только дата);
+- Для входного значения типа DATETIME возвращается DATETIME (дата и время).
+- Для входного значения типа TIMESTAMP_NS возвращается TIMESTAMP_NS с девятью знаками в дробной части секунды.
+- Для входного значения типа TIMESTAMPTZ возвращается TIMESTAMPTZ (дата, время и смещение).
+- Для DATETIME и TIMESTAMPTZ с заданным scale возвращаемое значение также имеет scale, а дробная часть равна нулю.
+
+Особые случаи:
+- Если любой из параметров равен NULL, возвращается NULL;
+- Если округлённый результат выходит за диапазон, поддерживаемый типом даты (например, за пределы '9999-12-31 23:59:59'), возвращается ошибка;
+- Если параметр period является неположительным целым числом, возникает ошибка.
+
+## Примеры {#examples}
+
+```sql
+-- Round up seconds to the nearest 5-second interval
+mysql> select date_ceil(cast("2023-07-13 22:28:18" as datetime),interval 5 second);
+
++------------------------------------------------------------------------+
+| date_ceil(cast("2023-07-13 22:28:18" as datetime),interval 5 second) |
++------------------------------------------------------------------------+
+| 2023-07-13 22:28:20.000000 |
++------------------------------------------------------------------------+
+
+-- Date time parameter with scale
+mysql> select date_ceil(cast("2023-07-13 22:28:18.123" as datetime(3)),interval 5 second);
++-----------------------------------------------------------------------------+
+| date_ceil(cast("2023-07-13 22:28:18.123" as datetime(3)),interval 5 second) |
++-----------------------------------------------------------------------------+
+| 2023-07-13 22:28:20.000 |
++-----------------------------------------------------------------------------+
+
+-- Round up to the nearest 5-minute interval
+select date_ceil("2023-07-13 22:28:18",interval 5 minute);
++--------------------------------------------------------------+
+| minute_ceil('2023-07-13 22:28:18', 5, '0001-01-01 00:00:00') |
++--------------------------------------------------------------+
+| 2023-07-13 22:30:00 |
++--------------------------------------------------------------+
+
+-- Round up to the nearest 5-week interval
+select date_ceil("2023-07-13 22:28:18",interval 5 WEEK);
++--------------------------------------------------+
+| date_ceil("2023-07-13 22:28:18",interval 5 WEEK) |
++--------------------------------------------------+
+| 2023-08-14 00:00:00 |
++--------------------------------------------------+
+
+-- Round up to the nearest 5-hour interval
+select date_ceil("2023-07-13 22:28:18",interval 5 hour);
+
++--------------------------------------------------+
+| date_ceil("2023-07-13 22:28:18",interval 5 hour) |
++--------------------------------------------------+
+| 2023-07-13 23:00:00 |
++--------------------------------------------------+
+
+-- Round up to the nearest 5-day interval
+select date_ceil("2023-07-13 22:28:18",interval 5 day);
+
++-----------------------------------------------------------+
+| day_ceil('2023-07-13 22:28:18', 5, '0001-01-01 00:00:00') |
++-----------------------------------------------------------+
+| 2023-07-15 00:00:00 |
++-----------------------------------------------------------+
+
+-- Round up to the nearest 5-month interval
+select date_ceil("2023-07-13 22:28:18",interval 5 month);
+
++-------------------------------------------------------------+
+| month_ceil('2023-07-13 22:28:18', 5, '0001-01-01 00:00:00') |
++-------------------------------------------------------------+
+| 2023-12-01 00:00:00 |
++-------------------------------------------------------------+
+
+
+-- Round up to the nearest 5-year interval
+select date_ceil("2023-07-13 22:28:18",interval 5 year);
+
++-------------------------------------------------------------+
+| month_ceil('2023-07-13 22:28:18', 5, '0001-01-01 00:00:00') |
++-------------------------------------------------------------+
+| 2023-12-01 00:00:00 |
++-------------------------------------------------------------+
+
+-- TimeStampTz type example, SET time_zone = '+08:00'
+-- Convert variable value to local_time(2026-01-01 02:59:59) then perform DATE_CEIL operation
+SELECT DATE_CEIL('2025-12-31 23:59:59+05:00', INTERVAL 1 YEAR);
++---------------------------------------------------------+
+| DATE_CEIL('2025-12-31 23:59:59+05:00', INTERVAL 1 YEAR) |
++---------------------------------------------------------+
+| 2027-01-01 00:00:00+08:00 |
++---------------------------------------------------------+
+
+-- Exceeds the maximum year
+mysql> select date_ceil("9999-07-13",interval 5 year);
+ERROR 1105 (HY000): errCode = 2, detailMessage = (10.16.10.3)[E-218]Operation year_ceil of 9999-07-13 00:00:00, 5 out of range
+
+-- Any parameter is NULL
+mysql> select date_ceil("9900-07-13",interval NULL year);
++--------------------------------------------+
+| date_ceil("9900-07-13",interval NULL year) |
++--------------------------------------------+
+| NULL |
++--------------------------------------------+
+
+mysql> select date_ceil(NULL,interval 5 year);
++---------------------------------+
+| date_ceil(NULL,interval 5 year) |
++---------------------------------+
+| NULL |
++---------------------------------+
+
+-- Invalid parameter, period is negative
+mysql> select date_ceil("2023-01-13 22:28:18",interval -5 month);
+ERROR 1105 (HY000): errCode = 2, detailMessage = (10.16.10.3)[INVALID_ARGUMENT]Operation month_ceil of 2023-01-13 22:28:18, -5, 0001-01-01 00:00:00 out of range
+```
diff --git a/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/date-time-functions/date-floor.md b/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/date-time-functions/date-floor.md
new file mode 100644
index 000000000000..803a5a51746b
--- /dev/null
+++ b/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/date-time-functions/date-floor.md
@@ -0,0 +1,129 @@
+---
+{
+ "title": "DATE_FLOOR",
+ "language": "ru",
+ "description": "Функция datefloor округляет указанное значение даты или времени вниз до ближайшего начала заданного временного интервала."
+}
+---
+
+## Описание {#description}
+
+Функция date_floor округляет указанное значение даты или времени вниз до ближайшего начала заданного временного интервала. Она поддерживает входные значения типов `DATE`, `DATETIME`, `TIMESTAMP_NS` и `TIMESTAMPTZ`. Период задаётся параметрами period (количество единиц) и type (единица измерения); расчёт ведётся от фиксированной начальной точки 0001-01-01 00:00:00.
+
+Формула расчёта даты:
+$$
+\begin{aligned}
+&\text{date\_floor}(\langle\text{date\_or\_time\_expr}\rangle, \langle\text{period}\rangle, \langle\text{type}\rangle) = \\
+&\max\{\langle\text{origin}\rangle + k \times \langle\text{period}\rangle \times \text{type} \mid \\
+&k \in \mathbb{Z} \land \langle\text{origin}\rangle + k \times \langle\text{period}\rangle \times \text{type} \leq \langle\text{date\_or\_time\_expr}\rangle\}
+\end{aligned}
+$$
+$k$ обозначает количество периодов, необходимых для достижения целевого времени от базового времени.
+
+$type$ обозначает единицу измерения периода
+
+## Синтаксис {#syntax}
+
+`DATE_FLOOR(<datetime>, INTERVAL <period> <type>)`
+
+## Параметры {#parameters}
+
+| Параметр | Описание |
+| -- | -- |
+| `date_or_time_expr` | Допустимое выражение даты. Поддерживаются `DATE`, `DATETIME`, `TIMESTAMP_NS` и `TIMESTAMPTZ`. Подробнее о форматах см. в разделах [преобразование timestamptz](../../../../sql-manual/basic-element/sql-data-types/conversion/timestamptz-conversion), [преобразование datetime](../../../../sql-manual/basic-element/sql-data-types/conversion/datetime-conversion) и [преобразование date](../../../../sql-manual/basic-element/sql-data-types/conversion/date-conversion). |
+| `period` | Задаёт количество единиц в каждом периоде, имеет тип `INT`. Начальная точка отсчёта: 0001-01-01T00:00:00 |
+| `type` | Допустимые значения: YEAR, QUARTER, MONTH, WEEK, DAY, HOUR, MINUTE, SECOND |
+
+## Возвращаемое значение {#return-value}
+
+Для входного значения типа `TIMESTAMP_NS` возвращается значение `TIMESTAMP_NS` с фиксированной точностью дробной части секунды в девять знаков. Результаты проверяются на соответствие диапазону возвращаемого типа; для `TIMESTAMP_NS` используется диапазон `[1677-09-21 00:12:43.145224192, 2262-04-11 23:47:16.854775807]`.
+
+Если `<origin>` не указан для входного значения типа `TIMESTAMP_NS`, документированная начальная точка по умолчанию используется только как внутренняя точка отсчёта для выравнивания; она не обязательно должна находиться в диапазоне значений, доступных для хранения в `TIMESTAMP_NS`.
+
+Возвращаемый тип: TIMESTAMPTZ, TIMESTAMP_NS, DATETIME или DATE. Возвращается результат округления даты вниз в соответствии с периодом, с тем же типом, что и у `<date_or_time_expr>`.
+
+Результат округления вниз соответствует типу `<date_or_time_expr>`:
+- Если входное значение имеет тип TIMESTAMPTZ, оно сначала преобразуется в local_time (например, `2025-12-31 23:59:59+05:00` представляет local_time `2026-01-01 02:59:59`, если значение переменной сеанса равно `+08:00`), затем выполняется вычисление DATE_FLOOR.
+- Если входное значение имеет тип DATE, возвращается DATE (только дата);
+- Если входное значение имеет тип DATETIME, возвращается DATETIME (дата и время).
+- Если входное значение имеет тип TIMESTAMP_NS, возвращается TIMESTAMP_NS с девятью знаками в дробной части секунды.
+- Если входное значение имеет тип TIMESTAMPTZ, возвращается TIMESTAMPTZ (дата, время и смещение).
+- Если входное значение содержит дробную часть секунд, возвращаемое значение сохраняет её точность, а сама дробная часть равна нулю.
+
+Особые случаи:
+- Возвращается NULL, если какой-либо параметр равен NULL;
+- При недопустимом значении period (неположительное целое число) или type возвращается ошибка;
+
+## Примеры {#examples}
+
+```sql
+-- Floor down to the nearest 5-second interval (period starts at 00, 05, 10... seconds)
+mysql> select date_floor(cast("0001-01-01 00:00:18" as datetime), INTERVAL 5 SECOND);
++------------------------------------------------------------------------+
+| date_floor(cast("0001-01-01 00:00:18" as datetime), INTERVAL 5 SECOND) |
++------------------------------------------------------------------------+
+| 0001-01-01 00:00:15.000000 |
++------------------------------------------------------------------------+
+
+-- Date time with scale will return value with scale
+mysql> select date_floor(cast("0001-01-01 00:00:18.123" as datetime), INTERVAL 5 SECOND);
++----------------------------------------------------------------------------+
+| date_floor(cast("0001-01-01 00:00:18.123" as datetime), INTERVAL 5 SECOND) |
++----------------------------------------------------------------------------+
+| 0001-01-01 00:00:15.000000 |
++----------------------------------------------------------------------------+
+
+-- The input time is exactly the start of a 5-day period
+mysql> select date_floor("2023-07-10 00:00:00", INTERVAL 5 DAY);
++---------------------------------------------------+
+| date_floor("2023-07-10 00:00:00", INTERVAL 5 DAY) |
++---------------------------------------------------+
+| 2023-07-10 00:00:00 |
++---------------------------------------------------+
+
+-- Floor down for date type
+mysql> select date_floor("2023-07-13", INTERVAL 5 YEAR);
++-------------------------------------------+
+| date_floor("2023-07-13", INTERVAL 5 YEAR) |
++-------------------------------------------+
+| 2021-01-01 00:00:00 |
++-------------------------------------------+
+
+-- TimeStampTz type example, SET time_zone = '+08:00'
+-- Convert variable value to local_time(2026-01-01 02:59:59) then perform DATE_FLOOR operation
+SELECT DATE_FLOOR('2025-12-31 23:59:59+05:00', INTERVAL 1 YEAR);
++----------------------------------------------------------+
+| DATE_FLOOR('2025-12-31 23:59:59+05:00', INTERVAL 1 YEAR) |
++----------------------------------------------------------+
+| 2026-01-01 00:00:00+08:00 |
++----------------------------------------------------------+
+
+-- If parameters contain both TimeStampTz and Datetime types, output DateTime type
+SELECT DATE_FLOOR('2025-12-31 23:59:59+05:00', INTERVAL 1 HOUR, '2025-12-15 00:00:00.123') AS result;
+
+-- period is negative, invalid returns error
+mysql> select date_floor("2023-07-13 22:28:18", INTERVAL -5 MINUTE);
+ERROR 1105 (HY000): errCode = 2, detailMessage = (10.16.10.3)[E-218]Operation minute_floor of 2023-07-13 22:28:18, -5, 0001-01-01 00:00:00 out of range
+
+-- Unsupported type
+mysql> select date_floor("2023-07-13 22:28:18", INTERVAL 5 MILLISECOND);
+ERROR 1105 (HY000): errCode = 2, detailMessage =
+mismatched input 'MILLISECOND' expecting {'.', '[', 'AND', 'BETWEEN', 'COLLATE', 'DAY', 'DIV', 'HOUR', 'IN', 'IS', 'LIKE', 'MATCH', 'MATCH_ALL', 'MATCH_ANY', 'MATCH_PHRASE', 'MATCH_PHRASE_EDGE', 'MATCH_PHRASE_PREFIX', 'MATCH_REGEXP', 'MINUTE', 'MONTH', 'NOT', 'OR', 'QUARTER', 'REGEXP', 'RLIKE', 'SECOND', 'WEEK', 'XOR', 'YEAR', EQ, '<=>', NEQ, '<', LTE, '>', GTE, '+', '-', '*', '/', '%', '&', '&&', '|', '||', '^'}(line 1, pos 52)
+
+-- Any parameter is NULL
+mysql> select date_floor(NULL, INTERVAL 5 HOUR);
++-----------------------------------+
+| date_floor(NULL, INTERVAL 5 HOUR) |
++-----------------------------------+
+| NULL |
++-----------------------------------+
+
+-- Floor down every 5 weeks
+mysql> select date_floor("2023-07-13 22:28:18", INTERVAL 5 WEEK);
++----------------------------------------------------+
+| date_floor("2023-07-13 22:28:18", INTERVAL 5 WEEK) |
++----------------------------------------------------+
+| 2023-07-10 00:00:00 |
++----------------------------------------------------+
+
+```
diff --git a/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/date-time-functions/date-format.md b/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/date-time-functions/date-format.md
new file mode 100644
index 000000000000..aa40b165fd36
--- /dev/null
+++ b/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/date-time-functions/date-format.md
@@ -0,0 +1,195 @@
+---
+{
+ "title": "DATE_FORMAT",
+ "language": "ru",
+ "description": "Функция DATEFORMAT преобразует значение даты или времени в строку в соответствии с заданной строкой формата (format)."
+}
+---
+
+## Описание {#description}
+
+Функция DATE_FORMAT преобразует значение даты или времени в строку в соответствии с заданной строкой формата (`format`). Она поддерживает значения типов `DATE`, `DATETIME`, `TIMESTAMP_NS` и `TIMESTAMPTZ` и возвращает строку, соответствующую указанному формату.
+
+Поведение этой функции соответствует [функции date_format](https://dev.mysql.com/doc/refman/8.4/en/date-and-time-functions.html#function_date-format) в MySQL.
+
+## Синтаксис {#syntax}
+
+```sql
+DATE_FORMAT(<date_or_time_expr>, <format>)
+```
+
+## Параметры {#parameters}
+
+| Параметр | Описание |
+| -- | -- |
+| `<date_or_time_expr>` | Допустимое значение типа `DATE`, `DATETIME`, `TIMESTAMP_NS` или `TIMESTAMPTZ`. Подробные сведения о форматах даты и времени см. в разделах [Преобразование даты](../../../../sql-manual/basic-element/sql-data-types/conversion/date-conversion), [Преобразование даты и времени](../../../../sql-manual/basic-element/sql-data-types/conversion/datetime-conversion), [Преобразование timestamp_ns](../../../basic-element/sql-data-types/conversion/timestamp-ns-conversion.md) [...]
+| `<format>` | Задаёт формат вывода даты и времени; имеет тип `varchar` |
+
+Поддерживаемые спецификаторы формата:
+
+| Спецификатор формата | Описание |
+|--------|-------------------------------------|
+| %a | Сокращённое название дня недели (3 буквы) |
+| %b | Сокращённое название месяца (3 буквы) |
+| %c | Месяц в виде числа (0-12) |
+| %D | День месяца с английским суффиксом (0th, 1st, 2nd, 3rd, …) |
+| %d | День месяца в виде числа (00-31) |
+| %e | День месяца в виде числа (0-31) |
+| %f | Микросекунды (000000-999999) |
+| %n | Наносекунды (000000000-999999999). Для типов с меньшей точностью недостающие разряды заполняются нулями. |
+| %H | Час (00-23) |
+| %h | Час (01-12) |
+| %I | Час (01-12) |
+| %i | Минуты в виде числа (00-59) |
+| %j | День года (001-366) |
+| %k | Час (0-23) |
+| %l | Час (1-12) |
+| %M | Название месяца |
+| %m | Месяц в виде числа (00-12) |
+| %p | AM или PM |
+| %r | Время в 12-часовом формате (hh:mm:ss с последующим AM или PM) |
+| %S | Секунды (00-59) |
+| %s | Секунды (00-59) |
+| %T | Время в 24-часовом формате (hh:mm:ss) |
+| %U | Неделя (00-53), где первый день недели приходится на воскресенье; режим 0 функции [week](./week) |
+| %u | Неделя (00-53), где первый день недели приходится на понедельник; режим 1 функции [week](./week) |
+| %V | Неделя (01-53), где первый день недели приходится на воскресенье; режим 2 функции [week](./week), используется с %X |
+| %v | Неделя (01-53), где первый день недели приходится на понедельник; режим 3 функции [week](./week), используется с %x |
+| %W | Полное название дня недели (воскресенье-суббота) |
+| %w | День недели (0 = воскресенье, 6 = суббота) |
+| %X | Год при отсчёте недель с воскресенья (4 цифры), используется с %V |
+| %x | Год при отсчёте недель с понедельника (4 цифры), используется с %v |
+| %Y | Год (4 цифры) |
+| %y | Год (2 цифры) |
+| %% | Обозначает символ % |
+| %**x** | Для любого **x**, не указанного выше, обозначает сам символ **x** |
+
+Также доступны три специальных формата:
+
+```text
+yyyyMMdd --corresponds to standard format specifier：%Y%m%d
+yyyy-MM-dd --corresponds to standard format specifier：%Y-%m-%d
+yyyy-MM-dd HH:mm:ss --corresponds to standard format specifier：%Y-%m-%d %H:%i:%s
+```
+
+## Возвращаемое значение {#return-value}
+
+Отформатированная строка даты типа Varchar.
+
+Особые случаи:
+- Возвращает NULL, если format равен NULL.
+- Возвращает NULL, если любой из параметров равен NULL.
+- Возвращает ошибку, если длина входного значения превышает 128 символов.
+- Возвращает ошибку, если длина результата превышает 102 символа.
+
+## Примеры {#examples}
+
+```sql
+SELECT DATE_FORMAT(
+ CAST('2024-02-29 12:34:56.123456789' AS TIMESTAMP_NS),
+ '%Y-%m-%d %H:%i:%s.%n'
+) AS result;
+```
+
+```text
++-------------------------------+
+| result |
++-------------------------------+
+| 2024-02-29 12:34:56.123456789 |
++-------------------------------+
+```
+
+```sql
+-- Output weekday name, month name, and 4-digit year
+select date_format(cast('2009-10-04 22:23:00' as datetime), '%W %M %Y');
+
++------------------------------------------------------------------+
+| date_format(cast('2009-10-04 22:23:00' as datetime), '%W %M %Y') |
++------------------------------------------------------------------+
+| Sunday October 2009 |
++------------------------------------------------------------------+
+
+-- Output time in 24-hour format (hour:minute:second)
+select date_format('2007-10-04 22:23:00', '%H:%i:%s');
+
++------------------------------------------------+
+| date_format('2007-10-04 22:23:00', '%H:%i:%s') |
++------------------------------------------------+
+| 22:23:00 |
++------------------------------------------------+
+
+-- Combine multiple format specifiers and plain characters
+select date_format('1900-10-04 22:23:00', 'Day: %D, Year: %y, Month: %b, DayOfYear: %j');
+
++-----------------------------------------------------------------------------------+
+| date_format('1900-10-04 22:23:00', 'Day: %D, Year: %y, Month: %b, DayOfYear: %j') |
++-----------------------------------------------------------------------------------+
+| Day: 4th, Year: 00, Month: Oct, DayOfYear: 277 |
++-----------------------------------------------------------------------------------+
+
+-- %X (year) used with %V (week number), where Sunday is the first day of the week
+select date_format('1999-01-01 00:00:00', '%X-%V');
+
++---------------------------------------------+
+| date_format('1999-01-01 00:00:00', '%X-%V') |
++---------------------------------------------+
+| 1998-52 |
++---------------------------------------------+
+
+-- Output the % character (escaped with %%)
+select date_format(cast('2006-06-01' as date), '%%%d/%m');
+
++----------------------------------------------------+
+| date_format(cast('2006-06-01' as date), '%%%d/%m') |
++----------------------------------------------------+
+| %01/06 |
++----------------------------------------------------+
+
+-- Special format yyyy-MM-dd HH:mm:ss
+select date_format('2023-12-31 23:59:59', 'yyyy-MM-dd HH:mm:ss');
++-----------------------------------------------------------+
+| date_format('2023-12-31 23:59:59', 'yyyy-MM-dd HH:mm:ss') |
++-----------------------------------------------------------+
+| 2023-12-31 23:59:59 |
++-----------------------------------------------------------+
+
+-- String that does not reference any time information
+select date_format('2023-12-31 23:59:59', 'ghg');
++-------------------------------------------+
+| date_format('2023-12-31 23:59:59', 'ghg') |
++-------------------------------------------+
+| ghg |
++-------------------------------------------+
+
+-- Special format yyyyMMdd
+select date_format('2023-12-31 23:59:59', 'yyyyMMdd');
++------------------------------------------------+
+| date_format('2023-12-31 23:59:59', 'yyyyMMdd') |
++------------------------------------------------+
+| 20231231 |
++------------------------------------------------+
+
+-- Special format yyyy-MM-dd
+select date_format('2023-12-31 23:59:59', 'yyyy-MM-dd');
++--------------------------------------------------+
+| date_format('2023-12-31 23:59:59', 'yyyy-MM-dd') |
++--------------------------------------------------+
+| 2023-12-31 |
++--------------------------------------------------+
+
+-- Parameter is null
+mysql> select date_format(NULL, '%Y-%m-%d');
++-------------------------------+
+| date_format(NULL, '%Y-%m-%d') |
++-------------------------------+
+| NULL |
++-------------------------------+
+
+---Returns error if the result string exceeds the function's maximum length limit.
+mysql> select date_format('2022-01-12',repeat('a',129));
+ERROR 1105 (HY000): errCode = 2, detailMessage = (10.16.10.3)[INVALID_ARGUMENT]Operation date_format of invalid or oversized format is invalid
+
+---output length over 102 size,throw error
+mysql> select date_format('2022-11-13 10:12:12',repeat('%h',52));
+ERROR 1105 (HY000): errCode = 2, detailMessage = (10.16.10.3)[INVALID_ARGUMENT]Operation date_format of 142335809712816128,%h%h%h%h%h%h%h%h%h%h%h%h%h%h%h%h%h%h%h%h%h%h%h%h%h%h%h%h%h%h%h%h%h%h%h%h%h%h%h%h%h%h%h%h%h%h%h%h%h%h%h%h is invalid
+```
diff --git a/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/date-time-functions/date-sub.md b/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/date-time-functions/date-sub.md
new file mode 100644
index 000000000000..0453421dedf2
--- /dev/null
+++ b/i18n/ru/docusaurus-plugin-content-docs/current/sql-manual/sql-functions/scalar-functions/date-time-functions/date-sub.md
@@ -0,0 +1,186 @@
+---
+{
+ "title": "DATE_SUB",
+ "language": "ru",
+ "description": "Функция DATESUB вычитает заданный временной интервал из указанного значения даты или времени и возвращает вычисленный результат."
+}
+---
+
+## Описание {#description}
+
+Функция DATE_SUB вычитает заданный временной интервал из значения даты или времени и возвращает вычисленный результат. Она поддерживает входные значения типов `DATE`, `DATETIME`, `TIMESTAMP_NS` и `TIMESTAMPTZ`. Временной интервал задаётся числовым значением и единицей измерения.
+
+Поведение этой функции соответствует поведению [функции date_sub](https://dev.mysql.com/doc/refman/8.4/en/date-and-time-functions.html#function_date-sub) в MySQL.
+
+## Псевдонимы {#aliases}
+
+- days_sub
+- subdate
+
+## Синтаксис {#syntax}
+
+```sql
+DATE_SUB(<date_or_time_part>, INTERVAL <expr> <time_unit>)
+```
+
+## Параметры {#parameters}
+
+| Параметр | Описание |
+| -- | -- |
+| `<date_or_time_part>` | Допустимое значение даты. Поддерживаются типы `DATE`, `DATETIME`, `TIMESTAMP_NS` и `TIMESTAMPTZ`. Подробные сведения о форматах см. в разделах [Преобразование timestamptz](../../../../sql-manual/basic-element/sql-data-types/conversion/timestamptz-conversion), [Преобразование datetime](../../../../sql-manual/basic-element/sql-data-types/conversion/datetime-conversion) и [Преобразование date](../../../../sql-manual/basic-element/sql-data-types/conversion/date-conv [...]
+| `<expr>` | Вычитаемый временной интервал. Для простых единиц (например, `YEAR`) используется тип `INT`, а для составных единиц (например, `YEAR_MONTH`) используется тип `STRING`, причём разделителями могут служить любые нецифровые символы. Поэтому, например, `INTERVAL 6/4 HOUR_MINUTE` будет распознан Doris как 6 часов 4 минуты, а не как 1 час 30 минут (6/4 == 1.5). Для составных единиц, если во входном значении интервала недостаточно компонентов, значение старшей единицы устанавливаетс [...]
+| `<time_unit>` | Допустимые значения: YEAR, QUARTER, MONTH, WEEK, DAY, HOUR, MINUTE, SECOND, YEAR_MONTH, DAY_HOUR, DAY_MINUTE, DAY_SECOND, DAY_MICROSECOND, HOUR_MINUTE, HOUR_SECOND, HOUR_MICROSECOND, MINUTE_SECOND, MINUTE_MICROSECOND, SECOND_MICROSECOND |
+
+| time_unit | Ожидаемый формат (разделителями могут служить любые нецифровые символы) |
+| ------------------ | ----------------------------------------- |
+| YEAR | 'YEARS' |
+| QUARTER | 'QUARTERS' |
+| MONTH | 'MONTHS' |
+| WEEK | 'WEEKS' |
+| DAY | 'DAYS' |
+| HOUR | 'HOURS' |
+| MINUTE | 'MINUTES' |
+| SECOND | 'SECONDS' |
+| MICROSECOND | 'MICROSECONDS' |
+| YEAR_MONTH | 'YEARS-MONTHS' |
+| DAY_HOUR | 'DAYS HOURS' |
+| DAY_MINUTE | 'DAYS HOURS:MINUTES' |
+| DAY_SECOND | 'DAYS HOURS:MINUTES:SECONDS' |
+| DAY_MICROSECOND | 'DAYS HOURS:MINUTES:SECONDS.MICROSECONDS' |
+| HOUR_MINUTE | 'HOURS:MINUTES' |
+| HOUR_SECOND | 'HOURS:MINUTES:SECONDS' |
+| HOUR_MICROSECOND | 'HOURS:MINUTES:SECONDS.MICROSECONDS' |
+| MINUTE_SECOND | 'MINUTES:SECONDS' |
+| MINUTE_MICROSECOND | 'MINUTES:SECONDS.MICROSECONDS' |
+| SECOND_MICROSECOND | 'SECONDS.MICROSECONDS' |
+
+## Возвращаемое значение {#return-value}
+
+Для входного значения типа `TIMESTAMP_NS` возвращается значение типа `TIMESTAMP_NS` с фиксированной точностью до девяти знаков в дробной части секунды. Результаты проверяются на соответствие диапазону возвращаемого типа; для `TIMESTAMP_NS` используется диапазон `[1677-09-21 00:12:43.145224192, 2262-04-11 23:47:16.854775807]`.
+
+Возвращает вычисленный результат того же типа, что и date:
+- Если входное значение имеет тип DATE, возвращается DATE (только дата);
+- Если входное значение имеет тип DATETIME, возвращается DATETIME (дата и время).
+- Если входное значение имеет тип TIMESTAMP_NS, возвращается TIMESTAMP_NS с девятью знаками в дробной части секунды.
+- Если входное значение имеет тип TIMESTAMPTZ, возвращается TIMESTAMPTZ (дата, время и смещение часового пояса).
+- Для типов даты и времени с заданной точностью дробной части эта точность сохраняется в возвращаемом значении.
+
+Особые случаи:
+- Если какой-либо параметр равен NULL, возвращается NULL;
+- При недопустимом значении expr (отрицательные значения) или time_unit возвращается NULL;
+- Для составных единиц, если во входном значении слишком много компонентов или значение любого компонента превышает допустимый максимум 922337203685477579, возвращается ошибка.
+- Если вычисленный результат предшествует минимальному значению, поддерживаемому типом даты (например, дате '0000-01-01'), возвращается ошибка.
+
+## Примеры {#examples}
+
+```sql
+-- Subtract two days
+mysql> select date_sub(cast('2010-11-30 23:59:59' as datetime), INTERVAL 2 DAY);
+
++-------------------------------------------------------------------+
+| date_sub(cast('2010-11-30 23:59:59' as datetime), INTERVAL 2 DAY) |
++-------------------------------------------------------------------+
+| 2010-11-28 23:59:59 |
++-------------------------------------------------------------------+
+
+-- Parameter with scale, return preserves scale
+mysql> select date_sub('2010-11-30 23:59:59.6', INTERVAL 4 SECOND);
++------------------------------------------------------+
+| date_sub('2010-11-30 23:59:59.6', INTERVAL 4 SECOND) |
++------------------------------------------------------+
+| 2010-11-30 23:59:55.6 |
++------------------------------------------------------+
+
+-- Subtract two months across years
+mysql> select date_sub(cast('2023-01-15' as date), INTERVAL 2 MONTH);
++--------------------------------------------------------+
+| date_sub(cast('2023-01-15' as date), INTERVAL 2 MONTH) |
++--------------------------------------------------------+
+| 2022-11-15 |
++--------------------------------------------------------+
+
+-- February 2023 has only 28 days, so subtracting one month from 2023-03-31 results in 2023-02-28
+mysql> select date_sub('2023-03-31', INTERVAL 1 MONTH);
++------------------------------------------+
+| date_sub('2023-03-31', INTERVAL 1 MONTH) |
++------------------------------------------+
+| 2023-02-28 |
++------------------------------------------+
+
+-- Subtract 61 seconds
+mysql> select date_sub('2023-12-31 23:59:59', INTERVAL 61 SECOND);
++-----------------------------------------------------+
+| date_sub('2023-12-31 23:59:59', INTERVAL 61 SECOND) |
++-----------------------------------------------------+
+| 2023-12-31 23:58:58 |
++-----------------------------------------------------+
+
+-- Subtract quarters
+mysql> select date_sub('2023-12-31 23:59:59', INTERVAL 61 QUARTER);
++------------------------------------------------------+
+| date_sub('2023-12-31 23:59:59', INTERVAL 61 QUARTER) |
++------------------------------------------------------+
+| 2008-09-30 23:59:59 |
++------------------------------------------------------+
+
+-- Example of TimeStampTz type, SET time_zone = '+08:00'
+SELECT DATE_SUB('2024-02-05 02:03:04.123+12:00', INTERVAL 1 DAY);
++-----------------------------------------------------------+
+| DATE_SUB('2024-02-05 02:03:04.123+12:00', INTERVAL 1 DAY) |
++-----------------------------------------------------------+
+| 2024-02-03 22:03:04.123+08:00 |
++-----------------------------------------------------------+
+
+-- Any parameter is NULL
+mysql> select date_sub('2023-01-01', INTERVAL NULL DAY);
++-------------------------------------------+
+| date_sub('2023-01-01', INTERVAL NULL DAY) |
++-------------------------------------------+
+| NULL |
++-------------------------------------------+
+
+
+-- For compound units, accept all non-numeric characters as separators.
+select DATE_SUB('2025-10-23 10:10:10', INTERVAL ' *1@#$2' DAY_HOUR);
++----------------------------------------------------------------+
+| DATE_SUB('2025-10-23 10:10:10', INTERVAL ' *1@#$2' DAY_HOUR) |
++----------------------------------------------------------------+
+| 2025-10-22 08:10:10 |
++----------------------------------------------------------------+
+
+-- For composite units, the sign of the time interval is determined only by whether the first non-digit character is `-`
+-- All subsequent `-` are considered part of the delimiter
+select
+ DATE_SUB('2025-10-23 10:10:10', INTERVAL '#-1:-1' MINUTE_SECOND) AS first_not_sub,
+ DATE_SUB('2025-10-23 10:10:10', INTERVAL ' -1:1' MINUTE_SECOND) AS first_sub;
++---------------------+---------------------+
+| first_not_sub | first_sub |
++---------------------+---------------------+
+| 2025-10-23 10:09:09 | 2025-10-23 10:11:11 |
++---------------------+---------------------+
+
+-- For composite units, if the input time interval is too short, the value of the larger unit will be set to 0.
+select DATE_SUB('2025-10-23 10:10:10', INTERVAL '1' MINUTE_SECOND) AS minute_interval_is_zero
++-------------------------+
... 4881 lines suppressed ...
---------------------------------------------------------------------
To unsubscribe, e-mail: commits-unsubscribe@doris.apache.org
For additional commands, e-mail: commits-help@doris.apache.org