Repository: ydb-platform/ydb
Pull request #17498: Select
Author: login: dennnniska
Labels: name: not-for-changelog
Created: 2025-04-21T15:08:30Z | Merged: 2025-05-21T14:17:39Z

### Changelog entry <!-- a user-readable short description of the changes that goes to CHANGELOG.md and Release Notes -->

были написаны тесты для [select](https://ydb.tech/docs/ru/yql/reference/syntax/select/#podderzhivaemye-konstrukcii-v-select) 

### Changelog category <!-- remove all except one -->

* Not for changelog (changelog entry is not required)

### Description for reviewers <!-- (optional) description for those who read this PR -->

https://github.com/ydb-platform/ydb/issues/14991



Diff:
diff --git a/ydb/tests/datashard/select/test_select.py b/ydb/tests/datashard/select/test_select.py
new file mode 100644
index 000000000000..322a6d3f8f71
--- /dev/null
+++ b/ydb/tests/datashard/select/test_select.py
@@ -0,0 +1,408 @@
+import pytest
+
+from ydb.tests.sql.lib.test_base import TestBase
+from ydb.tests.datashard.lib.dml_operations import DMLOperations
+from ydb.tests.datashard.lib.types_of_variables import (
+    cleanup_type_name,
+    format_sql_value,
+    pk_types,
+    non_pk_types,
+    index_first,
+    index_second,
+    ttl_types,
+    index_first_sync,
+    index_second_sync,
+    index_three_sync,
+    index_three_sync_not_Bool,
+    index_four_sync,
+    index_zero_sync,
+)
+
+unsuppored_time_types = [
+    "Date32",
+    "Datetime64",
+    "Timestamp64",
+    "Interval64",
+]  # https://github.com/ydb-platform/ydb/issues/16930
+unsuppored_distinct_types = [
+    "DyNumber",
+    "UUID",  # https://github.com/ydb-platform/ydb/issues/17484
+]
+uncomparable_types = ["Json", "JsonDocument", "Yson"]
+
+
+class TestDML(TestBase):
+    @pytest.mark.parametrize(
+        "table_name, pk_types, all_types, index, ttl, unique, sync",
+        [
+            ("table_index_4_UNIQUE_SYNC", pk_types, {}, index_four_sync, "", "UNIQUE", "SYNC"),
+            ("table_index_3_UNIQUE_SYNC", pk_types, {}, index_three_sync_not_Bool, "", "UNIQUE", "SYNC"),
+            ("table_index_2_UNIQUE_SYNC", pk_types, {}, index_second_sync, "", "UNIQUE", "SYNC"),
+            ("table_index_1_UNIQUE_SYNC", pk_types, {}, index_first_sync, "", "UNIQUE", "SYNC"),
+            ("table_index_0_UNIQUE_SYNC", pk_types, {}, index_zero_sync, "", "UNIQUE", "SYNC"),
+            ("table_index_4__SYNC", pk_types, {}, index_four_sync, "", "", "SYNC"),
+            ("table_index_3__SYNC", pk_types, {}, index_three_sync, "", "", "SYNC"),
+            ("table_index_2__SYNC", pk_types, {}, index_second_sync, "", "", "SYNC"),
+            ("table_index_1__SYNC", pk_types, {}, index_first_sync, "", "", "SYNC"),
+            ("table_index_0__SYNC", pk_types, {}, index_zero_sync, "", "", "SYNC"),
+            ("table_index_1__ASYNC", pk_types, {}, index_second, "", "", "ASYNC"),
+            ("table_index_0__ASYNC", pk_types, {}, index_first, "", "", "ASYNC"),
+            ("table_all_types", pk_types, {**pk_types, **non_pk_types}, {}, "", "", ""),
+            ("table_ttl_DyNumber", pk_types, {}, {}, "DyNumber", "", ""),
+            ("table_ttl_Uint32", pk_types, {}, {}, "Uint32", "", ""),
+            ("table_ttl_Uint64", pk_types, {}, {}, "Uint64", "", ""),
+            ("table_ttl_Datetime", pk_types, {}, {}, "Datetime", "", ""),
+            ("table_ttl_Timestamp", pk_types, {}, {}, "Timestamp", "", ""),
+            ("table_ttl_Date", pk_types, {}, {}, "Date", "", ""),
+        ],
+    )
+    def test_select(
+        self,
+        table_name: str,
+        pk_types: dict[str, str],
+        all_types: dict[str, str],
+        index: dict[str, str],
+        ttl: str,
+        unique: str,
+        sync: str,
+    ):
+        dml = DMLOperations(self)
+        dml.create_table(table_name, pk_types, all_types, index, ttl, unique, sync)
+        dml.insert(table_name, all_types, pk_types, index, ttl)
+        self.select_with(table_name, all_types, pk_types, index, ttl, dml)
+        self.order_by(table_name, all_types, pk_types, index, ttl, dml)
+        self.limit(table_name, all_types, pk_types, index, ttl, dml)
+        self.from_select(table_name, all_types, pk_types, index, ttl, dml)
+        self.distinct(table_name, all_types, pk_types, index, ttl, dml)
+        self.union(table_name, all_types, pk_types, index, ttl, dml)
+        self.without(table_name, all_types, pk_types, index, ttl)
+        self.tablesample_sample(table_name, all_types, pk_types, index, ttl, dml)
+
+    def limit(
+        self,
+        table_name: str,
+        all_types: dict[str, str],
+        pk_types: dict[str, str],
+        index: dict[str, str],
+        ttl: str,
+        dml: DMLOperations,
+    ):
+        selected_columns = self.create_types_for_all_select(all_types, pk_types, index, ttl)
+
+        number_of_columns = self.get_number_of_columns(pk_types, all_types, index, ttl)
+
+        for offset in range(number_of_columns):
+            rows = self.query(f"select {", ".join(selected_columns)} from {table_name} limit 1 OFFSET {offset}")
+            self.assert_type_after_select(offset + 1, rows[0], all_types, pk_types, index, ttl, dml)
+
+    def create_types_for_all_select(
+        self, all_types: dict[str, str], pk_types: dict[str, str], index: dict[str, str], ttl: str
+    ):
+        selected_columns = []
+        for type in all_types.keys():
+            if type not in unsuppored_time_types:
+                selected_columns.append(f"col_{cleanup_type_name(type)}")
+        for type in pk_types.keys():
+            if type not in unsuppored_time_types:
+                selected_columns.append(f"pk_{cleanup_type_name(type)}")
+        for type in index.keys():
+            if type not in unsuppored_time_types:
+                selected_columns.append(f"col_index_{cleanup_type_name(type)}")
+        if ttl != "":
+            selected_columns.append(f"ttl_{cleanup_type_name(ttl)}")
+        return selected_columns
+
+    def assert_type_after_select(
+        self,
+        value,
+        row,
+        all_types: dict[str, str],
+        pk_types: dict[str, str],
+        index: dict[str, str],
+        ttl: str,
+        dml: DMLOperations,
+    ):
+        col_idx = 0
+        for type in all_types.keys():
+            if type not in unsuppored_time_types:
+                dml.assert_type(all_types, type, value, row[col_idx])
+                col_idx += 1
+        for type in pk_types.keys():
+            if type not in unsuppored_time_types:
+                dml.assert_type(pk_types, type, value, row[col_idx])
+                col_idx += 1
+        for type in index.keys():
+            if type not in unsuppored_time_types:
+                dml.assert_type(index, type, value, row[col_idx])
+                col_idx += 1
+        if ttl != "":
+            dml.assert_type(ttl_types, ttl, value, row[col_idx])
+            col_idx += 1
+
+    def from_select(
+        self,
+        table_name: str,
+        all_types: dict[str, str],
+        pk_types: dict[str, str],
+        index: dict[str, str],
+        ttl: str,
+        dml: DMLOperations,
+    ):
+        selected_columns = self.create_types_for_all_select(all_types, pk_types, index, ttl)
+
+        rows = self.query(f"from {table_name} select {", ".join(selected_columns)}")
+        for i, row in enumerate(rows):
+            self.assert_type_after_select(i + 1, row, all_types, pk_types, index, ttl, dml)
+
+    def distinct(
+        self,
+        table_name: str,
+        all_types: dict[str, str],
+        pk_types: dict[str, str],
+        index: dict[str, str],
+        ttl: str,
+        dml: DMLOperations,
+    ):
+        for type in all_types.keys():
+            if (
+                type not in unsuppored_time_types
+                and type not in unsuppored_distinct_types
+                and type not in uncomparable_types
+            ):
+                rows_distinct = self.query(f"SELECT DISTINCT col_{cleanup_type_name(type)} from {table_name}")
+                for i in range(len(rows_distinct)):
+                    dml.assert_type(all_types, type, i + 1, rows_distinct[i][0])
+        for type in pk_types.keys():
+            if type not in unsuppored_time_types and type not in unsuppored_distinct_types:
+                rows_distinct = self.query(f"SELECT DISTINCT pk_{cleanup_type_name(type)} from {table_name}")
+                for i in range(len(rows_distinct)):
+                    dml.assert_type(pk_types, type, i + 1, rows_distinct[i][0])
+        for type in index.keys():
+            if type not in unsuppored_time_types and type not in unsuppored_distinct_types:
+                rows_distinct = self.query(f"SELECT DISTINCT col_index_{cleanup_type_name(type)} from {table_name}")
+                for i in range(len(rows_distinct)):
+                    dml.assert_type(index, type, i + 1, rows_distinct[i][0])
+        if ttl != "" and ttl != "DyNumber":
+            rows_distinct = self.query(f"SELECT DISTINCT ttl_{cleanup_type_name(ttl)} from {table_name}")
+            for i in range(len(rows_distinct)):
+                dml.assert_type(ttl_types, ttl, i + 1, rows_distinct[i][0])
+
+    def union(
+        self,
+        table_name: str,
+        all_types: dict[str, str],
+        pk_types: dict[str, str],
+        index: dict[str, str],
+        ttl: str,
+        dml: DMLOperations,
+    ):
+        selected_columns = []
+        for type in all_types.keys():
+            if (
+                type not in unsuppored_time_types
+                and type not in unsuppored_distinct_types
+                and type not in uncomparable_types
+            ):
+                selected_columns.append(f"col_{cleanup_type_name(type)}")
+        for type in pk_types.keys():
+            if type not in unsuppored_time_types and type not in unsuppored_distinct_types:
+                selected_columns.append(f"pk_{cleanup_type_name(type)}")
+        for type in index.keys():
+            if type not in unsuppored_time_types and type not in unsuppored_distinct_types:
+                selected_columns.append(f"col_index_{cleanup_type_name(type)}")
+        if ttl != "" and ttl != "DyNumber":
+            selected_columns.append(f"ttl_{cleanup_type_name(ttl)}")
+        rows = self.query(
+            f"""
+                          select {", ".join(selected_columns)} from {table_name}
+                          union
+                          select {", ".join(selected_columns)} from {table_name}
+                          """
+        )
+        for type in all_types.keys():
+            if (
+                type not in unsuppored_time_types
+                and type not in unsuppored_distinct_types
+                and type not in uncomparable_types
+            ):
+                for line in range(len(rows)):
+                    dml.assert_type(all_types, type, line + 1, rows[line][f"col_{cleanup_type_name(type)}"])
+        for type in pk_types.keys():
+            if type not in unsuppored_time_types and type not in unsuppored_distinct_types:
+                for line in range(len(rows)):
+                    dml.assert_type(pk_types, type, line + 1, rows[line][f"pk_{cleanup_type_name(type)}"])
+        for type in index.keys():
+            if type not in unsuppored_time_types and type not in unsuppored_distinct_types:
+                for line in range(len(rows)):
+                    dml.assert_type(index, type, line + 1, rows[line][f"col_index_{cleanup_type_name(type)}"])
+        if ttl != "" and ttl != "DyNumber":
+            for line in range(len(rows)):
+                dml.assert_type(ttl_types, ttl, line + 1, rows[line][f"ttl_{cleanup_type_name(ttl)}"])
+
+    def select_with(
+        self,
+        table_name: str,
+        all_types: dict[str, str],
+        pk_types: dict[str, str],
+        index: dict[str, str],
+        ttl: str,
+        dml: DMLOperations,
+    ):
+        select_with_parameters = [
+            "INFER_SCHEMA",
+            "FORCE_INFER_SCHEMA",
+            "DIRECT_READ",
+            "INLINE",
+            "UNORDERED",
+            "XLOCK",
+            "IGNORETYPEV3",
+        ]
+        selected_columns = self.create_types_for_all_select(all_types, pk_types, index, ttl)
+        for select_with_parameter in select_with_parameters:
+            select_with_sql_request = f"""
+                select {", ".join(selected_columns)}
+                from {table_name}
+                with {select_with_parameter}
+            """
+            rows = dml.query(select_with_sql_request)
+            for i, row in enumerate(rows):
+                self.assert_type_after_select(i + 1, row, all_types, pk_types, index, ttl, dml)
+
+    def without(
+        self, table_name: str, all_types: dict[str, str], pk_types: dict[str, str], index: dict[str, str], ttl: str
+    ):
+        selected_columns_without = []
+        for type_name in all_types.keys():
+            if type_name in unsuppored_time_types:
+                selected_columns_without.append(f"col_{cleanup_type_name(type_name)}")
+        for type_name in pk_types.keys():
+            if type_name in unsuppored_time_types:
+                selected_columns_without.append(f"pk_{cleanup_type_name(type_name)}")
+        for type_name in index.keys():
+            if type_name in unsuppored_time_types:
+                selected_columns_without.append(f"col_index_{cleanup_type_name(type_name)}")
+
+        for type_name in all_types.keys():
+            if type_name not in unsuppored_time_types:
+                self.create_without(table_name, selected_columns_without, f"col_{cleanup_type_name(type_name)}")
+        for type_name in pk_types.keys():
+            if type_name not in unsuppored_time_types:
+                self.create_without(table_name, selected_columns_without, f"pk_{cleanup_type_name(type_name)}")
+        for type_name in index.keys():
+            if type_name not in unsuppored_time_types:
+                self.create_without(table_name, selected_columns_without, f"col_index_{cleanup_type_name(type_name)}")
+        if ttl != "":
+            self.create_without(table_name, selected_columns_without, f"ttl_{cleanup_type_name(ttl)}")
+
+    def create_without(self, table_name, selected_columns_without, without):
+        rows = self.query(f"select * without {", ".join(selected_columns_without)}, {without} from {table_name}")
+        for col_name in rows[0].keys():
+            assert col_name != without, f"a column {without} in the table {table_name} was not excluded"
+
+    def tablesample_sample(
+        self,
+        table_name: str,
+        all_types: dict[str, str],
+        pk_types: dict[str, str],
+        index: dict[str, str],
+        ttl: str,
+        dml: DMLOperations,
+    ):
+        selected_columns = self.create_types_for_all_select(all_types, pk_types, index, ttl)
+        for i in range(1, 100):
+            rows = self.query(f"select {", ".join(selected_columns)} from {table_name} TABLESAMPLE SYSTEM({i}.0)")
+            for _, row in enumerate(rows):
+                numb = row["pk_Int64"]
+                self.assert_type_after_select(numb, row, all_types, pk_types, index, ttl, dml)
+
+            rows = self.query(
+                f"select {", ".join(selected_columns)} from {table_name} TABLESAMPLE BERNOULLI({i}.0) REPEATABLE({i})"
+            )
+            for _, row in enumerate(rows):
+                numb = row["pk_Int64"]
+                self.assert_type_after_select(numb, row, all_types, pk_types, index, ttl, dml)
+
+            rows = self.query(f"select {", ".join(selected_columns)} from {table_name} SAMPLE 1.0 / {i}")
+            for _, row in enumerate(rows):
+                numb = row["pk_Int64"]
+                self.assert_type_after_select(numb, row, all_types, pk_types, index, ttl, dml)
+
+    def order_by(
+        self,
+        table_name: str,
+        all_types: dict[str, str],
+        pk_types: dict[str, str],
+        index: dict[str, str],
+        ttl: str,
+        dml: DMLOperations,
+    ):
+        count_rows = len(all_types) + len(pk_types) + len(index)
+        if ttl != "":
+            count_rows += 1
+        string_order = [(pk_types["String"](i), i) for i in range(1, count_rows + 1)]
+        string_order = sorted(string_order)
+        selected_columns = self.create_types_for_all_select(all_types, pk_types, index, ttl)
+        for statement in selected_columns:
+            if "Json" not in statement and "JsonDocument" not in statement and "Yson" not in statement:
+                rows = self.query(f"select {", ".join(selected_columns)} from {table_name} ORDER BY {statement} ASC")
+                if "String" not in statement and "Utf8" not in statement:
+                    for i, row in enumerate(rows):
+                        self.assert_type_after_select(i + 1, row, all_types, pk_types, index, ttl, dml)
+                else:
+                    for i, row in enumerate(rows):
+                        self.assert_type_after_select(string_order[i][1], row, all_types, pk_types, index, ttl, dml)
+
+                rows = self.query(f"select {", ".join(selected_columns)} from {table_name} ORDER BY {statement} DESC")
+                string_order.reverse()
+                if "Bool" not in statement:
+                    if "String" not in statement and "Utf8" not in statement:
+                        for line, row in enumerate(rows):
+                            self.assert_type_after_select(len(rows) - line, row, all_types, pk_types, index, ttl, dml)
+                    else:
+                        for i, row in enumerate(rows):
+                            self.assert_type_after_select(string_order[i][1], row, all_types, pk_types, index, ttl, dml)
+                else:
+                    for i, row in enumerate(rows):
+                        self.assert_type_after_select(i + 1, row, all_types, pk_types, index, ttl, dml)
+                string_order.reverse()
+
+    def get_number_of_columns(self, pk_types, all_types, index, ttl):
+        number_of_columns = len(pk_types) + len(all_types) + len(index)
+
+        if ttl != "":
+            number_of_columns += 1
+        return number_of_columns
+
+    def test_as_table(self):
+        dml = DMLOperations(self)
+        all_types = {**pk_types, **non_pk_types}
+        statements = []
+        for type_name in all_types.keys():
+            if type_name not in unsuppored_time_types:
+                statements.append(
+                    f"{format_sql_value(all_types[type_name](1), type_name)} AS pk_{cleanup_type_name(type_name)}"
+                )
+        list_sql = f"""
+            $data = AsList(
+                AsStruct({", ".join(statements)})
+                );
+        """
+        rows = self.query(
+            f"""
+                   {list_sql}
+                   select * from AS_TABLE($data);
+                   """
+        )
+        for type_name in all_types.keys():
+            if (
+                type_name != "Date32"
+                and type_name != "Datetime64"
+                and type_name != "Timestamp64"
+                and type_name != 'Interval64'
+            ):
+                if type_name == "Utf8":
+                    dml.assert_type(
+                        all_types, type_name, 1, rows[0][f"pk_{cleanup_type_name(type_name)}"].decode("utf-8")
+                    )
+                else:
+                    dml.assert_type(all_types, type_name, 1, rows[0][f"pk_{cleanup_type_name(type_name)}"])
diff --git a/ydb/tests/datashard/select/ya.make b/ydb/tests/datashard/select/ya.make
new file mode 100644
index 000000000000..bccecd161092
--- /dev/null
+++ b/ydb/tests/datashard/select/ya.make
@@ -0,0 +1,24 @@
+PY3TEST()
+ENV(YDB_DRIVER_BINARY="ydb/apps/ydbd/ydbd")
+
+FORK_SUBTESTS()
+SPLIT_FACTOR(45)
+
+SIZE(MEDIUM)
+
+TEST_SRCS(
+    test_select.py
+
+)
+
+PEERDIR(
+    ydb/tests/datashard/lib
+    ydb/tests/sql/lib
+)
+
+DEPENDS(
+    ydb/apps/ydb
+    ydb/apps/ydbd
+)
+
+END()
diff --git a/ydb/tests/datashard/ya.make b/ydb/tests/datashard/ya.make
index 529f885bbff2..74a2a0674a17 100644
--- a/ydb/tests/datashard/ya.make
+++ b/ydb/tests/datashard/ya.make
@@ -6,6 +6,7 @@ RECURSE(
     lib
     partitioning
     parametrized_queries
+    select
     split_merge
     secondary_index
     s3


Reviews:
user: login: copilot-pull-request-reviewer[bot]
body: ## Pull Request Overview

This PR adds comprehensive tests for the SELECT functionality in YDB.  
- Introduces a new test file for SELECT statements with various constructs including ORDER BY, DISTINCT, UNION, and TABLESAMPLE.  
- Implements parameterized tests and helper functions to validate query results and type assertions.

<details>
<summary>Files not reviewed (2)</summary>

* **ydb/tests/datashard/select/ya.make**: Language not supported
* **ydb/tests/datashard/ya.make**: Language not supported
</details>

<details>
<summary>Comments suppressed due to low confidence (1)</summary>

**ydb/tests/datashard/select/test_select.py:90**
* Avoid using 'type' as a loop variable since it shadows the built-in function. Consider renaming it to a less ambiguous name like 'data_type'.
```
for type in all_types.keys():
```
</details>


state: COMMENTED
author_association: CONTRIBUTOR
submitted_at: 2025-04-24T16:07:03Z
user: login: lex007in
state: COMMENTED
author_association: COLLABORATOR
submitted_at: 2025-05-16T14:11:25Z
user: login: dennnniska
state: COMMENTED
author_association: CONTRIBUTOR
submitted_at: 2025-05-18T12:53:34Z
user: login: dennnniska
state: COMMENTED
author_association: CONTRIBUTOR
submitted_at: 2025-05-18T12:53:42Z
user: login: dennnniska
state: COMMENTED
author_association: CONTRIBUTOR
submitted_at: 2025-05-18T12:54:11Z
user: login: dennnniska
state: COMMENTED
author_association: CONTRIBUTOR
submitted_at: 2025-05-19T08:21:55Z
user: login: dennnniska
state: COMMENTED
author_association: CONTRIBUTOR
submitted_at: 2025-05-19T09:15:10Z
user: login: lex007in
state: COMMENTED
author_association: COLLABORATOR
submitted_at: 2025-05-20T14:47:35Z
user: login: dennnniska
state: COMMENTED
author_association: CONTRIBUTOR
submitted_at: 2025-05-20T15:39:45Z
user: login: dennnniska
state: COMMENTED
author_association: CONTRIBUTOR
submitted_at: 2025-05-20T15:39:53Z
user: login: lex007in
state: APPROVED
author_association: COLLABORATOR
submitted_at: 2025-05-21T14:16:57Z

Review comments:
diff_hunk: @@ -0,0 +1,328 @@
+import pytest
+
+from ydb.tests.sql.lib.test_base import TestBase
+from ydb.tests.datashard.lib.dml_operations import DMLOperations
+from ydb.tests.datashard.lib.types_of_variables import cleanup_type_name, format_sql_value, pk_types, non_pk_types, index_first, index_second, ttl_types, \
+    index_first_sync, index_second_sync, index_three_sync, index_three_sync_not_Bool, index_four_sync, index_zero_sync
+
+"""
+FROM AS_TABLE +
+FROM SELECT +
+DISTINCT +
+UNIQUE DISTINCT does not work
+UNION +
+WITH -
+WITHOUT +
+WHERE DMLOperations+
+ORDER BY +
+ASSUME ORDER BY -
+LIMIT OFFSET +
+SAMPLE +
+TABLESAMPLE +
+"""
+
+
+class TestDML(TestBase):
+    @pytest.mark.parametrize(
+        "table_name, pk_types, all_types, index, ttl, unique, sync",
+        [
+            ("table_index_4_UNIQUE_SYNC", pk_types, {},
+             index_four_sync, "", "UNIQUE", "SYNC"),
+            ("table_index_3_UNIQUE_SYNC", pk_types, {},
+             index_three_sync_not_Bool, "", "UNIQUE", "SYNC"),
+            ("table_index_2_UNIQUE_SYNC", pk_types, {},
+             index_second_sync, "", "UNIQUE", "SYNC"),
+            ("table_index_1_UNIQUE_SYNC", pk_types, {},
+             index_first_sync, "", "UNIQUE", "SYNC"),
+            ("table_index_0_UNIQUE_SYNC", pk_types, {},
+             index_zero_sync, "", "UNIQUE", "SYNC"),
+            ("table_index_4__SYNC", pk_types, {},
+             index_four_sync, "", "", "SYNC"),
+            ("table_index_3__SYNC", pk_types, {},
+             index_three_sync, "", "", "SYNC"),
+            ("table_index_2__SYNC", pk_types, {},
+             index_second_sync, "", "", "SYNC"),
+            ("table_index_1__SYNC", pk_types, {},
+             index_first_sync, "", "", "SYNC"),
+            ("table_index_0__SYNC", pk_types, {},
+             index_zero_sync, "", "", "SYNC"),
+            ("table_index_1__ASYNC", pk_types, {}, index_second, "", "", "ASYNC"),
+            ("table_index_0__ASYNC", pk_types, {}, index_first, "", "", "ASYNC"),
+            ("table_all_types", pk_types, {
+             **pk_types, **non_pk_types}, {}, "", "", ""),
+            ("table_ttl_DyNumber", pk_types, {}, {}, "DyNumber", "", ""),
+            ("table_ttl_Uint32", pk_types, {}, {}, "Uint32", "", ""),
+            ("table_ttl_Uint64", pk_types, {}, {}, "Uint64", "", ""),
+            ("table_ttl_Datetime", pk_types, {}, {}, "Datetime", "", ""),
+            ("table_ttl_Timestamp", pk_types, {}, {}, "Timestamp", "", ""),
+            ("table_ttl_Date", pk_types, {}, {}, "Date", "", ""),
+        ]
+    )
+    def test_select(self, table_name: str, pk_types: dict[str, str], all_types: dict[str, str], index: dict[str, str], ttl: str, unique: str, sync: str):
+        dml = DMLOperations(self)
+        dml.create_table(table_name, pk_types, all_types,
+                         index, ttl, unique, sync)
+        dml.insert(table_name, all_types, pk_types, index, ttl)
+        self.order_by(table_name, all_types, pk_types, index, ttl, dml)
+        self.limit(table_name, all_types, pk_types, index, ttl, dml)
+        self.from_select(table_name, all_types, pk_types, index, ttl, dml)
+        self.distinct(table_name, all_types, pk_types, index, ttl, dml)
+        self.union(table_name, all_types, pk_types, index, ttl, dml)
+        self.without(table_name, all_types, pk_types, index, ttl)
+        self.tablesample_sample(table_name, all_types,
+                                pk_types, index, ttl, dml)
+
+    def limit(self, table_name: str, all_types: dict[str, str], pk_types: dict[str, str], index: dict[str, str], ttl: str, dml: DMLOperations):
+        statements = self.create_types_for_all_select(
+            all_types, pk_types, index, ttl)
+
+        number_of_columns = self.get_number_of_columns(
+            pk_types, all_types, index, ttl)
+
+        for offset in range(number_of_columns):
+            rows = self.query(f"select {", ".join(statements)} from {table_name} limit 1 OFFSET {offset}")
+            self.assert_type_after_select(
+                offset+1, 0, rows, all_types, pk_types, index, ttl, dml)
+
+    def create_types_for_all_select(self, all_types: dict[str, str], pk_types: dict[str, str], index: dict[str, str], ttl: str):
+        statements = []
+        # delete if after https://github.com/ydb-platform/ydb/issues/16930
+        for type in all_types.keys():
+            if type != "Date32" and type != "Datetime64" and type != "Timestamp64" and type != 'Interval64':
+                statements.append(f"col_{cleanup_type_name(type)}")
+        for type in pk_types.keys():
+            if type != "Date32" and type != "Datetime64" and type != "Timestamp64" and type != 'Interval64':
+                statements.append(f"pk_{cleanup_type_name(type)}")
+        for type in index.keys():
+            if type != "Date32" and type != "Datetime64" and type != "Timestamp64" and type != 'Interval64':
+                statements.append(f"col_index_{cleanup_type_name(type)}")
+        if ttl != "":
+            statements.append(f"ttl_{cleanup_type_name(ttl)}")
+        return statements
+
+    def assert_type_after_select(self, value, line, rows, all_types: dict[str, str], pk_types: dict[str, str], index: dict[str, str], ttl: str, dml: DMLOperations):
+        count = 0
+        for type in all_types.keys():
+            if type != "Date32" and type != "Datetime64" and type != "Timestamp64" and type != 'Interval64':
+                dml.assert_type(all_types, type, value, rows[line][count])
+                count += 1
+        for type in pk_types.keys():
+            if type != "Date32" and type != "Datetime64" and type != "Timestamp64" and type != 'Interval64':
+                dml.assert_type(pk_types, type, value, rows[line][count])
+                count += 1
+        for type in index.keys():
+            if type != "Date32" and type != "Datetime64" and type != "Timestamp64" and type != 'Interval64':
+                dml.assert_type(index, type, value, rows[line][count])
+                count += 1
+        if ttl != "":
+            dml.assert_type(ttl_types, ttl, value, rows[line][count])
+            count += 1
+
+    def from_select(self, table_name: str, all_types: dict[str, str], pk_types: dict[str, str], index: dict[str, str], ttl: str, dml: DMLOperations):
+        statements = self.create_types_for_all_select(
+            all_types, pk_types, index, ttl)
+
+        rows = self.query(f"from {table_name} select {", ".join(statements)}")
+        for i in range(len(rows)):
+            self.assert_type_after_select(
+                i+1, i, rows, all_types, pk_types, index, ttl, dml)
+
+    def distinct(self, table_name: str, all_types: dict[str, str], pk_types: dict[str, str], index: dict[str, str], ttl: str, dml: DMLOperations):
+        # del type != "DyNumber" and type != "UUID" after https://github.com/ydb-platform/ydb/issues/17484
+        for type in all_types.keys():
+            if type != "Date32" and type != "Datetime64" and type != "Timestamp64" and type != 'Interval64'\
+                    and type != "DyNumber" and type != "UUID" and type != "Json" and type != "JsonDocument" and type != "Yson":
+                rows_distinct = self.query(
+                    f"SELECT DISTINCT col_{cleanup_type_name(type)} from {table_name}")
+                for i in range(len(rows_distinct)):
+                    dml.assert_type(all_types, type, i+1, rows_distinct[i][0])
+        for type in pk_types.keys():
+            if type != "Date32" and type != "Datetime64" and type != "Timestamp64" and type != 'Interval64' and type != "DyNumber" and type != "UUID":
+                rows_distinct = self.query(
+                    f"SELECT DISTINCT pk_{cleanup_type_name(type)} from {table_name}")
+                for i in range(len(rows_distinct)):
+                    dml.assert_type(pk_types, type, i+1, rows_distinct[i][0])
+        for type in index.keys():
+            if type != "Date32" and type != "Datetime64" and type != "Timestamp64" and type != 'Interval64' and type != "DyNumber" and type != "UUID":
+                rows_distinct = self.query(
+                    f"SELECT DISTINCT col_index_{cleanup_type_name(type)} from {table_name}")
+                for i in range(len(rows_distinct)):
+                    dml.assert_type(index, type, i+1, rows_distinct[i][0])
+        if ttl != "" and ttl != "DyNumber":
+            rows_distinct = self.query(
+                f"SELECT DISTINCT ttl_{cleanup_type_name(ttl)} from {table_name}")
+            for i in range(len(rows_distinct)):
+                dml.assert_type(ttl_types, ttl, i+1, rows_distinct[i][0])
+
+    def union(self, table_name: str, all_types: dict[str, str], pk_types: dict[str, str], index: dict[str, str], ttl: str, dml: DMLOperations):
+        statements = []
+        for type in all_types.keys():
+            if type != "Date32" and type != "Datetime64" and type != "Timestamp64" and type != 'Interval64'\
+                    and type != "DyNumber" and type != "UUID" and type != "Json" and type != "JsonDocument" and type != "Yson":
+                statements.append(f"col_{cleanup_type_name(type)}")
+        for type in pk_types.keys():
+            if type != "Date32" and type != "Datetime64" and type != "Timestamp64" and type != 'Interval64' and type != "DyNumber" and type != "UUID":
+                statements.append(f"pk_{cleanup_type_name(type)}")
+        for type in index.keys():
+            if type != "Date32" and type != "Datetime64" and type != "Timestamp64" and type != 'Interval64' and type != "DyNumber" and type != "UUID":
+                statements.append(f"col_index_{cleanup_type_name(type)}")
+        if ttl != "" and ttl != "DyNumber":
+            statements.append(f"ttl_{cleanup_type_name(ttl)}")
+        rows = self.query(f"""
+                          select {", ".join(statements)} from {table_name}
+                          union
+                          select {", ".join(statements)} from {table_name}
+                          """)
+        for type in all_types.keys():
+            if type != "Date32" and type != "Datetime64" and type != "Timestamp64" and type != 'Interval64'\
+                    and type != "DyNumber" and type != "UUID" and type != "Json" and type != "JsonDocument" and type != "Yson":
+                for line in range(len(rows)):
+                    dml.assert_type(all_types, type, line+1,
+                                    rows[line][f"col_{cleanup_type_name(type)}"])
+        for type in pk_types.keys():
+            if type != "Date32" and type != "Datetime64" and type != "Timestamp64" and type != 'Interval64' and type != "DyNumber" and type != "UUID":
+                for line in range(len(rows)):
+                    dml.assert_type(pk_types, type, line+1,
+                                    rows[line][f"pk_{cleanup_type_name(type)}"])
+        for type in index.keys():
+            if type != "Date32" and type != "Datetime64" and type != "Timestamp64" and type != 'Interval64' and type != "DyNumber" and type != "UUID":
+                for line in range(len(rows)):
+                    dml.assert_type(
+                        index, type, line+1, rows[line][f"col_index_{cleanup_type_name(type)}"])
+        if ttl != "" and ttl != "DyNumber":
+            for line in range(len(rows)):
+                dml.assert_type(ttl_types, ttl, line+1,
+                                rows[line][f"ttl_{cleanup_type_name(ttl)}"])
+
+    def without(self, table_name: str, all_types: dict[str, str], pk_types: dict[str, str], index: dict[str, str], ttl: str):
+        statements_without = []
+        for type_name in all_types.keys():
+            if type_name == "Date32" or type_name == "Datetime64" or type_name == "Timestamp64" or type_name == 'Interval64':
+                statements_without.append(
+                    f"col_{cleanup_type_name(type_name)}")
+        for type_name in pk_types.keys():
+            if type_name == "Date32" or type_name == "Datetime64" or type_name == "Timestamp64" or type_name == 'Interval64':
+                statements_without.append(f"pk_{cleanup_type_name(type_name)}")
+        for type_name in index.keys():
+            if type_name == "Date32" or type_name == "Datetime64" or type_name == "Timestamp64" or type_name == 'Interval64':
+                statements_without.append(
+                    f"col_index_{cleanup_type_name(type_name)}")
+
+        for type_name in all_types.keys():
+            if type_name != "Date32" and type_name != "Datetime64" and type_name != "Timestamp64" and type_name != 'Interval64':
+                self.create_without(
+                    table_name, statements_without, f"col_{cleanup_type_name(type_name)}")
+        for type_name in pk_types.keys():
+            if type_name != "Date32" and type_name != "Datetime64" and type_name != "Timestamp64" and type_name != 'Interval64':
+                self.create_without(
+                    table_name, statements_without, f"pk_{cleanup_type_name(type_name)}")
+        for type_name in index.keys():
+            if type_name != "Date32" and type_name != "Datetime64" and type_name != "Timestamp64" and type_name != 'Interval64':
+                self.create_without(
+                    table_name, statements_without, f"col_index_{cleanup_type_name(type_name)}")
+        if ttl != "":
+            self.create_without(table_name, statements_without,
+                                f"ttl_{cleanup_type_name(ttl)}")
+
+    def create_without(self, table_name, statements_without, without):
+        rows = self.query(f"select * without {", ".join(statements_without)}, {without} from {table_name}")
+        for col_name in rows[0].keys():
+            assert col_name != without, f"a column {without} in the table {table_name} was not excluded"
+
+    def tablesample_sample(self, table_name: str, all_types: dict[str, str], pk_types: dict[str, str], index: dict[str, str], ttl: str, dml: DMLOperations):
+        statements = self.create_types_for_all_select(
+            all_types, pk_types, index, ttl)
+        for i in range(1, 100):
+            rows = self.query(f"select {", ".join(statements)} from {table_name} TABLESAMPLE SYSTEM({i}.0)")
+            for line in range(len(rows)):
+                numb = rows[line]["pk_Int64"]
+                self.assert_type_after_select(
+                    numb, line, rows, all_types, pk_types, index, ttl, dml)
+
+            rows = self.query(f"select {", ".join(statements)} from {table_name} TABLESAMPLE BERNOULLI({i}.0) REPEATABLE({i})")
+            for line in range(len(rows)):
+                numb = rows[line]["pk_Int64"]
+                self.assert_type_after_select(
+                    numb, line, rows, all_types, pk_types, index, ttl, dml)
+
+            rows = self.query(f"select {", ".join(statements)} from {table_name} SAMPLE 1.0 / {i}")
+            for line in range(len(rows)):
+                numb = rows[line]["pk_Int64"]
+                self.assert_type_after_select(
+                    numb, line, rows, all_types, pk_types, index, ttl, dml)
+
+    def order_by(self, table_name: str, all_types: dict[str, str], pk_types: dict[str, str], index: dict[str, str], ttl: str, dml: DMLOperations):
+        statements = self.create_types_for_all_select(
+            all_types, pk_types, index, ttl)
+        for statement in statements:
+            if "Json" not in statement and "JsonDocument" not in statement and "Yson" not in statement:
+                rows = self.query(f"select {", ".join(statements)} from {table_name} ORDER BY {statement} ASC")
+                if "String" not in statement and "Utf8" not in statement:
+                    for line in range(len(rows)):
+                        self.assert_type_after_select(
+                            line + 1, line, rows, all_types, pk_types, index, ttl, dml)
+                else:
+                    line = 0
+                    for i in range(len(rows)//10):
+                        self.assert_type_after_select(
+                            i + 1, line, rows, all_types, pk_types, index, ttl, dml)
+                        line += 1
+                        for j in range(10):
+                            if (i+1) * 10 + j > len(rows):
+                                break
+                            self.assert_type_after_select(
+                                (i + 1) * 10 + j, line, rows, all_types, pk_types, index, ttl, dml)
+                            line += 1
+
+                rows = self.query(f"select {", ".join(statements)} from {table_name} ORDER BY {statement} DESC")
+
+                if "Bool" not in statement:
+                    if "String" not in statement and "Utf8" not in statement:
+                        for line in range(len(rows)):
+                            self.assert_type_after_select(
+                                len(rows) - line, line, rows, all_types, pk_types, index, ttl, dml)
+                    else:
+                        line = 0
+                        for i in range(len(rows)//10, 0):
path: ydb/tests/datashard/select/test_select.py
user: login: Copilot
body: The range in this loop will not produce any iterations because it lacks a negative step for descending iteration. If a descending order is intended, consider using range(len(rows)//10, 0, -1).
```suggestion
                        for i in range(len(rows)//10, 0, -1):
```
created_at: 2025-04-24T16:07:02Z
author_association: CONTRIBUTOR
diff_hunk: @@ -0,0 +1,509 @@
+import pytest
+
+from ydb.tests.sql.lib.test_base import TestBase
+from ydb.tests.datashard.lib.dml_operations import DMLOperations
+from ydb.tests.datashard.lib.types_of_variables import (
+    cleanup_type_name,
+    format_sql_value,
+    pk_types,
+    non_pk_types,
+    index_first,
+    index_second,
+    ttl_types,
+    index_first_sync,
+    index_second_sync,
+    index_three_sync,
+    index_three_sync_not_Bool,
+    index_four_sync,
+    index_zero_sync,
+)
+
+
+class TestDML(TestBase):
+    @pytest.mark.parametrize(
+        "table_name, pk_types, all_types, index, ttl, unique, sync",
+        [
+            ("table_index_4_UNIQUE_SYNC", pk_types, {},
+             index_four_sync, "", "UNIQUE", "SYNC"),
+            ("table_index_3_UNIQUE_SYNC", pk_types, {},
+             index_three_sync_not_Bool, "", "UNIQUE", "SYNC"),
+            ("table_index_2_UNIQUE_SYNC", pk_types, {},
+             index_second_sync, "", "UNIQUE", "SYNC"),
+            ("table_index_1_UNIQUE_SYNC", pk_types, {},
+             index_first_sync, "", "UNIQUE", "SYNC"),
+            ("table_index_0_UNIQUE_SYNC", pk_types, {},
+             index_zero_sync, "", "UNIQUE", "SYNC"),
+            ("table_index_4__SYNC", pk_types, {},
+             index_four_sync, "", "", "SYNC"),
+            ("table_index_3__SYNC", pk_types, {},
+             index_three_sync, "", "", "SYNC"),
+            ("table_index_2__SYNC", pk_types, {},
+             index_second_sync, "", "", "SYNC"),
+            ("table_index_1__SYNC", pk_types, {},
+             index_first_sync, "", "", "SYNC"),
+            ("table_index_0__SYNC", pk_types, {},
+             index_zero_sync, "", "", "SYNC"),
+            ("table_index_1__ASYNC", pk_types, {}, index_second, "", "", "ASYNC"),
+            ("table_index_0__ASYNC", pk_types, {}, index_first, "", "", "ASYNC"),
+            ("table_all_types", pk_types, {
+             **pk_types, **non_pk_types}, {}, "", "", ""),
+            ("table_ttl_DyNumber", pk_types, {}, {}, "DyNumber", "", ""),
+            ("table_ttl_Uint32", pk_types, {}, {}, "Uint32", "", ""),
+            ("table_ttl_Uint64", pk_types, {}, {}, "Uint64", "", ""),
+            ("table_ttl_Datetime", pk_types, {}, {}, "Datetime", "", ""),
+            ("table_ttl_Timestamp", pk_types, {}, {}, "Timestamp", "", ""),
+            ("table_ttl_Date", pk_types, {}, {}, "Date", "", ""),
+        ]
+    )
+    def test_select(self, table_name: str, pk_types: dict[str, str], all_types: dict[str, str], index: dict[str, str], ttl: str, unique: str, sync: str):
+        dml = DMLOperations(self)
+        dml.create_table(table_name, pk_types, all_types,
+                         index, ttl, unique, sync)
+        dml.insert(table_name, all_types, pk_types, index, ttl)
+        self.select_with(table_name, all_types, pk_types, index, ttl, dml)
+        self.order_by(table_name, all_types, pk_types, index, ttl, dml)
+        self.limit(table_name, all_types, pk_types, index, ttl, dml)
+        self.from_select(table_name, all_types, pk_types, index, ttl, dml)
+        self.distinct(table_name, all_types, pk_types, index, ttl, dml)
+        self.union(table_name, all_types, pk_types, index, ttl, dml)
+        self.without(table_name, all_types, pk_types, index, ttl)
+        self.tablesample_sample(table_name, all_types,
+                                pk_types, index, ttl, dml)
+
+    def limit(
+        self,
+        table_name: str,
+        all_types: dict[str, str],
+        pk_types: dict[str, str],
+        index: dict[str, str],
+        ttl: str,
+        dml: DMLOperations,
+    ):
+        statements = self.create_types_for_all_select(all_types, pk_types, index, ttl)
+
+        number_of_columns = self.get_number_of_columns(pk_types, all_types, index, ttl)
+
+        for offset in range(number_of_columns):
+            rows = self.query(f"select {", ".join(statements)} from {table_name} limit 1 OFFSET {offset}")
+            self.assert_type_after_select(offset + 1, 0, rows, all_types, pk_types, index, ttl, dml)
+
+    def create_types_for_all_select(
+        self, all_types: dict[str, str], pk_types: dict[str, str], index: dict[str, str], ttl: str
+    ):
+        statements = []
+        # delete if after https://github.com/ydb-platform/ydb/issues/16930
+        for type in all_types.keys():
+            if type != "Date32" and type != "Datetime64" and type != "Timestamp64" and type != 'Interval64':
+                statements.append(f"col_{cleanup_type_name(type)}")
+        for type in pk_types.keys():
+            if type != "Date32" and type != "Datetime64" and type != "Timestamp64" and type != 'Interval64':
+                statements.append(f"pk_{cleanup_type_name(type)}")
+        for type in index.keys():
+            if type != "Date32" and type != "Datetime64" and type != "Timestamp64" and type != 'Interval64':
+                statements.append(f"col_index_{cleanup_type_name(type)}")
+        if ttl != "":
+            statements.append(f"ttl_{cleanup_type_name(ttl)}")
+        return statements
+
+    def assert_type_after_select(
+        self,
+        value,
+        line,
+        rows,
+        all_types: dict[str, str],
+        pk_types: dict[str, str],
+        index: dict[str, str],
+        ttl: str,
+        dml: DMLOperations,
+    ):
+        count = 0
+        for type in all_types.keys():
+            if type != "Date32" and type != "Datetime64" and type != "Timestamp64" and type != 'Interval64':
+                dml.assert_type(all_types, type, value, rows[line][count])
+                count += 1
+        for type in pk_types.keys():
+            if type != "Date32" and type != "Datetime64" and type != "Timestamp64" and type != 'Interval64':
+                dml.assert_type(pk_types, type, value, rows[line][count])
path: ydb/tests/datashard/select/test_select.py
user: login: lex007in
body: > `rows[line][count]`

Возможно, чуть понятнее можно было назвать `rows[row_idx][col_idx]`
created_at: 2025-05-16T12:16:25Z
author_association: COLLABORATOR
diff_hunk: @@ -0,0 +1,509 @@
+import pytest
+
+from ydb.tests.sql.lib.test_base import TestBase
+from ydb.tests.datashard.lib.dml_operations import DMLOperations
+from ydb.tests.datashard.lib.types_of_variables import (
+    cleanup_type_name,
+    format_sql_value,
+    pk_types,
+    non_pk_types,
+    index_first,
+    index_second,
+    ttl_types,
+    index_first_sync,
+    index_second_sync,
+    index_three_sync,
+    index_three_sync_not_Bool,
+    index_four_sync,
+    index_zero_sync,
+)
+
+
+class TestDML(TestBase):
+    @pytest.mark.parametrize(
+        "table_name, pk_types, all_types, index, ttl, unique, sync",
+        [
+            ("table_index_4_UNIQUE_SYNC", pk_types, {},
+             index_four_sync, "", "UNIQUE", "SYNC"),
+            ("table_index_3_UNIQUE_SYNC", pk_types, {},
+             index_three_sync_not_Bool, "", "UNIQUE", "SYNC"),
+            ("table_index_2_UNIQUE_SYNC", pk_types, {},
+             index_second_sync, "", "UNIQUE", "SYNC"),
+            ("table_index_1_UNIQUE_SYNC", pk_types, {},
+             index_first_sync, "", "UNIQUE", "SYNC"),
+            ("table_index_0_UNIQUE_SYNC", pk_types, {},
+             index_zero_sync, "", "UNIQUE", "SYNC"),
+            ("table_index_4__SYNC", pk_types, {},
+             index_four_sync, "", "", "SYNC"),
+            ("table_index_3__SYNC", pk_types, {},
+             index_three_sync, "", "", "SYNC"),
+            ("table_index_2__SYNC", pk_types, {},
+             index_second_sync, "", "", "SYNC"),
+            ("table_index_1__SYNC", pk_types, {},
+             index_first_sync, "", "", "SYNC"),
+            ("table_index_0__SYNC", pk_types, {},
+             index_zero_sync, "", "", "SYNC"),
+            ("table_index_1__ASYNC", pk_types, {}, index_second, "", "", "ASYNC"),
+            ("table_index_0__ASYNC", pk_types, {}, index_first, "", "", "ASYNC"),
+            ("table_all_types", pk_types, {
+             **pk_types, **non_pk_types}, {}, "", "", ""),
+            ("table_ttl_DyNumber", pk_types, {}, {}, "DyNumber", "", ""),
+            ("table_ttl_Uint32", pk_types, {}, {}, "Uint32", "", ""),
+            ("table_ttl_Uint64", pk_types, {}, {}, "Uint64", "", ""),
+            ("table_ttl_Datetime", pk_types, {}, {}, "Datetime", "", ""),
+            ("table_ttl_Timestamp", pk_types, {}, {}, "Timestamp", "", ""),
+            ("table_ttl_Date", pk_types, {}, {}, "Date", "", ""),
+        ]
+    )
+    def test_select(self, table_name: str, pk_types: dict[str, str], all_types: dict[str, str], index: dict[str, str], ttl: str, unique: str, sync: str):
+        dml = DMLOperations(self)
+        dml.create_table(table_name, pk_types, all_types,
+                         index, ttl, unique, sync)
+        dml.insert(table_name, all_types, pk_types, index, ttl)
+        self.select_with(table_name, all_types, pk_types, index, ttl, dml)
+        self.order_by(table_name, all_types, pk_types, index, ttl, dml)
+        self.limit(table_name, all_types, pk_types, index, ttl, dml)
+        self.from_select(table_name, all_types, pk_types, index, ttl, dml)
+        self.distinct(table_name, all_types, pk_types, index, ttl, dml)
+        self.union(table_name, all_types, pk_types, index, ttl, dml)
+        self.without(table_name, all_types, pk_types, index, ttl)
+        self.tablesample_sample(table_name, all_types,
+                                pk_types, index, ttl, dml)
+
+    def limit(
+        self,
+        table_name: str,
+        all_types: dict[str, str],
+        pk_types: dict[str, str],
+        index: dict[str, str],
+        ttl: str,
+        dml: DMLOperations,
+    ):
+        statements = self.create_types_for_all_select(all_types, pk_types, index, ttl)
+
+        number_of_columns = self.get_number_of_columns(pk_types, all_types, index, ttl)
+
+        for offset in range(number_of_columns):
+            rows = self.query(f"select {", ".join(statements)} from {table_name} limit 1 OFFSET {offset}")
+            self.assert_type_after_select(offset + 1, 0, rows, all_types, pk_types, index, ttl, dml)
+
+    def create_types_for_all_select(
+        self, all_types: dict[str, str], pk_types: dict[str, str], index: dict[str, str], ttl: str
+    ):
+        statements = []
+        # delete if after https://github.com/ydb-platform/ydb/issues/16930
+        for type in all_types.keys():
+            if type != "Date32" and type != "Datetime64" and type != "Timestamp64" and type != 'Interval64':
+                statements.append(f"col_{cleanup_type_name(type)}")
+        for type in pk_types.keys():
+            if type != "Date32" and type != "Datetime64" and type != "Timestamp64" and type != 'Interval64':
+                statements.append(f"pk_{cleanup_type_name(type)}")
+        for type in index.keys():
+            if type != "Date32" and type != "Datetime64" and type != "Timestamp64" and type != 'Interval64':
+                statements.append(f"col_index_{cleanup_type_name(type)}")
+        if ttl != "":
+            statements.append(f"ttl_{cleanup_type_name(ttl)}")
+        return statements
+
+    def assert_type_after_select(
+        self,
+        value,
+        line,
+        rows,
+        all_types: dict[str, str],
+        pk_types: dict[str, str],
+        index: dict[str, str],
+        ttl: str,
+        dml: DMLOperations,
+    ):
+        count = 0
+        for type in all_types.keys():
+            if type != "Date32" and type != "Datetime64" and type != "Timestamp64" and type != 'Interval64':
+                dml.assert_type(all_types, type, value, rows[line][count])
+                count += 1
+        for type in pk_types.keys():
+            if type != "Date32" and type != "Datetime64" and type != "Timestamp64" and type != 'Interval64':
+                dml.assert_type(pk_types, type, value, rows[line][count])
+                count += 1
+        for type in index.keys():
+            if type != "Date32" and type != "Datetime64" and type != "Timestamp64" and type != 'Interval64':
+                dml.assert_type(index, type, value, rows[line][count])
+                count += 1
+        if ttl != "":
+            dml.assert_type(ttl_types, ttl, value, rows[line][count])
+            count += 1
+
+    def from_select(
+        self,
+        table_name: str,
+        all_types: dict[str, str],
+        pk_types: dict[str, str],
+        index: dict[str, str],
+        ttl: str,
+        dml: DMLOperations,
+    ):
+        statements = self.create_types_for_all_select(all_types, pk_types, index, ttl)
+
+        rows = self.query(f"from {table_name} select {", ".join(statements)}")
+        for i in range(len(rows)):
+            self.assert_type_after_select(i + 1, i, rows, all_types, pk_types, index, ttl, dml)
+
+    def distinct(
+        self,
+        table_name: str,
+        all_types: dict[str, str],
+        pk_types: dict[str, str],
+        index: dict[str, str],
+        ttl: str,
+        dml: DMLOperations,
+    ):
+        # del type != "DyNumber" and type != "UUID" after https://github.com/ydb-platform/ydb/issues/17484
+        for type in all_types.keys():
+            if (
+                type != "Date32"
+                and type != "Datetime64"
+                and type != "Timestamp64"
+                and type != 'Interval64'
+                and type != "DyNumber"
+                and type != "UUID"
+                and type != "Json"
+                and type != "JsonDocument"
+                and type != "Yson"
+            ):
+                rows_distinct = self.query(f"SELECT DISTINCT col_{cleanup_type_name(type)} from {table_name}")
+                for i in range(len(rows_distinct)):
+                    dml.assert_type(all_types, type, i + 1, rows_distinct[i][0])
+        for type in pk_types.keys():
+            if (
+                type != "Date32"
+                and type != "Datetime64"
+                and type != "Timestamp64"
+                and type != 'Interval64'
+                and type != "DyNumber"
+                and type != "UUID"
+            ):
+                rows_distinct = self.query(f"SELECT DISTINCT pk_{cleanup_type_name(type)} from {table_name}")
+                for i in range(len(rows_distinct)):
+                    dml.assert_type(pk_types, type, i + 1, rows_distinct[i][0])
+        for type in index.keys():
+            if (
+                type != "Date32"
+                and type != "Datetime64"
+                and type != "Timestamp64"
+                and type != 'Interval64'
+                and type != "DyNumber"
+                and type != "UUID"
+            ):
+                rows_distinct = self.query(f"SELECT DISTINCT col_index_{cleanup_type_name(type)} from {table_name}")
+                for i in range(len(rows_distinct)):
+                    dml.assert_type(index, type, i + 1, rows_distinct[i][0])
+        if ttl != "" and ttl != "DyNumber":
+            rows_distinct = self.query(f"SELECT DISTINCT ttl_{cleanup_type_name(ttl)} from {table_name}")
+            for i in range(len(rows_distinct)):
+                dml.assert_type(ttl_types, ttl, i + 1, rows_distinct[i][0])
+
+    def union(
+        self,
+        table_name: str,
+        all_types: dict[str, str],
+        pk_types: dict[str, str],
+        index: dict[str, str],
+        ttl: str,
+        dml: DMLOperations,
+    ):
+        statements = []
+        for type in all_types.keys():
+            if (
+                type != "Date32"
+                and type != "Datetime64"
+                and type != "Timestamp64"
+                and type != 'Interval64'
+                and type != "DyNumber"
+                and type != "UUID"
+                and type != "Json"
+                and type != "JsonDocument"
+                and type != "Yson"
+            ):
+                statements.append(f"col_{cleanup_type_name(type)}")
+        for type in pk_types.keys():
+            if (
+                type != "Date32"
+                and type != "Datetime64"
+                and type != "Timestamp64"
+                and type != 'Interval64'
+                and type != "DyNumber"
+                and type != "UUID"
+            ):
+                statements.append(f"pk_{cleanup_type_name(type)}")
+        for type in index.keys():
+            if (
+                type != "Date32"
+                and type != "Datetime64"
+                and type != "Timestamp64"
+                and type != 'Interval64'
+                and type != "DyNumber"
+                and type != "UUID"
+            ):
+                statements.append(f"col_index_{cleanup_type_name(type)}")
+        if ttl != "" and ttl != "DyNumber":
+            statements.append(f"ttl_{cleanup_type_name(ttl)}")
+        rows = self.query(
+            f"""
+                          select {", ".join(statements)} from {table_name}
+                          union
+                          select {", ".join(statements)} from {table_name}
+                          """
+        )
+        for type in all_types.keys():
+            if (
+                type != "Date32"
+                and type != "Datetime64"
+                and type != "Timestamp64"
+                and type != 'Interval64'
+                and type != "DyNumber"
+                and type != "UUID"
+                and type != "Json"
+                and type != "JsonDocument"
+                and type != "Yson"
+            ):
+                for line in range(len(rows)):
+                    dml.assert_type(all_types, type, line + 1, rows[line][f"col_{cleanup_type_name(type)}"])
+        for type in pk_types.keys():
+            if (
+                type != "Date32"
+                and type != "Datetime64"
+                and type != "Timestamp64"
+                and type != 'Interval64'
+                and type != "DyNumber"
+                and type != "UUID"
+            ):
+                for line in range(len(rows)):
+                    dml.assert_type(pk_types, type, line + 1, rows[line][f"pk_{cleanup_type_name(type)}"])
+        for type in index.keys():
+            if (
+                type != "Date32"
+                and type != "Datetime64"
+                and type != "Timestamp64"
+                and type != 'Interval64'
+                and type != "DyNumber"
+                and type != "UUID"
+            ):
+                for line in range(len(rows)):
+                    dml.assert_type(index, type, line + 1, rows[line][f"col_index_{cleanup_type_name(type)}"])
+        if ttl != "" and ttl != "DyNumber":
+            for line in range(len(rows)):
+                dml.assert_type(ttl_types, ttl, line + 1, rows[line][f"ttl_{cleanup_type_name(ttl)}"])
+
+    def select_with(
+        self,
+        table_name: str,
+        all_types: dict[str, str],
+        pk_types: dict[str, str],
+        index: dict[str, str],
+        ttl: str,
+        dml: DMLOperations,
+    ):
+        select_with_parameters = [
+            "INFER_SCHEMA",
+            "FORCE_INFER_SCHEMA",
+            "DIRECT_READ",
+            "INLINE",
+            "UNORDERED",
+            "XLOCK",
+            "IGNORETYPEV3",
+        ]
+        statements = self.create_types_for_all_select(all_types, pk_types, index, ttl)
+        for select_with_parameter in select_with_parameters:
+            select_with_sql_request = f"""
+                select {", ".join(statements)}
+                from {table_name}
+                with {select_with_parameter}
+            """
+            rows = dml.query(select_with_sql_request)
+            for i in range(len(rows)):
+                self.assert_type_after_select(i + 1, i, rows, all_types, pk_types, index, ttl, dml)
path: ydb/tests/datashard/select/test_select.py
user: login: lex007in
body: Можно ещё так:
```
for i, row in enumerate(rows):
    ...
    (и передавать уже конкрентую row, а не все rows)
```
created_at: 2025-05-16T12:20:42Z
author_association: COLLABORATOR
diff_hunk: @@ -0,0 +1,509 @@
+import pytest
+
+from ydb.tests.sql.lib.test_base import TestBase
+from ydb.tests.datashard.lib.dml_operations import DMLOperations
+from ydb.tests.datashard.lib.types_of_variables import (
+    cleanup_type_name,
+    format_sql_value,
+    pk_types,
+    non_pk_types,
+    index_first,
+    index_second,
+    ttl_types,
+    index_first_sync,
+    index_second_sync,
+    index_three_sync,
+    index_three_sync_not_Bool,
+    index_four_sync,
+    index_zero_sync,
+)
+
+
+class TestDML(TestBase):
+    @pytest.mark.parametrize(
+        "table_name, pk_types, all_types, index, ttl, unique, sync",
+        [
+            ("table_index_4_UNIQUE_SYNC", pk_types, {},
+             index_four_sync, "", "UNIQUE", "SYNC"),
+            ("table_index_3_UNIQUE_SYNC", pk_types, {},
+             index_three_sync_not_Bool, "", "UNIQUE", "SYNC"),
+            ("table_index_2_UNIQUE_SYNC", pk_types, {},
+             index_second_sync, "", "UNIQUE", "SYNC"),
+            ("table_index_1_UNIQUE_SYNC", pk_types, {},
+             index_first_sync, "", "UNIQUE", "SYNC"),
+            ("table_index_0_UNIQUE_SYNC", pk_types, {},
+             index_zero_sync, "", "UNIQUE", "SYNC"),
+            ("table_index_4__SYNC", pk_types, {},
+             index_four_sync, "", "", "SYNC"),
+            ("table_index_3__SYNC", pk_types, {},
+             index_three_sync, "", "", "SYNC"),
+            ("table_index_2__SYNC", pk_types, {},
+             index_second_sync, "", "", "SYNC"),
+            ("table_index_1__SYNC", pk_types, {},
+             index_first_sync, "", "", "SYNC"),
+            ("table_index_0__SYNC", pk_types, {},
+             index_zero_sync, "", "", "SYNC"),
+            ("table_index_1__ASYNC", pk_types, {}, index_second, "", "", "ASYNC"),
+            ("table_index_0__ASYNC", pk_types, {}, index_first, "", "", "ASYNC"),
+            ("table_all_types", pk_types, {
+             **pk_types, **non_pk_types}, {}, "", "", ""),
+            ("table_ttl_DyNumber", pk_types, {}, {}, "DyNumber", "", ""),
+            ("table_ttl_Uint32", pk_types, {}, {}, "Uint32", "", ""),
+            ("table_ttl_Uint64", pk_types, {}, {}, "Uint64", "", ""),
+            ("table_ttl_Datetime", pk_types, {}, {}, "Datetime", "", ""),
+            ("table_ttl_Timestamp", pk_types, {}, {}, "Timestamp", "", ""),
+            ("table_ttl_Date", pk_types, {}, {}, "Date", "", ""),
+        ]
+    )
+    def test_select(self, table_name: str, pk_types: dict[str, str], all_types: dict[str, str], index: dict[str, str], ttl: str, unique: str, sync: str):
+        dml = DMLOperations(self)
+        dml.create_table(table_name, pk_types, all_types,
+                         index, ttl, unique, sync)
+        dml.insert(table_name, all_types, pk_types, index, ttl)
+        self.select_with(table_name, all_types, pk_types, index, ttl, dml)
+        self.order_by(table_name, all_types, pk_types, index, ttl, dml)
+        self.limit(table_name, all_types, pk_types, index, ttl, dml)
+        self.from_select(table_name, all_types, pk_types, index, ttl, dml)
+        self.distinct(table_name, all_types, pk_types, index, ttl, dml)
+        self.union(table_name, all_types, pk_types, index, ttl, dml)
+        self.without(table_name, all_types, pk_types, index, ttl)
+        self.tablesample_sample(table_name, all_types,
+                                pk_types, index, ttl, dml)
+
+    def limit(
+        self,
+        table_name: str,
+        all_types: dict[str, str],
+        pk_types: dict[str, str],
+        index: dict[str, str],
+        ttl: str,
+        dml: DMLOperations,
+    ):
+        statements = self.create_types_for_all_select(all_types, pk_types, index, ttl)
+
+        number_of_columns = self.get_number_of_columns(pk_types, all_types, index, ttl)
+
+        for offset in range(number_of_columns):
+            rows = self.query(f"select {", ".join(statements)} from {table_name} limit 1 OFFSET {offset}")
+            self.assert_type_after_select(offset + 1, 0, rows, all_types, pk_types, index, ttl, dml)
+
+    def create_types_for_all_select(
+        self, all_types: dict[str, str], pk_types: dict[str, str], index: dict[str, str], ttl: str
+    ):
+        statements = []
+        # delete if after https://github.com/ydb-platform/ydb/issues/16930
+        for type in all_types.keys():
+            if type != "Date32" and type != "Datetime64" and type != "Timestamp64" and type != 'Interval64':
path: ydb/tests/datashard/select/test_select.py
user: login: lex007in
body: Можно ещё как-то:
```
if type not in ["Date32", "Datetime64", "Timestamp64", "Interval64"]:
    ...
```
created_at: 2025-05-16T12:25:42Z
author_association: COLLABORATOR
diff_hunk: @@ -0,0 +1,509 @@
+import pytest
+
+from ydb.tests.sql.lib.test_base import TestBase
+from ydb.tests.datashard.lib.dml_operations import DMLOperations
+from ydb.tests.datashard.lib.types_of_variables import (
+    cleanup_type_name,
+    format_sql_value,
+    pk_types,
+    non_pk_types,
+    index_first,
+    index_second,
+    ttl_types,
+    index_first_sync,
+    index_second_sync,
+    index_three_sync,
+    index_three_sync_not_Bool,
+    index_four_sync,
+    index_zero_sync,
+)
+
+
+class TestDML(TestBase):
+    @pytest.mark.parametrize(
+        "table_name, pk_types, all_types, index, ttl, unique, sync",
+        [
+            ("table_index_4_UNIQUE_SYNC", pk_types, {},
+             index_four_sync, "", "UNIQUE", "SYNC"),
+            ("table_index_3_UNIQUE_SYNC", pk_types, {},
+             index_three_sync_not_Bool, "", "UNIQUE", "SYNC"),
+            ("table_index_2_UNIQUE_SYNC", pk_types, {},
+             index_second_sync, "", "UNIQUE", "SYNC"),
+            ("table_index_1_UNIQUE_SYNC", pk_types, {},
+             index_first_sync, "", "UNIQUE", "SYNC"),
+            ("table_index_0_UNIQUE_SYNC", pk_types, {},
+             index_zero_sync, "", "UNIQUE", "SYNC"),
+            ("table_index_4__SYNC", pk_types, {},
+             index_four_sync, "", "", "SYNC"),
+            ("table_index_3__SYNC", pk_types, {},
+             index_three_sync, "", "", "SYNC"),
+            ("table_index_2__SYNC", pk_types, {},
+             index_second_sync, "", "", "SYNC"),
+            ("table_index_1__SYNC", pk_types, {},
+             index_first_sync, "", "", "SYNC"),
+            ("table_index_0__SYNC", pk_types, {},
+             index_zero_sync, "", "", "SYNC"),
+            ("table_index_1__ASYNC", pk_types, {}, index_second, "", "", "ASYNC"),
+            ("table_index_0__ASYNC", pk_types, {}, index_first, "", "", "ASYNC"),
+            ("table_all_types", pk_types, {
+             **pk_types, **non_pk_types}, {}, "", "", ""),
+            ("table_ttl_DyNumber", pk_types, {}, {}, "DyNumber", "", ""),
+            ("table_ttl_Uint32", pk_types, {}, {}, "Uint32", "", ""),
+            ("table_ttl_Uint64", pk_types, {}, {}, "Uint64", "", ""),
+            ("table_ttl_Datetime", pk_types, {}, {}, "Datetime", "", ""),
+            ("table_ttl_Timestamp", pk_types, {}, {}, "Timestamp", "", ""),
+            ("table_ttl_Date", pk_types, {}, {}, "Date", "", ""),
+        ]
+    )
+    def test_select(self, table_name: str, pk_types: dict[str, str], all_types: dict[str, str], index: dict[str, str], ttl: str, unique: str, sync: str):
+        dml = DMLOperations(self)
+        dml.create_table(table_name, pk_types, all_types,
+                         index, ttl, unique, sync)
+        dml.insert(table_name, all_types, pk_types, index, ttl)
+        self.select_with(table_name, all_types, pk_types, index, ttl, dml)
+        self.order_by(table_name, all_types, pk_types, index, ttl, dml)
+        self.limit(table_name, all_types, pk_types, index, ttl, dml)
+        self.from_select(table_name, all_types, pk_types, index, ttl, dml)
+        self.distinct(table_name, all_types, pk_types, index, ttl, dml)
+        self.union(table_name, all_types, pk_types, index, ttl, dml)
+        self.without(table_name, all_types, pk_types, index, ttl)
+        self.tablesample_sample(table_name, all_types,
+                                pk_types, index, ttl, dml)
+
+    def limit(
+        self,
+        table_name: str,
+        all_types: dict[str, str],
+        pk_types: dict[str, str],
+        index: dict[str, str],
+        ttl: str,
+        dml: DMLOperations,
+    ):
+        statements = self.create_types_for_all_select(all_types, pk_types, index, ttl)
+
+        number_of_columns = self.get_number_of_columns(pk_types, all_types, index, ttl)
+
+        for offset in range(number_of_columns):
+            rows = self.query(f"select {", ".join(statements)} from {table_name} limit 1 OFFSET {offset}")
+            self.assert_type_after_select(offset + 1, 0, rows, all_types, pk_types, index, ttl, dml)
+
+    def create_types_for_all_select(
+        self, all_types: dict[str, str], pk_types: dict[str, str], index: dict[str, str], ttl: str
+    ):
+        statements = []
+        # delete if after https://github.com/ydb-platform/ydb/issues/16930
+        for type in all_types.keys():
+            if type != "Date32" and type != "Datetime64" and type != "Timestamp64" and type != 'Interval64':
+                statements.append(f"col_{cleanup_type_name(type)}")
+        for type in pk_types.keys():
+            if type != "Date32" and type != "Datetime64" and type != "Timestamp64" and type != 'Interval64':
+                statements.append(f"pk_{cleanup_type_name(type)}")
+        for type in index.keys():
+            if type != "Date32" and type != "Datetime64" and type != "Timestamp64" and type != 'Interval64':
+                statements.append(f"col_index_{cleanup_type_name(type)}")
+        if ttl != "":
+            statements.append(f"ttl_{cleanup_type_name(ttl)}")
+        return statements
+
+    def assert_type_after_select(
+        self,
+        value,
+        line,
+        rows,
+        all_types: dict[str, str],
+        pk_types: dict[str, str],
+        index: dict[str, str],
+        ttl: str,
+        dml: DMLOperations,
+    ):
+        count = 0
+        for type in all_types.keys():
+            if type != "Date32" and type != "Datetime64" and type != "Timestamp64" and type != 'Interval64':
+                dml.assert_type(all_types, type, value, rows[line][count])
+                count += 1
+        for type in pk_types.keys():
+            if type != "Date32" and type != "Datetime64" and type != "Timestamp64" and type != 'Interval64':
+                dml.assert_type(pk_types, type, value, rows[line][count])
+                count += 1
+        for type in index.keys():
+            if type != "Date32" and type != "Datetime64" and type != "Timestamp64" and type != 'Interval64':
+                dml.assert_type(index, type, value, rows[line][count])
+                count += 1
+        if ttl != "":
+            dml.assert_type(ttl_types, ttl, value, rows[line][count])
+            count += 1
+
+    def from_select(
+        self,
+        table_name: str,
+        all_types: dict[str, str],
+        pk_types: dict[str, str],
+        index: dict[str, str],
+        ttl: str,
+        dml: DMLOperations,
+    ):
+        statements = self.create_types_for_all_select(all_types, pk_types, index, ttl)
+
+        rows = self.query(f"from {table_name} select {", ".join(statements)}")
+        for i in range(len(rows)):
+            self.assert_type_after_select(i + 1, i, rows, all_types, pk_types, index, ttl, dml)
+
+    def distinct(
+        self,
+        table_name: str,
+        all_types: dict[str, str],
+        pk_types: dict[str, str],
+        index: dict[str, str],
+        ttl: str,
+        dml: DMLOperations,
+    ):
+        # del type != "DyNumber" and type != "UUID" after https://github.com/ydb-platform/ydb/issues/17484
+        for type in all_types.keys():
+            if (
+                type != "Date32"
+                and type != "Datetime64"
+                and type != "Timestamp64"
+                and type != 'Interval64'
+                and type != "DyNumber"
+                and type != "UUID"
+                and type != "Json"
+                and type != "JsonDocument"
+                and type != "Yson"
+            ):
+                rows_distinct = self.query(f"SELECT DISTINCT col_{cleanup_type_name(type)} from {table_name}")
+                for i in range(len(rows_distinct)):
+                    dml.assert_type(all_types, type, i + 1, rows_distinct[i][0])
+        for type in pk_types.keys():
+            if (
+                type != "Date32"
+                and type != "Datetime64"
+                and type != "Timestamp64"
+                and type != 'Interval64'
+                and type != "DyNumber"
+                and type != "UUID"
+            ):
+                rows_distinct = self.query(f"SELECT DISTINCT pk_{cleanup_type_name(type)} from {table_name}")
+                for i in range(len(rows_distinct)):
+                    dml.assert_type(pk_types, type, i + 1, rows_distinct[i][0])
+        for type in index.keys():
+            if (
+                type != "Date32"
+                and type != "Datetime64"
+                and type != "Timestamp64"
+                and type != 'Interval64'
+                and type != "DyNumber"
+                and type != "UUID"
+            ):
+                rows_distinct = self.query(f"SELECT DISTINCT col_index_{cleanup_type_name(type)} from {table_name}")
+                for i in range(len(rows_distinct)):
+                    dml.assert_type(index, type, i + 1, rows_distinct[i][0])
+        if ttl != "" and ttl != "DyNumber":
+            rows_distinct = self.query(f"SELECT DISTINCT ttl_{cleanup_type_name(ttl)} from {table_name}")
+            for i in range(len(rows_distinct)):
+                dml.assert_type(ttl_types, ttl, i + 1, rows_distinct[i][0])
+
+    def union(
+        self,
+        table_name: str,
+        all_types: dict[str, str],
+        pk_types: dict[str, str],
+        index: dict[str, str],
+        ttl: str,
+        dml: DMLOperations,
+    ):
+        statements = []
+        for type in all_types.keys():
+            if (
+                type != "Date32"
+                and type != "Datetime64"
+                and type != "Timestamp64"
+                and type != 'Interval64'
+                and type != "DyNumber"
+                and type != "UUID"
+                and type != "Json"
+                and type != "JsonDocument"
+                and type != "Yson"
+            ):
+                statements.append(f"col_{cleanup_type_name(type)}")
+        for type in pk_types.keys():
+            if (
+                type != "Date32"
+                and type != "Datetime64"
+                and type != "Timestamp64"
+                and type != 'Interval64'
+                and type != "DyNumber"
+                and type != "UUID"
+            ):
+                statements.append(f"pk_{cleanup_type_name(type)}")
+        for type in index.keys():
+            if (
+                type != "Date32"
+                and type != "Datetime64"
+                and type != "Timestamp64"
+                and type != 'Interval64'
+                and type != "DyNumber"
+                and type != "UUID"
+            ):
+                statements.append(f"col_index_{cleanup_type_name(type)}")
+        if ttl != "" and ttl != "DyNumber":
+            statements.append(f"ttl_{cleanup_type_name(ttl)}")
+        rows = self.query(
+            f"""
+                          select {", ".join(statements)} from {table_name}
+                          union
+                          select {", ".join(statements)} from {table_name}
+                          """
+        )
+        for type in all_types.keys():
+            if (
+                type != "Date32"
+                and type != "Datetime64"
+                and type != "Timestamp64"
+                and type != 'Interval64'
+                and type != "DyNumber"
+                and type != "UUID"
+                and type != "Json"
+                and type != "JsonDocument"
+                and type != "Yson"
+            ):
+                for line in range(len(rows)):
+                    dml.assert_type(all_types, type, line + 1, rows[line][f"col_{cleanup_type_name(type)}"])
+        for type in pk_types.keys():
+            if (
+                type != "Date32"
+                and type != "Datetime64"
+                and type != "Timestamp64"
+                and type != 'Interval64'
+                and type != "DyNumber"
+                and type != "UUID"
+            ):
+                for line in range(len(rows)):
+                    dml.assert_type(pk_types, type, line + 1, rows[line][f"pk_{cleanup_type_name(type)}"])
+        for type in index.keys():
+            if (
+                type != "Date32"
+                and type != "Datetime64"
+                and type != "Timestamp64"
+                and type != 'Interval64'
+                and type != "DyNumber"
+                and type != "UUID"
+            ):
+                for line in range(len(rows)):
+                    dml.assert_type(index, type, line + 1, rows[line][f"col_index_{cleanup_type_name(type)}"])
+        if ttl != "" and ttl != "DyNumber":
+            for line in range(len(rows)):
+                dml.assert_type(ttl_types, ttl, line + 1, rows[line][f"ttl_{cleanup_type_name(ttl)}"])
+
+    def select_with(
+        self,
+        table_name: str,
+        all_types: dict[str, str],
+        pk_types: dict[str, str],
+        index: dict[str, str],
+        ttl: str,
+        dml: DMLOperations,
+    ):
+        select_with_parameters = [
+            "INFER_SCHEMA",
+            "FORCE_INFER_SCHEMA",
+            "DIRECT_READ",
+            "INLINE",
+            "UNORDERED",
+            "XLOCK",
+            "IGNORETYPEV3",
+        ]
+        statements = self.create_types_for_all_select(all_types, pk_types, index, ttl)
path: ydb/tests/datashard/select/test_select.py
user: login: lex007in
body: Вообще, по смыслу тут скорее не statements, а expressions, ну или вообще можно назвать как-то типа `selected_columns` или `columns_to_select`
created_at: 2025-05-16T12:43:14Z
author_association: COLLABORATOR
diff_hunk: @@ -0,0 +1,509 @@
+import pytest
+
+from ydb.tests.sql.lib.test_base import TestBase
+from ydb.tests.datashard.lib.dml_operations import DMLOperations
+from ydb.tests.datashard.lib.types_of_variables import (
+    cleanup_type_name,
+    format_sql_value,
+    pk_types,
+    non_pk_types,
+    index_first,
+    index_second,
+    ttl_types,
+    index_first_sync,
+    index_second_sync,
+    index_three_sync,
+    index_three_sync_not_Bool,
+    index_four_sync,
+    index_zero_sync,
+)
+
+
+class TestDML(TestBase):
+    @pytest.mark.parametrize(
+        "table_name, pk_types, all_types, index, ttl, unique, sync",
+        [
+            ("table_index_4_UNIQUE_SYNC", pk_types, {},
+             index_four_sync, "", "UNIQUE", "SYNC"),
+            ("table_index_3_UNIQUE_SYNC", pk_types, {},
+             index_three_sync_not_Bool, "", "UNIQUE", "SYNC"),
+            ("table_index_2_UNIQUE_SYNC", pk_types, {},
+             index_second_sync, "", "UNIQUE", "SYNC"),
+            ("table_index_1_UNIQUE_SYNC", pk_types, {},
+             index_first_sync, "", "UNIQUE", "SYNC"),
+            ("table_index_0_UNIQUE_SYNC", pk_types, {},
+             index_zero_sync, "", "UNIQUE", "SYNC"),
+            ("table_index_4__SYNC", pk_types, {},
+             index_four_sync, "", "", "SYNC"),
+            ("table_index_3__SYNC", pk_types, {},
+             index_three_sync, "", "", "SYNC"),
+            ("table_index_2__SYNC", pk_types, {},
+             index_second_sync, "", "", "SYNC"),
+            ("table_index_1__SYNC", pk_types, {},
+             index_first_sync, "", "", "SYNC"),
+            ("table_index_0__SYNC", pk_types, {},
+             index_zero_sync, "", "", "SYNC"),
+            ("table_index_1__ASYNC", pk_types, {}, index_second, "", "", "ASYNC"),
+            ("table_index_0__ASYNC", pk_types, {}, index_first, "", "", "ASYNC"),
+            ("table_all_types", pk_types, {
+             **pk_types, **non_pk_types}, {}, "", "", ""),
+            ("table_ttl_DyNumber", pk_types, {}, {}, "DyNumber", "", ""),
+            ("table_ttl_Uint32", pk_types, {}, {}, "Uint32", "", ""),
+            ("table_ttl_Uint64", pk_types, {}, {}, "Uint64", "", ""),
+            ("table_ttl_Datetime", pk_types, {}, {}, "Datetime", "", ""),
+            ("table_ttl_Timestamp", pk_types, {}, {}, "Timestamp", "", ""),
+            ("table_ttl_Date", pk_types, {}, {}, "Date", "", ""),
+        ]
+    )
+    def test_select(self, table_name: str, pk_types: dict[str, str], all_types: dict[str, str], index: dict[str, str], ttl: str, unique: str, sync: str):
+        dml = DMLOperations(self)
+        dml.create_table(table_name, pk_types, all_types,
+                         index, ttl, unique, sync)
+        dml.insert(table_name, all_types, pk_types, index, ttl)
+        self.select_with(table_name, all_types, pk_types, index, ttl, dml)
+        self.order_by(table_name, all_types, pk_types, index, ttl, dml)
+        self.limit(table_name, all_types, pk_types, index, ttl, dml)
+        self.from_select(table_name, all_types, pk_types, index, ttl, dml)
+        self.distinct(table_name, all_types, pk_types, index, ttl, dml)
+        self.union(table_name, all_types, pk_types, index, ttl, dml)
+        self.without(table_name, all_types, pk_types, index, ttl)
+        self.tablesample_sample(table_name, all_types,
+                                pk_types, index, ttl, dml)
+
+    def limit(
+        self,
+        table_name: str,
+        all_types: dict[str, str],
+        pk_types: dict[str, str],
+        index: dict[str, str],
+        ttl: str,
+        dml: DMLOperations,
+    ):
+        statements = self.create_types_for_all_select(all_types, pk_types, index, ttl)
+
+        number_of_columns = self.get_number_of_columns(pk_types, all_types, index, ttl)
+
+        for offset in range(number_of_columns):
+            rows = self.query(f"select {", ".join(statements)} from {table_name} limit 1 OFFSET {offset}")
+            self.assert_type_after_select(offset + 1, 0, rows, all_types, pk_types, index, ttl, dml)
+
+    def create_types_for_all_select(
+        self, all_types: dict[str, str], pk_types: dict[str, str], index: dict[str, str], ttl: str
+    ):
+        statements = []
+        # delete if after https://github.com/ydb-platform/ydb/issues/16930
+        for type in all_types.keys():
+            if type != "Date32" and type != "Datetime64" and type != "Timestamp64" and type != 'Interval64':
+                statements.append(f"col_{cleanup_type_name(type)}")
+        for type in pk_types.keys():
+            if type != "Date32" and type != "Datetime64" and type != "Timestamp64" and type != 'Interval64':
+                statements.append(f"pk_{cleanup_type_name(type)}")
+        for type in index.keys():
+            if type != "Date32" and type != "Datetime64" and type != "Timestamp64" and type != 'Interval64':
+                statements.append(f"col_index_{cleanup_type_name(type)}")
+        if ttl != "":
+            statements.append(f"ttl_{cleanup_type_name(ttl)}")
+        return statements
+
+    def assert_type_after_select(
+        self,
+        value,
+        line,
+        rows,
+        all_types: dict[str, str],
+        pk_types: dict[str, str],
+        index: dict[str, str],
+        ttl: str,
+        dml: DMLOperations,
+    ):
+        count = 0
+        for type in all_types.keys():
+            if type != "Date32" and type != "Datetime64" and type != "Timestamp64" and type != 'Interval64':
+                dml.assert_type(all_types, type, value, rows[line][count])
+                count += 1
+        for type in pk_types.keys():
+            if type != "Date32" and type != "Datetime64" and type != "Timestamp64" and type != 'Interval64':
+                dml.assert_type(pk_types, type, value, rows[line][count])
+                count += 1
+        for type in index.keys():
+            if type != "Date32" and type != "Datetime64" and type != "Timestamp64" and type != 'Interval64':
+                dml.assert_type(index, type, value, rows[line][count])
+                count += 1
+        if ttl != "":
+            dml.assert_type(ttl_types, ttl, value, rows[line][count])
+            count += 1
+
+    def from_select(
+        self,
+        table_name: str,
+        all_types: dict[str, str],
+        pk_types: dict[str, str],
+        index: dict[str, str],
+        ttl: str,
+        dml: DMLOperations,
+    ):
+        statements = self.create_types_for_all_select(all_types, pk_types, index, ttl)
+
+        rows = self.query(f"from {table_name} select {", ".join(statements)}")
+        for i in range(len(rows)):
+            self.assert_type_after_select(i + 1, i, rows, all_types, pk_types, index, ttl, dml)
+
+    def distinct(
+        self,
+        table_name: str,
+        all_types: dict[str, str],
+        pk_types: dict[str, str],
+        index: dict[str, str],
+        ttl: str,
+        dml: DMLOperations,
+    ):
+        # del type != "DyNumber" and type != "UUID" after https://github.com/ydb-platform/ydb/issues/17484
+        for type in all_types.keys():
+            if (
+                type != "Date32"
+                and type != "Datetime64"
+                and type != "Timestamp64"
+                and type != 'Interval64'
+                and type != "DyNumber"
+                and type != "UUID"
+                and type != "Json"
+                and type != "JsonDocument"
+                and type != "Yson"
+            ):
path: ydb/tests/datashard/select/test_select.py
user: login: lex007in
body: Давай сделаем как-то так:
Вне класса:
```
unsuppored_time_types = ["Date32",  "Datetime64", "Timestamp64", "Interval64"]  # https://github.com/ydb-platform/ydb/issues/16930
unsuppored_distinct_types = [
    "DyNumber", "UUID",    # https://github.com/ydb-platform/ydb/issues/17484
    "Json", "JsonDocument", "Yson"
]
uncomparable_types = [ "Json", "JsonDocument", "Yson"]
```
И потом в коде так использовать:
```
if type not in unsuppored_time_types and type not in unsuppored_distinct_types:
    ...
```
created_at: 2025-05-16T13:21:38Z
author_association: COLLABORATOR
diff_hunk: @@ -0,0 +1,509 @@
+import pytest
+
+from ydb.tests.sql.lib.test_base import TestBase
+from ydb.tests.datashard.lib.dml_operations import DMLOperations
+from ydb.tests.datashard.lib.types_of_variables import (
+    cleanup_type_name,
+    format_sql_value,
+    pk_types,
+    non_pk_types,
+    index_first,
+    index_second,
+    ttl_types,
+    index_first_sync,
+    index_second_sync,
+    index_three_sync,
+    index_three_sync_not_Bool,
+    index_four_sync,
+    index_zero_sync,
+)
+
+
+class TestDML(TestBase):
+    @pytest.mark.parametrize(
+        "table_name, pk_types, all_types, index, ttl, unique, sync",
+        [
+            ("table_index_4_UNIQUE_SYNC", pk_types, {},
+             index_four_sync, "", "UNIQUE", "SYNC"),
+            ("table_index_3_UNIQUE_SYNC", pk_types, {},
+             index_three_sync_not_Bool, "", "UNIQUE", "SYNC"),
+            ("table_index_2_UNIQUE_SYNC", pk_types, {},
+             index_second_sync, "", "UNIQUE", "SYNC"),
+            ("table_index_1_UNIQUE_SYNC", pk_types, {},
+             index_first_sync, "", "UNIQUE", "SYNC"),
+            ("table_index_0_UNIQUE_SYNC", pk_types, {},
+             index_zero_sync, "", "UNIQUE", "SYNC"),
+            ("table_index_4__SYNC", pk_types, {},
+             index_four_sync, "", "", "SYNC"),
+            ("table_index_3__SYNC", pk_types, {},
+             index_three_sync, "", "", "SYNC"),
+            ("table_index_2__SYNC", pk_types, {},
+             index_second_sync, "", "", "SYNC"),
+            ("table_index_1__SYNC", pk_types, {},
+             index_first_sync, "", "", "SYNC"),
+            ("table_index_0__SYNC", pk_types, {},
+             index_zero_sync, "", "", "SYNC"),
+            ("table_index_1__ASYNC", pk_types, {}, index_second, "", "", "ASYNC"),
+            ("table_index_0__ASYNC", pk_types, {}, index_first, "", "", "ASYNC"),
+            ("table_all_types", pk_types, {
+             **pk_types, **non_pk_types}, {}, "", "", ""),
+            ("table_ttl_DyNumber", pk_types, {}, {}, "DyNumber", "", ""),
+            ("table_ttl_Uint32", pk_types, {}, {}, "Uint32", "", ""),
+            ("table_ttl_Uint64", pk_types, {}, {}, "Uint64", "", ""),
+            ("table_ttl_Datetime", pk_types, {}, {}, "Datetime", "", ""),
+            ("table_ttl_Timestamp", pk_types, {}, {}, "Timestamp", "", ""),
+            ("table_ttl_Date", pk_types, {}, {}, "Date", "", ""),
+        ]
+    )
+    def test_select(self, table_name: str, pk_types: dict[str, str], all_types: dict[str, str], index: dict[str, str], ttl: str, unique: str, sync: str):
+        dml = DMLOperations(self)
+        dml.create_table(table_name, pk_types, all_types,
+                         index, ttl, unique, sync)
+        dml.insert(table_name, all_types, pk_types, index, ttl)
+        self.select_with(table_name, all_types, pk_types, index, ttl, dml)
+        self.order_by(table_name, all_types, pk_types, index, ttl, dml)
+        self.limit(table_name, all_types, pk_types, index, ttl, dml)
+        self.from_select(table_name, all_types, pk_types, index, ttl, dml)
+        self.distinct(table_name, all_types, pk_types, index, ttl, dml)
+        self.union(table_name, all_types, pk_types, index, ttl, dml)
+        self.without(table_name, all_types, pk_types, index, ttl)
+        self.tablesample_sample(table_name, all_types,
+                                pk_types, index, ttl, dml)
+
+    def limit(
+        self,
+        table_name: str,
+        all_types: dict[str, str],
+        pk_types: dict[str, str],
+        index: dict[str, str],
+        ttl: str,
+        dml: DMLOperations,
+    ):
+        statements = self.create_types_for_all_select(all_types, pk_types, index, ttl)
+
+        number_of_columns = self.get_number_of_columns(pk_types, all_types, index, ttl)
+
+        for offset in range(number_of_columns):
+            rows = self.query(f"select {", ".join(statements)} from {table_name} limit 1 OFFSET {offset}")
+            self.assert_type_after_select(offset + 1, 0, rows, all_types, pk_types, index, ttl, dml)
+
+    def create_types_for_all_select(
+        self, all_types: dict[str, str], pk_types: dict[str, str], index: dict[str, str], ttl: str
+    ):
+        statements = []
+        # delete if after https://github.com/ydb-platform/ydb/issues/16930
+        for type in all_types.keys():
+            if type != "Date32" and type != "Datetime64" and type != "Timestamp64" and type != 'Interval64':
+                statements.append(f"col_{cleanup_type_name(type)}")
+        for type in pk_types.keys():
+            if type != "Date32" and type != "Datetime64" and type != "Timestamp64" and type != 'Interval64':
+                statements.append(f"pk_{cleanup_type_name(type)}")
+        for type in index.keys():
+            if type != "Date32" and type != "Datetime64" and type != "Timestamp64" and type != 'Interval64':
+                statements.append(f"col_index_{cleanup_type_name(type)}")
+        if ttl != "":
+            statements.append(f"ttl_{cleanup_type_name(ttl)}")
+        return statements
+
+    def assert_type_after_select(
+        self,
+        value,
+        line,
+        rows,
+        all_types: dict[str, str],
+        pk_types: dict[str, str],
+        index: dict[str, str],
+        ttl: str,
+        dml: DMLOperations,
+    ):
+        count = 0
+        for type in all_types.keys():
+            if type != "Date32" and type != "Datetime64" and type != "Timestamp64" and type != 'Interval64':
+                dml.assert_type(all_types, type, value, rows[line][count])
+                count += 1
+        for type in pk_types.keys():
+            if type != "Date32" and type != "Datetime64" and type != "Timestamp64" and type != 'Interval64':
+                dml.assert_type(pk_types, type, value, rows[line][count])
+                count += 1
+        for type in index.keys():
+            if type != "Date32" and type != "Datetime64" and type != "Timestamp64" and type != 'Interval64':
+                dml.assert_type(index, type, value, rows[line][count])
+                count += 1
+        if ttl != "":
+            dml.assert_type(ttl_types, ttl, value, rows[line][count])
+            count += 1
+
+    def from_select(
+        self,
+        table_name: str,
+        all_types: dict[str, str],
+        pk_types: dict[str, str],
+        index: dict[str, str],
+        ttl: str,
+        dml: DMLOperations,
+    ):
+        statements = self.create_types_for_all_select(all_types, pk_types, index, ttl)
+
+        rows = self.query(f"from {table_name} select {", ".join(statements)}")
+        for i in range(len(rows)):
+            self.assert_type_after_select(i + 1, i, rows, all_types, pk_types, index, ttl, dml)
+
+    def distinct(
+        self,
+        table_name: str,
+        all_types: dict[str, str],
+        pk_types: dict[str, str],
+        index: dict[str, str],
+        ttl: str,
+        dml: DMLOperations,
+    ):
+        # del type != "DyNumber" and type != "UUID" after https://github.com/ydb-platform/ydb/issues/17484
+        for type in all_types.keys():
+            if (
+                type != "Date32"
+                and type != "Datetime64"
+                and type != "Timestamp64"
+                and type != 'Interval64'
+                and type != "DyNumber"
+                and type != "UUID"
+                and type != "Json"
+                and type != "JsonDocument"
+                and type != "Yson"
+            ):
+                rows_distinct = self.query(f"SELECT DISTINCT col_{cleanup_type_name(type)} from {table_name}")
+                for i in range(len(rows_distinct)):
+                    dml.assert_type(all_types, type, i + 1, rows_distinct[i][0])
+        for type in pk_types.keys():
+            if (
+                type != "Date32"
+                and type != "Datetime64"
+                and type != "Timestamp64"
+                and type != 'Interval64'
+                and type != "DyNumber"
+                and type != "UUID"
+            ):
+                rows_distinct = self.query(f"SELECT DISTINCT pk_{cleanup_type_name(type)} from {table_name}")
+                for i in range(len(rows_distinct)):
+                    dml.assert_type(pk_types, type, i + 1, rows_distinct[i][0])
+        for type in index.keys():
+            if (
+                type != "Date32"
+                and type != "Datetime64"
+                and type != "Timestamp64"
+                and type != 'Interval64'
+                and type != "DyNumber"
+                and type != "UUID"
+            ):
+                rows_distinct = self.query(f"SELECT DISTINCT col_index_{cleanup_type_name(type)} from {table_name}")
+                for i in range(len(rows_distinct)):
+                    dml.assert_type(index, type, i + 1, rows_distinct[i][0])
+        if ttl != "" and ttl != "DyNumber":
+            rows_distinct = self.query(f"SELECT DISTINCT ttl_{cleanup_type_name(ttl)} from {table_name}")
+            for i in range(len(rows_distinct)):
+                dml.assert_type(ttl_types, ttl, i + 1, rows_distinct[i][0])
+
+    def union(
+        self,
+        table_name: str,
+        all_types: dict[str, str],
+        pk_types: dict[str, str],
+        index: dict[str, str],
+        ttl: str,
+        dml: DMLOperations,
+    ):
+        statements = []
+        for type in all_types.keys():
+            if (
+                type != "Date32"
+                and type != "Datetime64"
+                and type != "Timestamp64"
+                and type != 'Interval64'
+                and type != "DyNumber"
+                and type != "UUID"
+                and type != "Json"
+                and type != "JsonDocument"
+                and type != "Yson"
+            ):
+                statements.append(f"col_{cleanup_type_name(type)}")
+        for type in pk_types.keys():
+            if (
+                type != "Date32"
+                and type != "Datetime64"
+                and type != "Timestamp64"
+                and type != 'Interval64'
+                and type != "DyNumber"
+                and type != "UUID"
+            ):
+                statements.append(f"pk_{cleanup_type_name(type)}")
+        for type in index.keys():
+            if (
+                type != "Date32"
+                and type != "Datetime64"
+                and type != "Timestamp64"
+                and type != 'Interval64'
+                and type != "DyNumber"
+                and type != "UUID"
+            ):
+                statements.append(f"col_index_{cleanup_type_name(type)}")
+        if ttl != "" and ttl != "DyNumber":
+            statements.append(f"ttl_{cleanup_type_name(ttl)}")
+        rows = self.query(
+            f"""
+                          select {", ".join(statements)} from {table_name}
+                          union
+                          select {", ".join(statements)} from {table_name}
+                          """
+        )
+        for type in all_types.keys():
+            if (
+                type != "Date32"
+                and type != "Datetime64"
+                and type != "Timestamp64"
+                and type != 'Interval64'
+                and type != "DyNumber"
+                and type != "UUID"
+                and type != "Json"
+                and type != "JsonDocument"
+                and type != "Yson"
+            ):
+                for line in range(len(rows)):
+                    dml.assert_type(all_types, type, line + 1, rows[line][f"col_{cleanup_type_name(type)}"])
+        for type in pk_types.keys():
+            if (
+                type != "Date32"
+                and type != "Datetime64"
+                and type != "Timestamp64"
+                and type != 'Interval64'
+                and type != "DyNumber"
+                and type != "UUID"
+            ):
+                for line in range(len(rows)):
+                    dml.assert_type(pk_types, type, line + 1, rows[line][f"pk_{cleanup_type_name(type)}"])
+        for type in index.keys():
+            if (
+                type != "Date32"
+                and type != "Datetime64"
+                and type != "Timestamp64"
+                and type != 'Interval64'
+                and type != "DyNumber"
+                and type != "UUID"
+            ):
+                for line in range(len(rows)):
+                    dml.assert_type(index, type, line + 1, rows[line][f"col_index_{cleanup_type_name(type)}"])
+        if ttl != "" and ttl != "DyNumber":
+            for line in range(len(rows)):
+                dml.assert_type(ttl_types, ttl, line + 1, rows[line][f"ttl_{cleanup_type_name(ttl)}"])
+
+    def select_with(
+        self,
+        table_name: str,
+        all_types: dict[str, str],
+        pk_types: dict[str, str],
+        index: dict[str, str],
+        ttl: str,
+        dml: DMLOperations,
+    ):
+        select_with_parameters = [
+            "INFER_SCHEMA",
+            "FORCE_INFER_SCHEMA",
+            "DIRECT_READ",
+            "INLINE",
+            "UNORDERED",
+            "XLOCK",
+            "IGNORETYPEV3",
+        ]
+        statements = self.create_types_for_all_select(all_types, pk_types, index, ttl)
+        for select_with_parameter in select_with_parameters:
+            select_with_sql_request = f"""
+                select {", ".join(statements)}
+                from {table_name}
+                with {select_with_parameter}
+            """
+            rows = dml.query(select_with_sql_request)
+            for i in range(len(rows)):
+                self.assert_type_after_select(i + 1, i, rows, all_types, pk_types, index, ttl, dml)
+
+    def without(
+        self, table_name: str, all_types: dict[str, str], pk_types: dict[str, str], index: dict[str, str], ttl: str
+    ):
+        statements_without = []
+        for type_name in all_types.keys():
+            if (
+                type_name == "Date32"
+                or type_name == "Datetime64"
+                or type_name == "Timestamp64"
+                or type_name == 'Interval64'
+            ):
+                statements_without.append(f"col_{cleanup_type_name(type_name)}")
+        for type_name in pk_types.keys():
+            if (
+                type_name == "Date32"
+                or type_name == "Datetime64"
+                or type_name == "Timestamp64"
+                or type_name == 'Interval64'
+            ):
+                statements_without.append(f"pk_{cleanup_type_name(type_name)}")
+        for type_name in index.keys():
+            if (
+                type_name == "Date32"
+                or type_name == "Datetime64"
+                or type_name == "Timestamp64"
+                or type_name == 'Interval64'
+            ):
+                statements_without.append(f"col_index_{cleanup_type_name(type_name)}")
+
+        for type_name in all_types.keys():
+            if (
+                type_name != "Date32"
+                and type_name != "Datetime64"
+                and type_name != "Timestamp64"
+                and type_name != 'Interval64'
+            ):
+                self.create_without(table_name, statements_without, f"col_{cleanup_type_name(type_name)}")
+        for type_name in pk_types.keys():
+            if (
+                type_name != "Date32"
+                and type_name != "Datetime64"
+                and type_name != "Timestamp64"
+                and type_name != 'Interval64'
+            ):
+                self.create_without(table_name, statements_without, f"pk_{cleanup_type_name(type_name)}")
+        for type_name in index.keys():
+            if (
+                type_name != "Date32"
+                and type_name != "Datetime64"
+                and type_name != "Timestamp64"
+                and type_name != 'Interval64'
+            ):
+                self.create_without(table_name, statements_without, f"col_index_{cleanup_type_name(type_name)}")
+        if ttl != "":
+            self.create_without(table_name, statements_without, f"ttl_{cleanup_type_name(ttl)}")
+
+    def create_without(self, table_name, statements_without, without):
+        rows = self.query(f"select * without {", ".join(statements_without)}, {without} from {table_name}")
+        for col_name in rows[0].keys():
+            assert col_name != without, f"a column {without} in the table {table_name} was not excluded"
+
+    def tablesample_sample(
+        self,
+        table_name: str,
+        all_types: dict[str, str],
+        pk_types: dict[str, str],
+        index: dict[str, str],
+        ttl: str,
+        dml: DMLOperations,
+    ):
+        statements = self.create_types_for_all_select(all_types, pk_types, index, ttl)
+        for i in range(1, 100):
+            rows = self.query(f"select {", ".join(statements)} from {table_name} TABLESAMPLE SYSTEM({i}.0)")
+            for line in range(len(rows)):
+                numb = rows[line]["pk_Int64"]
+                self.assert_type_after_select(numb, line, rows, all_types, pk_types, index, ttl, dml)
+
+            rows = self.query(
+                f"select {", ".join(statements)} from {table_name} TABLESAMPLE BERNOULLI({i}.0) REPEATABLE({i})"
+            )
+            for line in range(len(rows)):
+                numb = rows[line]["pk_Int64"]
+                self.assert_type_after_select(numb, line, rows, all_types, pk_types, index, ttl, dml)
+
+            rows = self.query(f"select {", ".join(statements)} from {table_name} SAMPLE 1.0 / {i}")
+            for line in range(len(rows)):
+                numb = rows[line]["pk_Int64"]
+                self.assert_type_after_select(numb, line, rows, all_types, pk_types, index, ttl, dml)
+
+    def order_by(
+        self,
+        table_name: str,
+        all_types: dict[str, str],
+        pk_types: dict[str, str],
+        index: dict[str, str],
+        ttl: str,
+        dml: DMLOperations,
+    ):
+        statements = self.create_types_for_all_select(all_types, pk_types, index, ttl)
+        for statement in statements:
+            if "Json" not in statement and "JsonDocument" not in statement and "Yson" not in statement:
+                rows = self.query(f"select {", ".join(statements)} from {table_name} ORDER BY {statement} ASC")
+                if "String" not in statement and "Utf8" not in statement:
+                    for line in range(len(rows)):
+                        self.assert_type_after_select(line + 1, line, rows, all_types, pk_types, index, ttl, dml)
+                else:
+                    line = 0
+                    for i in range(len(rows) // 10):
+                        self.assert_type_after_select(i + 1, line, rows, all_types, pk_types, index, ttl, dml)
+                        line += 1
+                        for j in range(10):
+                            if (i + 1) * 10 + j > len(rows):
path: ydb/tests/datashard/select/test_select.py
user: login: lex007in
body: Может, проще сгенерировать список строк и отсортировать?
created_at: 2025-05-16T14:00:35Z
author_association: COLLABORATOR
diff_hunk: @@ -0,0 +1,509 @@
+import pytest
+
+from ydb.tests.sql.lib.test_base import TestBase
+from ydb.tests.datashard.lib.dml_operations import DMLOperations
+from ydb.tests.datashard.lib.types_of_variables import (
+    cleanup_type_name,
+    format_sql_value,
+    pk_types,
+    non_pk_types,
+    index_first,
+    index_second,
+    ttl_types,
+    index_first_sync,
+    index_second_sync,
+    index_three_sync,
+    index_three_sync_not_Bool,
+    index_four_sync,
+    index_zero_sync,
+)
+
+
+class TestDML(TestBase):
+    @pytest.mark.parametrize(
+        "table_name, pk_types, all_types, index, ttl, unique, sync",
+        [
+            ("table_index_4_UNIQUE_SYNC", pk_types, {},
+             index_four_sync, "", "UNIQUE", "SYNC"),
+            ("table_index_3_UNIQUE_SYNC", pk_types, {},
+             index_three_sync_not_Bool, "", "UNIQUE", "SYNC"),
+            ("table_index_2_UNIQUE_SYNC", pk_types, {},
+             index_second_sync, "", "UNIQUE", "SYNC"),
+            ("table_index_1_UNIQUE_SYNC", pk_types, {},
+             index_first_sync, "", "UNIQUE", "SYNC"),
+            ("table_index_0_UNIQUE_SYNC", pk_types, {},
+             index_zero_sync, "", "UNIQUE", "SYNC"),
+            ("table_index_4__SYNC", pk_types, {},
+             index_four_sync, "", "", "SYNC"),
+            ("table_index_3__SYNC", pk_types, {},
+             index_three_sync, "", "", "SYNC"),
+            ("table_index_2__SYNC", pk_types, {},
+             index_second_sync, "", "", "SYNC"),
+            ("table_index_1__SYNC", pk_types, {},
+             index_first_sync, "", "", "SYNC"),
+            ("table_index_0__SYNC", pk_types, {},
+             index_zero_sync, "", "", "SYNC"),
+            ("table_index_1__ASYNC", pk_types, {}, index_second, "", "", "ASYNC"),
+            ("table_index_0__ASYNC", pk_types, {}, index_first, "", "", "ASYNC"),
+            ("table_all_types", pk_types, {
+             **pk_types, **non_pk_types}, {}, "", "", ""),
+            ("table_ttl_DyNumber", pk_types, {}, {}, "DyNumber", "", ""),
+            ("table_ttl_Uint32", pk_types, {}, {}, "Uint32", "", ""),
+            ("table_ttl_Uint64", pk_types, {}, {}, "Uint64", "", ""),
+            ("table_ttl_Datetime", pk_types, {}, {}, "Datetime", "", ""),
+            ("table_ttl_Timestamp", pk_types, {}, {}, "Timestamp", "", ""),
+            ("table_ttl_Date", pk_types, {}, {}, "Date", "", ""),
+        ]
+    )
+    def test_select(self, table_name: str, pk_types: dict[str, str], all_types: dict[str, str], index: dict[str, str], ttl: str, unique: str, sync: str):
+        dml = DMLOperations(self)
+        dml.create_table(table_name, pk_types, all_types,
+                         index, ttl, unique, sync)
+        dml.insert(table_name, all_types, pk_types, index, ttl)
+        self.select_with(table_name, all_types, pk_types, index, ttl, dml)
+        self.order_by(table_name, all_types, pk_types, index, ttl, dml)
+        self.limit(table_name, all_types, pk_types, index, ttl, dml)
+        self.from_select(table_name, all_types, pk_types, index, ttl, dml)
+        self.distinct(table_name, all_types, pk_types, index, ttl, dml)
+        self.union(table_name, all_types, pk_types, index, ttl, dml)
+        self.without(table_name, all_types, pk_types, index, ttl)
+        self.tablesample_sample(table_name, all_types,
+                                pk_types, index, ttl, dml)
+
+    def limit(
+        self,
+        table_name: str,
+        all_types: dict[str, str],
+        pk_types: dict[str, str],
+        index: dict[str, str],
+        ttl: str,
+        dml: DMLOperations,
+    ):
+        statements = self.create_types_for_all_select(all_types, pk_types, index, ttl)
+
+        number_of_columns = self.get_number_of_columns(pk_types, all_types, index, ttl)
+
+        for offset in range(number_of_columns):
+            rows = self.query(f"select {", ".join(statements)} from {table_name} limit 1 OFFSET {offset}")
+            self.assert_type_after_select(offset + 1, 0, rows, all_types, pk_types, index, ttl, dml)
+
+    def create_types_for_all_select(
+        self, all_types: dict[str, str], pk_types: dict[str, str], index: dict[str, str], ttl: str
+    ):
+        statements = []
+        # delete if after https://github.com/ydb-platform/ydb/issues/16930
+        for type in all_types.keys():
+            if type != "Date32" and type != "Datetime64" and type != "Timestamp64" and type != 'Interval64':
+                statements.append(f"col_{cleanup_type_name(type)}")
+        for type in pk_types.keys():
+            if type != "Date32" and type != "Datetime64" and type != "Timestamp64" and type != 'Interval64':
+                statements.append(f"pk_{cleanup_type_name(type)}")
+        for type in index.keys():
+            if type != "Date32" and type != "Datetime64" and type != "Timestamp64" and type != 'Interval64':
+                statements.append(f"col_index_{cleanup_type_name(type)}")
+        if ttl != "":
+            statements.append(f"ttl_{cleanup_type_name(ttl)}")
+        return statements
+
+    def assert_type_after_select(
+        self,
+        value,
+        line,
+        rows,
+        all_types: dict[str, str],
+        pk_types: dict[str, str],
+        index: dict[str, str],
+        ttl: str,
+        dml: DMLOperations,
+    ):
+        count = 0
+        for type in all_types.keys():
+            if type != "Date32" and type != "Datetime64" and type != "Timestamp64" and type != 'Interval64':
+                dml.assert_type(all_types, type, value, rows[line][count])
+                count += 1
+        for type in pk_types.keys():
+            if type != "Date32" and type != "Datetime64" and type != "Timestamp64" and type != 'Interval64':
+                dml.assert_type(pk_types, type, value, rows[line][count])
+                count += 1
+        for type in index.keys():
+            if type != "Date32" and type != "Datetime64" and type != "Timestamp64" and type != 'Interval64':
+                dml.assert_type(index, type, value, rows[line][count])
+                count += 1
+        if ttl != "":
+            dml.assert_type(ttl_types, ttl, value, rows[line][count])
+            count += 1
+
+    def from_select(
+        self,
+        table_name: str,
+        all_types: dict[str, str],
+        pk_types: dict[str, str],
+        index: dict[str, str],
+        ttl: str,
+        dml: DMLOperations,
+    ):
+        statements = self.create_types_for_all_select(all_types, pk_types, index, ttl)
+
+        rows = self.query(f"from {table_name} select {", ".join(statements)}")
+        for i in range(len(rows)):
+            self.assert_type_after_select(i + 1, i, rows, all_types, pk_types, index, ttl, dml)
+
+    def distinct(
+        self,
+        table_name: str,
+        all_types: dict[str, str],
+        pk_types: dict[str, str],
+        index: dict[str, str],
+        ttl: str,
+        dml: DMLOperations,
+    ):
+        # del type != "DyNumber" and type != "UUID" after https://github.com/ydb-platform/ydb/issues/17484
+        for type in all_types.keys():
+            if (
+                type != "Date32"
+                and type != "Datetime64"
+                and type != "Timestamp64"
+                and type != 'Interval64'
+                and type != "DyNumber"
+                and type != "UUID"
+                and type != "Json"
+                and type != "JsonDocument"
+                and type != "Yson"
+            ):
+                rows_distinct = self.query(f"SELECT DISTINCT col_{cleanup_type_name(type)} from {table_name}")
+                for i in range(len(rows_distinct)):
+                    dml.assert_type(all_types, type, i + 1, rows_distinct[i][0])
+        for type in pk_types.keys():
+            if (
+                type != "Date32"
+                and type != "Datetime64"
+                and type != "Timestamp64"
+                and type != 'Interval64'
+                and type != "DyNumber"
+                and type != "UUID"
+            ):
+                rows_distinct = self.query(f"SELECT DISTINCT pk_{cleanup_type_name(type)} from {table_name}")
+                for i in range(len(rows_distinct)):
+                    dml.assert_type(pk_types, type, i + 1, rows_distinct[i][0])
+        for type in index.keys():
+            if (
+                type != "Date32"
+                and type != "Datetime64"
+                and type != "Timestamp64"
+                and type != 'Interval64'
+                and type != "DyNumber"
+                and type != "UUID"
+            ):
+                rows_distinct = self.query(f"SELECT DISTINCT col_index_{cleanup_type_name(type)} from {table_name}")
+                for i in range(len(rows_distinct)):
+                    dml.assert_type(index, type, i + 1, rows_distinct[i][0])
+        if ttl != "" and ttl != "DyNumber":
+            rows_distinct = self.query(f"SELECT DISTINCT ttl_{cleanup_type_name(ttl)} from {table_name}")
+            for i in range(len(rows_distinct)):
+                dml.assert_type(ttl_types, ttl, i + 1, rows_distinct[i][0])
+
+    def union(
+        self,
+        table_name: str,
+        all_types: dict[str, str],
+        pk_types: dict[str, str],
+        index: dict[str, str],
+        ttl: str,
+        dml: DMLOperations,
+    ):
+        statements = []
+        for type in all_types.keys():
+            if (
+                type != "Date32"
+                and type != "Datetime64"
+                and type != "Timestamp64"
+                and type != 'Interval64'
+                and type != "DyNumber"
+                and type != "UUID"
+                and type != "Json"
+                and type != "JsonDocument"
+                and type != "Yson"
+            ):
+                statements.append(f"col_{cleanup_type_name(type)}")
+        for type in pk_types.keys():
+            if (
+                type != "Date32"
+                and type != "Datetime64"
+                and type != "Timestamp64"
+                and type != 'Interval64'
+                and type != "DyNumber"
+                and type != "UUID"
+            ):
+                statements.append(f"pk_{cleanup_type_name(type)}")
+        for type in index.keys():
+            if (
+                type != "Date32"
+                and type != "Datetime64"
+                and type != "Timestamp64"
+                and type != 'Interval64'
+                and type != "DyNumber"
+                and type != "UUID"
+            ):
+                statements.append(f"col_index_{cleanup_type_name(type)}")
+        if ttl != "" and ttl != "DyNumber":
+            statements.append(f"ttl_{cleanup_type_name(ttl)}")
+        rows = self.query(
+            f"""
+                          select {", ".join(statements)} from {table_name}
+                          union
+                          select {", ".join(statements)} from {table_name}
+                          """
+        )
+        for type in all_types.keys():
+            if (
+                type != "Date32"
+                and type != "Datetime64"
+                and type != "Timestamp64"
+                and type != 'Interval64'
+                and type != "DyNumber"
+                and type != "UUID"
+                and type != "Json"
+                and type != "JsonDocument"
+                and type != "Yson"
+            ):
+                for line in range(len(rows)):
+                    dml.assert_type(all_types, type, line + 1, rows[line][f"col_{cleanup_type_name(type)}"])
+        for type in pk_types.keys():
+            if (
+                type != "Date32"
+                and type != "Datetime64"
+                and type != "Timestamp64"
+                and type != 'Interval64'
+                and type != "DyNumber"
+                and type != "UUID"
+            ):
+                for line in range(len(rows)):
+                    dml.assert_type(pk_types, type, line + 1, rows[line][f"pk_{cleanup_type_name(type)}"])
+        for type in index.keys():
+            if (
+                type != "Date32"
+                and type != "Datetime64"
+                and type != "Timestamp64"
+                and type != 'Interval64'
+                and type != "DyNumber"
+                and type != "UUID"
+            ):
+                for line in range(len(rows)):
+                    dml.assert_type(index, type, line + 1, rows[line][f"col_index_{cleanup_type_name(type)}"])
+        if ttl != "" and ttl != "DyNumber":
+            for line in range(len(rows)):
+                dml.assert_type(ttl_types, ttl, line + 1, rows[line][f"ttl_{cleanup_type_name(ttl)}"])
+
+    def select_with(
+        self,
+        table_name: str,
+        all_types: dict[str, str],
+        pk_types: dict[str, str],
+        index: dict[str, str],
+        ttl: str,
+        dml: DMLOperations,
+    ):
+        select_with_parameters = [
+            "INFER_SCHEMA",
+            "FORCE_INFER_SCHEMA",
+            "DIRECT_READ",
+            "INLINE",
+            "UNORDERED",
+            "XLOCK",
+            "IGNORETYPEV3",
+        ]
+        statements = self.create_types_for_all_select(all_types, pk_types, index, ttl)
+        for select_with_parameter in select_with_parameters:
+            select_with_sql_request = f"""
+                select {", ".join(statements)}
+                from {table_name}
+                with {select_with_parameter}
+            """
+            rows = dml.query(select_with_sql_request)
+            for i in range(len(rows)):
+                self.assert_type_after_select(i + 1, i, rows, all_types, pk_types, index, ttl, dml)
+
+    def without(
+        self, table_name: str, all_types: dict[str, str], pk_types: dict[str, str], index: dict[str, str], ttl: str
+    ):
+        statements_without = []
+        for type_name in all_types.keys():
+            if (
+                type_name == "Date32"
+                or type_name == "Datetime64"
+                or type_name == "Timestamp64"
+                or type_name == 'Interval64'
+            ):
+                statements_without.append(f"col_{cleanup_type_name(type_name)}")
+        for type_name in pk_types.keys():
+            if (
+                type_name == "Date32"
+                or type_name == "Datetime64"
+                or type_name == "Timestamp64"
+                or type_name == 'Interval64'
+            ):
+                statements_without.append(f"pk_{cleanup_type_name(type_name)}")
+        for type_name in index.keys():
+            if (
+                type_name == "Date32"
+                or type_name == "Datetime64"
+                or type_name == "Timestamp64"
+                or type_name == 'Interval64'
+            ):
+                statements_without.append(f"col_index_{cleanup_type_name(type_name)}")
+
+        for type_name in all_types.keys():
+            if (
+                type_name != "Date32"
+                and type_name != "Datetime64"
+                and type_name != "Timestamp64"
+                and type_name != 'Interval64'
+            ):
+                self.create_without(table_name, statements_without, f"col_{cleanup_type_name(type_name)}")
+        for type_name in pk_types.keys():
+            if (
+                type_name != "Date32"
+                and type_name != "Datetime64"
+                and type_name != "Timestamp64"
+                and type_name != 'Interval64'
+            ):
+                self.create_without(table_name, statements_without, f"pk_{cleanup_type_name(type_name)}")
+        for type_name in index.keys():
+            if (
+                type_name != "Date32"
+                and type_name != "Datetime64"
+                and type_name != "Timestamp64"
+                and type_name != 'Interval64'
+            ):
+                self.create_without(table_name, statements_without, f"col_index_{cleanup_type_name(type_name)}")
+        if ttl != "":
+            self.create_without(table_name, statements_without, f"ttl_{cleanup_type_name(ttl)}")
+
+    def create_without(self, table_name, statements_without, without):
+        rows = self.query(f"select * without {", ".join(statements_without)}, {without} from {table_name}")
+        for col_name in rows[0].keys():
+            assert col_name != without, f"a column {without} in the table {table_name} was not excluded"
+
+    def tablesample_sample(
+        self,
+        table_name: str,
+        all_types: dict[str, str],
+        pk_types: dict[str, str],
+        index: dict[str, str],
+        ttl: str,
+        dml: DMLOperations,
+    ):
+        statements = self.create_types_for_all_select(all_types, pk_types, index, ttl)
+        for i in range(1, 100):
+            rows = self.query(f"select {", ".join(statements)} from {table_name} TABLESAMPLE SYSTEM({i}.0)")
+            for line in range(len(rows)):
+                numb = rows[line]["pk_Int64"]
+                self.assert_type_after_select(numb, line, rows, all_types, pk_types, index, ttl, dml)
+
+            rows = self.query(
+                f"select {", ".join(statements)} from {table_name} TABLESAMPLE BERNOULLI({i}.0) REPEATABLE({i})"
+            )
+            for line in range(len(rows)):
+                numb = rows[line]["pk_Int64"]
+                self.assert_type_after_select(numb, line, rows, all_types, pk_types, index, ttl, dml)
+
+            rows = self.query(f"select {", ".join(statements)} from {table_name} SAMPLE 1.0 / {i}")
+            for line in range(len(rows)):
+                numb = rows[line]["pk_Int64"]
+                self.assert_type_after_select(numb, line, rows, all_types, pk_types, index, ttl, dml)
+
+    def order_by(
+        self,
+        table_name: str,
+        all_types: dict[str, str],
+        pk_types: dict[str, str],
+        index: dict[str, str],
+        ttl: str,
+        dml: DMLOperations,
+    ):
+        statements = self.create_types_for_all_select(all_types, pk_types, index, ttl)
+        for statement in statements:
+            if "Json" not in statement and "JsonDocument" not in statement and "Yson" not in statement:
+                rows = self.query(f"select {", ".join(statements)} from {table_name} ORDER BY {statement} ASC")
+                if "String" not in statement and "Utf8" not in statement:
+                    for line in range(len(rows)):
+                        self.assert_type_after_select(line + 1, line, rows, all_types, pk_types, index, ttl, dml)
+                else:
+                    line = 0
+                    for i in range(len(rows) // 10):
+                        self.assert_type_after_select(i + 1, line, rows, all_types, pk_types, index, ttl, dml)
+                        line += 1
+                        for j in range(10):
+                            if (i + 1) * 10 + j > len(rows):
+                                break
+                            self.assert_type_after_select(
+                                (i + 1) * 10 + j, line, rows, all_types, pk_types, index, ttl, dml
+                            )
+                            line += 1
+
+                rows = self.query(f"select {", ".join(statements)} from {table_name} ORDER BY {statement} DESC")
+
+                if "Bool" not in statement:
path: ydb/tests/datashard/select/test_select.py
user: login: lex007in
body: А почему с DESC не проверяется Bool?
created_at: 2025-05-16T14:02:29Z
author_association: COLLABORATOR
diff_hunk: @@ -0,0 +1,509 @@
+import pytest
+
+from ydb.tests.sql.lib.test_base import TestBase
+from ydb.tests.datashard.lib.dml_operations import DMLOperations
+from ydb.tests.datashard.lib.types_of_variables import (
+    cleanup_type_name,
+    format_sql_value,
+    pk_types,
+    non_pk_types,
+    index_first,
+    index_second,
+    ttl_types,
+    index_first_sync,
+    index_second_sync,
+    index_three_sync,
+    index_three_sync_not_Bool,
+    index_four_sync,
+    index_zero_sync,
+)
+
+
+class TestDML(TestBase):
+    @pytest.mark.parametrize(
+        "table_name, pk_types, all_types, index, ttl, unique, sync",
+        [
+            ("table_index_4_UNIQUE_SYNC", pk_types, {},
+             index_four_sync, "", "UNIQUE", "SYNC"),
+            ("table_index_3_UNIQUE_SYNC", pk_types, {},
+             index_three_sync_not_Bool, "", "UNIQUE", "SYNC"),
+            ("table_index_2_UNIQUE_SYNC", pk_types, {},
+             index_second_sync, "", "UNIQUE", "SYNC"),
+            ("table_index_1_UNIQUE_SYNC", pk_types, {},
+             index_first_sync, "", "UNIQUE", "SYNC"),
+            ("table_index_0_UNIQUE_SYNC", pk_types, {},
+             index_zero_sync, "", "UNIQUE", "SYNC"),
+            ("table_index_4__SYNC", pk_types, {},
+             index_four_sync, "", "", "SYNC"),
+            ("table_index_3__SYNC", pk_types, {},
+             index_three_sync, "", "", "SYNC"),
+            ("table_index_2__SYNC", pk_types, {},
+             index_second_sync, "", "", "SYNC"),
+            ("table_index_1__SYNC", pk_types, {},
+             index_first_sync, "", "", "SYNC"),
+            ("table_index_0__SYNC", pk_types, {},
+             index_zero_sync, "", "", "SYNC"),
+            ("table_index_1__ASYNC", pk_types, {}, index_second, "", "", "ASYNC"),
+            ("table_index_0__ASYNC", pk_types, {}, index_first, "", "", "ASYNC"),
+            ("table_all_types", pk_types, {
+             **pk_types, **non_pk_types}, {}, "", "", ""),
+            ("table_ttl_DyNumber", pk_types, {}, {}, "DyNumber", "", ""),
+            ("table_ttl_Uint32", pk_types, {}, {}, "Uint32", "", ""),
+            ("table_ttl_Uint64", pk_types, {}, {}, "Uint64", "", ""),
+            ("table_ttl_Datetime", pk_types, {}, {}, "Datetime", "", ""),
+            ("table_ttl_Timestamp", pk_types, {}, {}, "Timestamp", "", ""),
+            ("table_ttl_Date", pk_types, {}, {}, "Date", "", ""),
+        ]
+    )
+    def test_select(self, table_name: str, pk_types: dict[str, str], all_types: dict[str, str], index: dict[str, str], ttl: str, unique: str, sync: str):
+        dml = DMLOperations(self)
+        dml.create_table(table_name, pk_types, all_types,
+                         index, ttl, unique, sync)
+        dml.insert(table_name, all_types, pk_types, index, ttl)
+        self.select_with(table_name, all_types, pk_types, index, ttl, dml)
+        self.order_by(table_name, all_types, pk_types, index, ttl, dml)
+        self.limit(table_name, all_types, pk_types, index, ttl, dml)
+        self.from_select(table_name, all_types, pk_types, index, ttl, dml)
+        self.distinct(table_name, all_types, pk_types, index, ttl, dml)
+        self.union(table_name, all_types, pk_types, index, ttl, dml)
+        self.without(table_name, all_types, pk_types, index, ttl)
+        self.tablesample_sample(table_name, all_types,
+                                pk_types, index, ttl, dml)
+
+    def limit(
+        self,
+        table_name: str,
+        all_types: dict[str, str],
+        pk_types: dict[str, str],
+        index: dict[str, str],
+        ttl: str,
+        dml: DMLOperations,
+    ):
+        statements = self.create_types_for_all_select(all_types, pk_types, index, ttl)
+
+        number_of_columns = self.get_number_of_columns(pk_types, all_types, index, ttl)
+
+        for offset in range(number_of_columns):
+            rows = self.query(f"select {", ".join(statements)} from {table_name} limit 1 OFFSET {offset}")
+            self.assert_type_after_select(offset + 1, 0, rows, all_types, pk_types, index, ttl, dml)
+
+    def create_types_for_all_select(
+        self, all_types: dict[str, str], pk_types: dict[str, str], index: dict[str, str], ttl: str
+    ):
+        statements = []
+        # delete if after https://github.com/ydb-platform/ydb/issues/16930
+        for type in all_types.keys():
+            if type != "Date32" and type != "Datetime64" and type != "Timestamp64" and type != 'Interval64':
+                statements.append(f"col_{cleanup_type_name(type)}")
+        for type in pk_types.keys():
+            if type != "Date32" and type != "Datetime64" and type != "Timestamp64" and type != 'Interval64':
+                statements.append(f"pk_{cleanup_type_name(type)}")
+        for type in index.keys():
+            if type != "Date32" and type != "Datetime64" and type != "Timestamp64" and type != 'Interval64':
+                statements.append(f"col_index_{cleanup_type_name(type)}")
+        if ttl != "":
+            statements.append(f"ttl_{cleanup_type_name(ttl)}")
+        return statements
+
+    def assert_type_after_select(
+        self,
+        value,
+        line,
+        rows,
+        all_types: dict[str, str],
+        pk_types: dict[str, str],
+        index: dict[str, str],
+        ttl: str,
+        dml: DMLOperations,
+    ):
+        count = 0
+        for type in all_types.keys():
+            if type != "Date32" and type != "Datetime64" and type != "Timestamp64" and type != 'Interval64':
+                dml.assert_type(all_types, type, value, rows[line][count])
+                count += 1
+        for type in pk_types.keys():
+            if type != "Date32" and type != "Datetime64" and type != "Timestamp64" and type != 'Interval64':
+                dml.assert_type(pk_types, type, value, rows[line][count])
path: ydb/tests/datashard/select/test_select.py
user: login: dennnniska
body: сделал 
created_at: 2025-05-18T12:53:34Z
author_association: CONTRIBUTOR
diff_hunk: @@ -0,0 +1,509 @@
+import pytest
+
+from ydb.tests.sql.lib.test_base import TestBase
+from ydb.tests.datashard.lib.dml_operations import DMLOperations
+from ydb.tests.datashard.lib.types_of_variables import (
+    cleanup_type_name,
+    format_sql_value,
+    pk_types,
+    non_pk_types,
+    index_first,
+    index_second,
+    ttl_types,
+    index_first_sync,
+    index_second_sync,
+    index_three_sync,
+    index_three_sync_not_Bool,
+    index_four_sync,
+    index_zero_sync,
+)
+
+
+class TestDML(TestBase):
+    @pytest.mark.parametrize(
+        "table_name, pk_types, all_types, index, ttl, unique, sync",
+        [
+            ("table_index_4_UNIQUE_SYNC", pk_types, {},
+             index_four_sync, "", "UNIQUE", "SYNC"),
+            ("table_index_3_UNIQUE_SYNC", pk_types, {},
+             index_three_sync_not_Bool, "", "UNIQUE", "SYNC"),
+            ("table_index_2_UNIQUE_SYNC", pk_types, {},
+             index_second_sync, "", "UNIQUE", "SYNC"),
+            ("table_index_1_UNIQUE_SYNC", pk_types, {},
+             index_first_sync, "", "UNIQUE", "SYNC"),
+            ("table_index_0_UNIQUE_SYNC", pk_types, {},
+             index_zero_sync, "", "UNIQUE", "SYNC"),
+            ("table_index_4__SYNC", pk_types, {},
+             index_four_sync, "", "", "SYNC"),
+            ("table_index_3__SYNC", pk_types, {},
+             index_three_sync, "", "", "SYNC"),
+            ("table_index_2__SYNC", pk_types, {},
+             index_second_sync, "", "", "SYNC"),
+            ("table_index_1__SYNC", pk_types, {},
+             index_first_sync, "", "", "SYNC"),
+            ("table_index_0__SYNC", pk_types, {},
+             index_zero_sync, "", "", "SYNC"),
+            ("table_index_1__ASYNC", pk_types, {}, index_second, "", "", "ASYNC"),
+            ("table_index_0__ASYNC", pk_types, {}, index_first, "", "", "ASYNC"),
+            ("table_all_types", pk_types, {
+             **pk_types, **non_pk_types}, {}, "", "", ""),
+            ("table_ttl_DyNumber", pk_types, {}, {}, "DyNumber", "", ""),
+            ("table_ttl_Uint32", pk_types, {}, {}, "Uint32", "", ""),
+            ("table_ttl_Uint64", pk_types, {}, {}, "Uint64", "", ""),
+            ("table_ttl_Datetime", pk_types, {}, {}, "Datetime", "", ""),
+            ("table_ttl_Timestamp", pk_types, {}, {}, "Timestamp", "", ""),
+            ("table_ttl_Date", pk_types, {}, {}, "Date", "", ""),
+        ]
+    )
+    def test_select(self, table_name: str, pk_types: dict[str, str], all_types: dict[str, str], index: dict[str, str], ttl: str, unique: str, sync: str):
+        dml = DMLOperations(self)
+        dml.create_table(table_name, pk_types, all_types,
+                         index, ttl, unique, sync)
+        dml.insert(table_name, all_types, pk_types, index, ttl)
+        self.select_with(table_name, all_types, pk_types, index, ttl, dml)
+        self.order_by(table_name, all_types, pk_types, index, ttl, dml)
+        self.limit(table_name, all_types, pk_types, index, ttl, dml)
+        self.from_select(table_name, all_types, pk_types, index, ttl, dml)
+        self.distinct(table_name, all_types, pk_types, index, ttl, dml)
+        self.union(table_name, all_types, pk_types, index, ttl, dml)
+        self.without(table_name, all_types, pk_types, index, ttl)
+        self.tablesample_sample(table_name, all_types,
+                                pk_types, index, ttl, dml)
+
+    def limit(
+        self,
+        table_name: str,
+        all_types: dict[str, str],
+        pk_types: dict[str, str],
+        index: dict[str, str],
+        ttl: str,
+        dml: DMLOperations,
+    ):
+        statements = self.create_types_for_all_select(all_types, pk_types, index, ttl)
+
+        number_of_columns = self.get_number_of_columns(pk_types, all_types, index, ttl)
+
+        for offset in range(number_of_columns):
+            rows = self.query(f"select {", ".join(statements)} from {table_name} limit 1 OFFSET {offset}")
+            self.assert_type_after_select(offset + 1, 0, rows, all_types, pk_types, index, ttl, dml)
+
+    def create_types_for_all_select(
+        self, all_types: dict[str, str], pk_types: dict[str, str], index: dict[str, str], ttl: str
+    ):
+        statements = []
+        # delete if after https://github.com/ydb-platform/ydb/issues/16930
+        for type in all_types.keys():
+            if type != "Date32" and type != "Datetime64" and type != "Timestamp64" and type != 'Interval64':
+                statements.append(f"col_{cleanup_type_name(type)}")
+        for type in pk_types.keys():
+            if type != "Date32" and type != "Datetime64" and type != "Timestamp64" and type != 'Interval64':
+                statements.append(f"pk_{cleanup_type_name(type)}")
+        for type in index.keys():
+            if type != "Date32" and type != "Datetime64" and type != "Timestamp64" and type != 'Interval64':
+                statements.append(f"col_index_{cleanup_type_name(type)}")
+        if ttl != "":
+            statements.append(f"ttl_{cleanup_type_name(ttl)}")
+        return statements
+
+    def assert_type_after_select(
+        self,
+        value,
+        line,
+        rows,
+        all_types: dict[str, str],
+        pk_types: dict[str, str],
+        index: dict[str, str],
+        ttl: str,
+        dml: DMLOperations,
+    ):
+        count = 0
+        for type in all_types.keys():
+            if type != "Date32" and type != "Datetime64" and type != "Timestamp64" and type != 'Interval64':
+                dml.assert_type(all_types, type, value, rows[line][count])
+                count += 1
+        for type in pk_types.keys():
+            if type != "Date32" and type != "Datetime64" and type != "Timestamp64" and type != 'Interval64':
+                dml.assert_type(pk_types, type, value, rows[line][count])
+                count += 1
+        for type in index.keys():
+            if type != "Date32" and type != "Datetime64" and type != "Timestamp64" and type != 'Interval64':
+                dml.assert_type(index, type, value, rows[line][count])
+                count += 1
+        if ttl != "":
+            dml.assert_type(ttl_types, ttl, value, rows[line][count])
+            count += 1
+
+    def from_select(
+        self,
+        table_name: str,
+        all_types: dict[str, str],
+        pk_types: dict[str, str],
+        index: dict[str, str],
+        ttl: str,
+        dml: DMLOperations,
+    ):
+        statements = self.create_types_for_all_select(all_types, pk_types, index, ttl)
+
+        rows = self.query(f"from {table_name} select {", ".join(statements)}")
+        for i in range(len(rows)):
+            self.assert_type_after_select(i + 1, i, rows, all_types, pk_types, index, ttl, dml)
+
+    def distinct(
+        self,
+        table_name: str,
+        all_types: dict[str, str],
+        pk_types: dict[str, str],
+        index: dict[str, str],
+        ttl: str,
+        dml: DMLOperations,
+    ):
+        # del type != "DyNumber" and type != "UUID" after https://github.com/ydb-platform/ydb/issues/17484
+        for type in all_types.keys():
+            if (
+                type != "Date32"
+                and type != "Datetime64"
+                and type != "Timestamp64"
+                and type != 'Interval64'
+                and type != "DyNumber"
+                and type != "UUID"
+                and type != "Json"
+                and type != "JsonDocument"
+                and type != "Yson"
+            ):
+                rows_distinct = self.query(f"SELECT DISTINCT col_{cleanup_type_name(type)} from {table_name}")
+                for i in range(len(rows_distinct)):
+                    dml.assert_type(all_types, type, i + 1, rows_distinct[i][0])
+        for type in pk_types.keys():
+            if (
+                type != "Date32"
+                and type != "Datetime64"
+                and type != "Timestamp64"
+                and type != 'Interval64'
+                and type != "DyNumber"
+                and type != "UUID"
+            ):
+                rows_distinct = self.query(f"SELECT DISTINCT pk_{cleanup_type_name(type)} from {table_name}")
+                for i in range(len(rows_distinct)):
+                    dml.assert_type(pk_types, type, i + 1, rows_distinct[i][0])
+        for type in index.keys():
+            if (
+                type != "Date32"
+                and type != "Datetime64"
+                and type != "Timestamp64"
+                and type != 'Interval64'
+                and type != "DyNumber"
+                and type != "UUID"
+            ):
+                rows_distinct = self.query(f"SELECT DISTINCT col_index_{cleanup_type_name(type)} from {table_name}")
+                for i in range(len(rows_distinct)):
+                    dml.assert_type(index, type, i + 1, rows_distinct[i][0])
+        if ttl != "" and ttl != "DyNumber":
+            rows_distinct = self.query(f"SELECT DISTINCT ttl_{cleanup_type_name(ttl)} from {table_name}")
+            for i in range(len(rows_distinct)):
+                dml.assert_type(ttl_types, ttl, i + 1, rows_distinct[i][0])
+
+    def union(
+        self,
+        table_name: str,
+        all_types: dict[str, str],
+        pk_types: dict[str, str],
+        index: dict[str, str],
+        ttl: str,
+        dml: DMLOperations,
+    ):
+        statements = []
+        for type in all_types.keys():
+            if (
+                type != "Date32"
+                and type != "Datetime64"
+                and type != "Timestamp64"
+                and type != 'Interval64'
+                and type != "DyNumber"
+                and type != "UUID"
+                and type != "Json"
+                and type != "JsonDocument"
+                and type != "Yson"
+            ):
+                statements.append(f"col_{cleanup_type_name(type)}")
+        for type in pk_types.keys():
+            if (
+                type != "Date32"
+                and type != "Datetime64"
+                and type != "Timestamp64"
+                and type != 'Interval64'
+                and type != "DyNumber"
+                and type != "UUID"
+            ):
+                statements.append(f"pk_{cleanup_type_name(type)}")
+        for type in index.keys():
+            if (
+                type != "Date32"
+                and type != "Datetime64"
+                and type != "Timestamp64"
+                and type != 'Interval64'
+                and type != "DyNumber"
+                and type != "UUID"
+            ):
+                statements.append(f"col_index_{cleanup_type_name(type)}")
+        if ttl != "" and ttl != "DyNumber":
+            statements.append(f"ttl_{cleanup_type_name(ttl)}")
+        rows = self.query(
+            f"""
+                          select {", ".join(statements)} from {table_name}
+                          union
+                          select {", ".join(statements)} from {table_name}
+                          """
+        )
+        for type in all_types.keys():
+            if (
+                type != "Date32"
+                and type != "Datetime64"
+                and type != "Timestamp64"
+                and type != 'Interval64'
+                and type != "DyNumber"
+                and type != "UUID"
+                and type != "Json"
+                and type != "JsonDocument"
+                and type != "Yson"
+            ):
+                for line in range(len(rows)):
+                    dml.assert_type(all_types, type, line + 1, rows[line][f"col_{cleanup_type_name(type)}"])
+        for type in pk_types.keys():
+            if (
+                type != "Date32"
+                and type != "Datetime64"
+                and type != "Timestamp64"
+                and type != 'Interval64'
+                and type != "DyNumber"
+                and type != "UUID"
+            ):
+                for line in range(len(rows)):
+                    dml.assert_type(pk_types, type, line + 1, rows[line][f"pk_{cleanup_type_name(type)}"])
+        for type in index.keys():
+            if (
+                type != "Date32"
+                and type != "Datetime64"
+                and type != "Timestamp64"
+                and type != 'Interval64'
+                and type != "DyNumber"
+                and type != "UUID"
+            ):
+                for line in range(len(rows)):
+                    dml.assert_type(index, type, line + 1, rows[line][f"col_index_{cleanup_type_name(type)}"])
+        if ttl != "" and ttl != "DyNumber":
+            for line in range(len(rows)):
+                dml.assert_type(ttl_types, ttl, line + 1, rows[line][f"ttl_{cleanup_type_name(ttl)}"])
+
+    def select_with(
+        self,
+        table_name: str,
+        all_types: dict[str, str],
+        pk_types: dict[str, str],
+        index: dict[str, str],
+        ttl: str,
+        dml: DMLOperations,
+    ):
+        select_with_parameters = [
+            "INFER_SCHEMA",
+            "FORCE_INFER_SCHEMA",
+            "DIRECT_READ",
+            "INLINE",
+            "UNORDERED",
+            "XLOCK",
+            "IGNORETYPEV3",
+        ]
+        statements = self.create_types_for_all_select(all_types, pk_types, index, ttl)
+        for select_with_parameter in select_with_parameters:
+            select_with_sql_request = f"""
+                select {", ".join(statements)}
+                from {table_name}
+                with {select_with_parameter}
+            """
+            rows = dml.query(select_with_sql_request)
+            for i in range(len(rows)):
+                self.assert_type_after_select(i + 1, i, rows, all_types, pk_types, index, ttl, dml)
path: ydb/tests/datashard/select/test_select.py
user: login: dennnniska
body: Поменял 
created_at: 2025-05-18T12:53:42Z
author_association: CONTRIBUTOR
diff_hunk: @@ -0,0 +1,509 @@
+import pytest
+
+from ydb.tests.sql.lib.test_base import TestBase
+from ydb.tests.datashard.lib.dml_operations import DMLOperations
+from ydb.tests.datashard.lib.types_of_variables import (
+    cleanup_type_name,
+    format_sql_value,
+    pk_types,
+    non_pk_types,
+    index_first,
+    index_second,
+    ttl_types,
+    index_first_sync,
+    index_second_sync,
+    index_three_sync,
+    index_three_sync_not_Bool,
+    index_four_sync,
+    index_zero_sync,
+)
+
+
+class TestDML(TestBase):
+    @pytest.mark.parametrize(
+        "table_name, pk_types, all_types, index, ttl, unique, sync",
+        [
+            ("table_index_4_UNIQUE_SYNC", pk_types, {},
+             index_four_sync, "", "UNIQUE", "SYNC"),
+            ("table_index_3_UNIQUE_SYNC", pk_types, {},
+             index_three_sync_not_Bool, "", "UNIQUE", "SYNC"),
+            ("table_index_2_UNIQUE_SYNC", pk_types, {},
+             index_second_sync, "", "UNIQUE", "SYNC"),
+            ("table_index_1_UNIQUE_SYNC", pk_types, {},
+             index_first_sync, "", "UNIQUE", "SYNC"),
+            ("table_index_0_UNIQUE_SYNC", pk_types, {},
+             index_zero_sync, "", "UNIQUE", "SYNC"),
+            ("table_index_4__SYNC", pk_types, {},
+             index_four_sync, "", "", "SYNC"),
+            ("table_index_3__SYNC", pk_types, {},
+             index_three_sync, "", "", "SYNC"),
+            ("table_index_2__SYNC", pk_types, {},
+             index_second_sync, "", "", "SYNC"),
+            ("table_index_1__SYNC", pk_types, {},
+             index_first_sync, "", "", "SYNC"),
+            ("table_index_0__SYNC", pk_types, {},
+             index_zero_sync, "", "", "SYNC"),
+            ("table_index_1__ASYNC", pk_types, {}, index_second, "", "", "ASYNC"),
+            ("table_index_0__ASYNC", pk_types, {}, index_first, "", "", "ASYNC"),
+            ("table_all_types", pk_types, {
+             **pk_types, **non_pk_types}, {}, "", "", ""),
+            ("table_ttl_DyNumber", pk_types, {}, {}, "DyNumber", "", ""),
+            ("table_ttl_Uint32", pk_types, {}, {}, "Uint32", "", ""),
+            ("table_ttl_Uint64", pk_types, {}, {}, "Uint64", "", ""),
+            ("table_ttl_Datetime", pk_types, {}, {}, "Datetime", "", ""),
+            ("table_ttl_Timestamp", pk_types, {}, {}, "Timestamp", "", ""),
+            ("table_ttl_Date", pk_types, {}, {}, "Date", "", ""),
+        ]
+    )
+    def test_select(self, table_name: str, pk_types: dict[str, str], all_types: dict[str, str], index: dict[str, str], ttl: str, unique: str, sync: str):
+        dml = DMLOperations(self)
+        dml.create_table(table_name, pk_types, all_types,
+                         index, ttl, unique, sync)
+        dml.insert(table_name, all_types, pk_types, index, ttl)
+        self.select_with(table_name, all_types, pk_types, index, ttl, dml)
+        self.order_by(table_name, all_types, pk_types, index, ttl, dml)
+        self.limit(table_name, all_types, pk_types, index, ttl, dml)
+        self.from_select(table_name, all_types, pk_types, index, ttl, dml)
+        self.distinct(table_name, all_types, pk_types, index, ttl, dml)
+        self.union(table_name, all_types, pk_types, index, ttl, dml)
+        self.without(table_name, all_types, pk_types, index, ttl)
+        self.tablesample_sample(table_name, all_types,
+                                pk_types, index, ttl, dml)
+
+    def limit(
+        self,
+        table_name: str,
+        all_types: dict[str, str],
+        pk_types: dict[str, str],
+        index: dict[str, str],
+        ttl: str,
+        dml: DMLOperations,
+    ):
+        statements = self.create_types_for_all_select(all_types, pk_types, index, ttl)
+
+        number_of_columns = self.get_number_of_columns(pk_types, all_types, index, ttl)
+
+        for offset in range(number_of_columns):
+            rows = self.query(f"select {", ".join(statements)} from {table_name} limit 1 OFFSET {offset}")
+            self.assert_type_after_select(offset + 1, 0, rows, all_types, pk_types, index, ttl, dml)
+
+    def create_types_for_all_select(
+        self, all_types: dict[str, str], pk_types: dict[str, str], index: dict[str, str], ttl: str
+    ):
+        statements = []
+        # delete if after https://github.com/ydb-platform/ydb/issues/16930
+        for type in all_types.keys():
+            if type != "Date32" and type != "Datetime64" and type != "Timestamp64" and type != 'Interval64':
+                statements.append(f"col_{cleanup_type_name(type)}")
+        for type in pk_types.keys():
+            if type != "Date32" and type != "Datetime64" and type != "Timestamp64" and type != 'Interval64':
+                statements.append(f"pk_{cleanup_type_name(type)}")
+        for type in index.keys():
+            if type != "Date32" and type != "Datetime64" and type != "Timestamp64" and type != 'Interval64':
+                statements.append(f"col_index_{cleanup_type_name(type)}")
+        if ttl != "":
+            statements.append(f"ttl_{cleanup_type_name(ttl)}")
+        return statements
+
+    def assert_type_after_select(
+        self,
+        value,
+        line,
+        rows,
+        all_types: dict[str, str],
+        pk_types: dict[str, str],
+        index: dict[str, str],
+        ttl: str,
+        dml: DMLOperations,
+    ):
+        count = 0
+        for type in all_types.keys():
+            if type != "Date32" and type != "Datetime64" and type != "Timestamp64" and type != 'Interval64':
+                dml.assert_type(all_types, type, value, rows[line][count])
+                count += 1
+        for type in pk_types.keys():
+            if type != "Date32" and type != "Datetime64" and type != "Timestamp64" and type != 'Interval64':
+                dml.assert_type(pk_types, type, value, rows[line][count])
+                count += 1
+        for type in index.keys():
+            if type != "Date32" and type != "Datetime64" and type != "Timestamp64" and type != 'Interval64':
+                dml.assert_type(index, type, value, rows[line][count])
+                count += 1
+        if ttl != "":
+            dml.assert_type(ttl_types, ttl, value, rows[line][count])
+            count += 1
+
+    def from_select(
+        self,
+        table_name: str,
+        all_types: dict[str, str],
+        pk_types: dict[str, str],
+        index: dict[str, str],
+        ttl: str,
+        dml: DMLOperations,
+    ):
+        statements = self.create_types_for_all_select(all_types, pk_types, index, ttl)
+
+        rows = self.query(f"from {table_name} select {", ".join(statements)}")
+        for i in range(len(rows)):
+            self.assert_type_after_select(i + 1, i, rows, all_types, pk_types, index, ttl, dml)
+
+    def distinct(
+        self,
+        table_name: str,
+        all_types: dict[str, str],
+        pk_types: dict[str, str],
+        index: dict[str, str],
+        ttl: str,
+        dml: DMLOperations,
+    ):
+        # del type != "DyNumber" and type != "UUID" after https://github.com/ydb-platform/ydb/issues/17484
+        for type in all_types.keys():
+            if (
+                type != "Date32"
+                and type != "Datetime64"
+                and type != "Timestamp64"
+                and type != 'Interval64'
+                and type != "DyNumber"
+                and type != "UUID"
+                and type != "Json"
+                and type != "JsonDocument"
+                and type != "Yson"
+            ):
path: ydb/tests/datashard/select/test_select.py
user: login: dennnniska
body: Сделал 
created_at: 2025-05-18T12:54:11Z
author_association: CONTRIBUTOR
diff_hunk: @@ -0,0 +1,509 @@
+import pytest
+
+from ydb.tests.sql.lib.test_base import TestBase
+from ydb.tests.datashard.lib.dml_operations import DMLOperations
+from ydb.tests.datashard.lib.types_of_variables import (
+    cleanup_type_name,
+    format_sql_value,
+    pk_types,
+    non_pk_types,
+    index_first,
+    index_second,
+    ttl_types,
+    index_first_sync,
+    index_second_sync,
+    index_three_sync,
+    index_three_sync_not_Bool,
+    index_four_sync,
+    index_zero_sync,
+)
+
+
+class TestDML(TestBase):
+    @pytest.mark.parametrize(
+        "table_name, pk_types, all_types, index, ttl, unique, sync",
+        [
+            ("table_index_4_UNIQUE_SYNC", pk_types, {},
+             index_four_sync, "", "UNIQUE", "SYNC"),
+            ("table_index_3_UNIQUE_SYNC", pk_types, {},
+             index_three_sync_not_Bool, "", "UNIQUE", "SYNC"),
+            ("table_index_2_UNIQUE_SYNC", pk_types, {},
+             index_second_sync, "", "UNIQUE", "SYNC"),
+            ("table_index_1_UNIQUE_SYNC", pk_types, {},
+             index_first_sync, "", "UNIQUE", "SYNC"),
+            ("table_index_0_UNIQUE_SYNC", pk_types, {},
+             index_zero_sync, "", "UNIQUE", "SYNC"),
+            ("table_index_4__SYNC", pk_types, {},
+             index_four_sync, "", "", "SYNC"),
+            ("table_index_3__SYNC", pk_types, {},
+             index_three_sync, "", "", "SYNC"),
+            ("table_index_2__SYNC", pk_types, {},
+             index_second_sync, "", "", "SYNC"),
+            ("table_index_1__SYNC", pk_types, {},
+             index_first_sync, "", "", "SYNC"),
+            ("table_index_0__SYNC", pk_types, {},
+             index_zero_sync, "", "", "SYNC"),
+            ("table_index_1__ASYNC", pk_types, {}, index_second, "", "", "ASYNC"),
+            ("table_index_0__ASYNC", pk_types, {}, index_first, "", "", "ASYNC"),
+            ("table_all_types", pk_types, {
+             **pk_types, **non_pk_types}, {}, "", "", ""),
+            ("table_ttl_DyNumber", pk_types, {}, {}, "DyNumber", "", ""),
+            ("table_ttl_Uint32", pk_types, {}, {}, "Uint32", "", ""),
+            ("table_ttl_Uint64", pk_types, {}, {}, "Uint64", "", ""),
+            ("table_ttl_Datetime", pk_types, {}, {}, "Datetime", "", ""),
+            ("table_ttl_Timestamp", pk_types, {}, {}, "Timestamp", "", ""),
+            ("table_ttl_Date", pk_types, {}, {}, "Date", "", ""),
+        ]
+    )
+    def test_select(self, table_name: str, pk_types: dict[str, str], all_types: dict[str, str], index: dict[str, str], ttl: str, unique: str, sync: str):
+        dml = DMLOperations(self)
+        dml.create_table(table_name, pk_types, all_types,
+                         index, ttl, unique, sync)
+        dml.insert(table_name, all_types, pk_types, index, ttl)
+        self.select_with(table_name, all_types, pk_types, index, ttl, dml)
+        self.order_by(table_name, all_types, pk_types, index, ttl, dml)
+        self.limit(table_name, all_types, pk_types, index, ttl, dml)
+        self.from_select(table_name, all_types, pk_types, index, ttl, dml)
+        self.distinct(table_name, all_types, pk_types, index, ttl, dml)
+        self.union(table_name, all_types, pk_types, index, ttl, dml)
+        self.without(table_name, all_types, pk_types, index, ttl)
+        self.tablesample_sample(table_name, all_types,
+                                pk_types, index, ttl, dml)
+
+    def limit(
+        self,
+        table_name: str,
+        all_types: dict[str, str],
+        pk_types: dict[str, str],
+        index: dict[str, str],
+        ttl: str,
+        dml: DMLOperations,
+    ):
+        statements = self.create_types_for_all_select(all_types, pk_types, index, ttl)
+
+        number_of_columns = self.get_number_of_columns(pk_types, all_types, index, ttl)
+
+        for offset in range(number_of_columns):
+            rows = self.query(f"select {", ".join(statements)} from {table_name} limit 1 OFFSET {offset}")
+            self.assert_type_after_select(offset + 1, 0, rows, all_types, pk_types, index, ttl, dml)
+
+    def create_types_for_all_select(
+        self, all_types: dict[str, str], pk_types: dict[str, str], index: dict[str, str], ttl: str
+    ):
+        statements = []
+        # delete if after https://github.com/ydb-platform/ydb/issues/16930
+        for type in all_types.keys():
+            if type != "Date32" and type != "Datetime64" and type != "Timestamp64" and type != 'Interval64':
+                statements.append(f"col_{cleanup_type_name(type)}")
+        for type in pk_types.keys():
+            if type != "Date32" and type != "Datetime64" and type != "Timestamp64" and type != 'Interval64':
+                statements.append(f"pk_{cleanup_type_name(type)}")
+        for type in index.keys():
+            if type != "Date32" and type != "Datetime64" and type != "Timestamp64" and type != 'Interval64':
+                statements.append(f"col_index_{cleanup_type_name(type)}")
+        if ttl != "":
+            statements.append(f"ttl_{cleanup_type_name(ttl)}")
+        return statements
+
+    def assert_type_after_select(
+        self,
+        value,
+        line,
+        rows,
+        all_types: dict[str, str],
+        pk_types: dict[str, str],
+        index: dict[str, str],
+        ttl: str,
+        dml: DMLOperations,
+    ):
+        count = 0
+        for type in all_types.keys():
+            if type != "Date32" and type != "Datetime64" and type != "Timestamp64" and type != 'Interval64':
+                dml.assert_type(all_types, type, value, rows[line][count])
+                count += 1
+        for type in pk_types.keys():
+            if type != "Date32" and type != "Datetime64" and type != "Timestamp64" and type != 'Interval64':
+                dml.assert_type(pk_types, type, value, rows[line][count])
+                count += 1
+        for type in index.keys():
+            if type != "Date32" and type != "Datetime64" and type != "Timestamp64" and type != 'Interval64':
+                dml.assert_type(index, type, value, rows[line][count])
+                count += 1
+        if ttl != "":
+            dml.assert_type(ttl_types, ttl, value, rows[line][count])
+            count += 1
+
+    def from_select(
+        self,
+        table_name: str,
+        all_types: dict[str, str],
+        pk_types: dict[str, str],
+        index: dict[str, str],
+        ttl: str,
+        dml: DMLOperations,
+    ):
+        statements = self.create_types_for_all_select(all_types, pk_types, index, ttl)
+
+        rows = self.query(f"from {table_name} select {", ".join(statements)}")
+        for i in range(len(rows)):
+            self.assert_type_after_select(i + 1, i, rows, all_types, pk_types, index, ttl, dml)
+
+    def distinct(
+        self,
+        table_name: str,
+        all_types: dict[str, str],
+        pk_types: dict[str, str],
+        index: dict[str, str],
+        ttl: str,
+        dml: DMLOperations,
+    ):
+        # del type != "DyNumber" and type != "UUID" after https://github.com/ydb-platform/ydb/issues/17484
+        for type in all_types.keys():
+            if (
+                type != "Date32"
+                and type != "Datetime64"
+                and type != "Timestamp64"
+                and type != 'Interval64'
+                and type != "DyNumber"
+                and type != "UUID"
+                and type != "Json"
+                and type != "JsonDocument"
+                and type != "Yson"
+            ):
+                rows_distinct = self.query(f"SELECT DISTINCT col_{cleanup_type_name(type)} from {table_name}")
+                for i in range(len(rows_distinct)):
+                    dml.assert_type(all_types, type, i + 1, rows_distinct[i][0])
+        for type in pk_types.keys():
+            if (
+                type != "Date32"
+                and type != "Datetime64"
+                and type != "Timestamp64"
+                and type != 'Interval64'
+                and type != "DyNumber"
+                and type != "UUID"
+            ):
+                rows_distinct = self.query(f"SELECT DISTINCT pk_{cleanup_type_name(type)} from {table_name}")
+                for i in range(len(rows_distinct)):
+                    dml.assert_type(pk_types, type, i + 1, rows_distinct[i][0])
+        for type in index.keys():
+            if (
+                type != "Date32"
+                and type != "Datetime64"
+                and type != "Timestamp64"
+                and type != 'Interval64'
+                and type != "DyNumber"
+                and type != "UUID"
+            ):
+                rows_distinct = self.query(f"SELECT DISTINCT col_index_{cleanup_type_name(type)} from {table_name}")
+                for i in range(len(rows_distinct)):
+                    dml.assert_type(index, type, i + 1, rows_distinct[i][0])
+        if ttl != "" and ttl != "DyNumber":
+            rows_distinct = self.query(f"SELECT DISTINCT ttl_{cleanup_type_name(ttl)} from {table_name}")
+            for i in range(len(rows_distinct)):
+                dml.assert_type(ttl_types, ttl, i + 1, rows_distinct[i][0])
+
+    def union(
+        self,
+        table_name: str,
+        all_types: dict[str, str],
+        pk_types: dict[str, str],
+        index: dict[str, str],
+        ttl: str,
+        dml: DMLOperations,
+    ):
+        statements = []
+        for type in all_types.keys():
+            if (
+                type != "Date32"
+                and type != "Datetime64"
+                and type != "Timestamp64"
+                and type != 'Interval64'
+                and type != "DyNumber"
+                and type != "UUID"
+                and type != "Json"
+                and type != "JsonDocument"
+                and type != "Yson"
+            ):
+                statements.append(f"col_{cleanup_type_name(type)}")
+        for type in pk_types.keys():
+            if (
+                type != "Date32"
+                and type != "Datetime64"
+                and type != "Timestamp64"
+                and type != 'Interval64'
+                and type != "DyNumber"
+                and type != "UUID"
+            ):
+                statements.append(f"pk_{cleanup_type_name(type)}")
+        for type in index.keys():
+            if (
+                type != "Date32"
+                and type != "Datetime64"
+                and type != "Timestamp64"
+                and type != 'Interval64'
+                and type != "DyNumber"
+                and type != "UUID"
+            ):
+                statements.append(f"col_index_{cleanup_type_name(type)}")
+        if ttl != "" and ttl != "DyNumber":
+            statements.append(f"ttl_{cleanup_type_name(ttl)}")
+        rows = self.query(
+            f"""
+                          select {", ".join(statements)} from {table_name}
+                          union
+                          select {", ".join(statements)} from {table_name}
+                          """
+        )
+        for type in all_types.keys():
+            if (
+                type != "Date32"
+                and type != "Datetime64"
+                and type != "Timestamp64"
+                and type != 'Interval64'
+                and type != "DyNumber"
+                and type != "UUID"
+                and type != "Json"
+                and type != "JsonDocument"
+                and type != "Yson"
+            ):
+                for line in range(len(rows)):
+                    dml.assert_type(all_types, type, line + 1, rows[line][f"col_{cleanup_type_name(type)}"])
+        for type in pk_types.keys():
+            if (
+                type != "Date32"
+                and type != "Datetime64"
+                and type != "Timestamp64"
+                and type != 'Interval64'
+                and type != "DyNumber"
+                and type != "UUID"
+            ):
+                for line in range(len(rows)):
+                    dml.assert_type(pk_types, type, line + 1, rows[line][f"pk_{cleanup_type_name(type)}"])
+        for type in index.keys():
+            if (
+                type != "Date32"
+                and type != "Datetime64"
+                and type != "Timestamp64"
+                and type != 'Interval64'
+                and type != "DyNumber"
+                and type != "UUID"
+            ):
+                for line in range(len(rows)):
+                    dml.assert_type(index, type, line + 1, rows[line][f"col_index_{cleanup_type_name(type)}"])
+        if ttl != "" and ttl != "DyNumber":
+            for line in range(len(rows)):
+                dml.assert_type(ttl_types, ttl, line + 1, rows[line][f"ttl_{cleanup_type_name(ttl)}"])
+
+    def select_with(
+        self,
+        table_name: str,
+        all_types: dict[str, str],
+        pk_types: dict[str, str],
+        index: dict[str, str],
+        ttl: str,
+        dml: DMLOperations,
+    ):
+        select_with_parameters = [
+            "INFER_SCHEMA",
+            "FORCE_INFER_SCHEMA",
+            "DIRECT_READ",
+            "INLINE",
+            "UNORDERED",
+            "XLOCK",
+            "IGNORETYPEV3",
+        ]
+        statements = self.create_types_for_all_select(all_types, pk_types, index, ttl)
+        for select_with_parameter in select_with_parameters:
+            select_with_sql_request = f"""
+                select {", ".join(statements)}
+                from {table_name}
+                with {select_with_parameter}
+            """
+            rows = dml.query(select_with_sql_request)
+            for i in range(len(rows)):
+                self.assert_type_after_select(i + 1, i, rows, all_types, pk_types, index, ttl, dml)
+
+    def without(
+        self, table_name: str, all_types: dict[str, str], pk_types: dict[str, str], index: dict[str, str], ttl: str
+    ):
+        statements_without = []
+        for type_name in all_types.keys():
+            if (
+                type_name == "Date32"
+                or type_name == "Datetime64"
+                or type_name == "Timestamp64"
+                or type_name == 'Interval64'
+            ):
+                statements_without.append(f"col_{cleanup_type_name(type_name)}")
+        for type_name in pk_types.keys():
+            if (
+                type_name == "Date32"
+                or type_name == "Datetime64"
+                or type_name == "Timestamp64"
+                or type_name == 'Interval64'
+            ):
+                statements_without.append(f"pk_{cleanup_type_name(type_name)}")
+        for type_name in index.keys():
+            if (
+                type_name == "Date32"
+                or type_name == "Datetime64"
+                or type_name == "Timestamp64"
+                or type_name == 'Interval64'
+            ):
+                statements_without.append(f"col_index_{cleanup_type_name(type_name)}")
+
+        for type_name in all_types.keys():
+            if (
+                type_name != "Date32"
+                and type_name != "Datetime64"
+                and type_name != "Timestamp64"
+                and type_name != 'Interval64'
+            ):
+                self.create_without(table_name, statements_without, f"col_{cleanup_type_name(type_name)}")
+        for type_name in pk_types.keys():
+            if (
+                type_name != "Date32"
+                and type_name != "Datetime64"
+                and type_name != "Timestamp64"
+                and type_name != 'Interval64'
+            ):
+                self.create_without(table_name, statements_without, f"pk_{cleanup_type_name(type_name)}")
+        for type_name in index.keys():
+            if (
+                type_name != "Date32"
+                and type_name != "Datetime64"
+                and type_name != "Timestamp64"
+                and type_name != 'Interval64'
+            ):
+                self.create_without(table_name, statements_without, f"col_index_{cleanup_type_name(type_name)}")
+        if ttl != "":
+            self.create_without(table_name, statements_without, f"ttl_{cleanup_type_name(ttl)}")
+
+    def create_without(self, table_name, statements_without, without):
+        rows = self.query(f"select * without {", ".join(statements_without)}, {without} from {table_name}")
+        for col_name in rows[0].keys():
+            assert col_name != without, f"a column {without} in the table {table_name} was not excluded"
+
+    def tablesample_sample(
+        self,
+        table_name: str,
+        all_types: dict[str, str],
+        pk_types: dict[str, str],
+        index: dict[str, str],
+        ttl: str,
+        dml: DMLOperations,
+    ):
+        statements = self.create_types_for_all_select(all_types, pk_types, index, ttl)
+        for i in range(1, 100):
+            rows = self.query(f"select {", ".join(statements)} from {table_name} TABLESAMPLE SYSTEM({i}.0)")
+            for line in range(len(rows)):
+                numb = rows[line]["pk_Int64"]
+                self.assert_type_after_select(numb, line, rows, all_types, pk_types, index, ttl, dml)
+
+            rows = self.query(
+                f"select {", ".join(statements)} from {table_name} TABLESAMPLE BERNOULLI({i}.0) REPEATABLE({i})"
+            )
+            for line in range(len(rows)):
+                numb = rows[line]["pk_Int64"]
+                self.assert_type_after_select(numb, line, rows, all_types, pk_types, index, ttl, dml)
+
+            rows = self.query(f"select {", ".join(statements)} from {table_name} SAMPLE 1.0 / {i}")
+            for line in range(len(rows)):
+                numb = rows[line]["pk_Int64"]
+                self.assert_type_after_select(numb, line, rows, all_types, pk_types, index, ttl, dml)
+
+    def order_by(
+        self,
+        table_name: str,
+        all_types: dict[str, str],
+        pk_types: dict[str, str],
+        index: dict[str, str],
+        ttl: str,
+        dml: DMLOperations,
+    ):
+        statements = self.create_types_for_all_select(all_types, pk_types, index, ttl)
+        for statement in statements:
+            if "Json" not in statement and "JsonDocument" not in statement and "Yson" not in statement:
+                rows = self.query(f"select {", ".join(statements)} from {table_name} ORDER BY {statement} ASC")
+                if "String" not in statement and "Utf8" not in statement:
+                    for line in range(len(rows)):
+                        self.assert_type_after_select(line + 1, line, rows, all_types, pk_types, index, ttl, dml)
+                else:
+                    line = 0
+                    for i in range(len(rows) // 10):
+                        self.assert_type_after_select(i + 1, line, rows, all_types, pk_types, index, ttl, dml)
+                        line += 1
+                        for j in range(10):
+                            if (i + 1) * 10 + j > len(rows):
+                                break
+                            self.assert_type_after_select(
+                                (i + 1) * 10 + j, line, rows, all_types, pk_types, index, ttl, dml
+                            )
+                            line += 1
+
+                rows = self.query(f"select {", ".join(statements)} from {table_name} ORDER BY {statement} DESC")
+
+                if "Bool" not in statement:
path: ydb/tests/datashard/select/test_select.py
user: login: dennnniska
body: Сделал, забыл убрать 
created_at: 2025-05-19T08:21:55Z
author_association: CONTRIBUTOR
diff_hunk: @@ -0,0 +1,509 @@
+import pytest
+
+from ydb.tests.sql.lib.test_base import TestBase
+from ydb.tests.datashard.lib.dml_operations import DMLOperations
+from ydb.tests.datashard.lib.types_of_variables import (
+    cleanup_type_name,
+    format_sql_value,
+    pk_types,
+    non_pk_types,
+    index_first,
+    index_second,
+    ttl_types,
+    index_first_sync,
+    index_second_sync,
+    index_three_sync,
+    index_three_sync_not_Bool,
+    index_four_sync,
+    index_zero_sync,
+)
+
+
+class TestDML(TestBase):
+    @pytest.mark.parametrize(
+        "table_name, pk_types, all_types, index, ttl, unique, sync",
+        [
+            ("table_index_4_UNIQUE_SYNC", pk_types, {},
+             index_four_sync, "", "UNIQUE", "SYNC"),
+            ("table_index_3_UNIQUE_SYNC", pk_types, {},
+             index_three_sync_not_Bool, "", "UNIQUE", "SYNC"),
+            ("table_index_2_UNIQUE_SYNC", pk_types, {},
+             index_second_sync, "", "UNIQUE", "SYNC"),
+            ("table_index_1_UNIQUE_SYNC", pk_types, {},
+             index_first_sync, "", "UNIQUE", "SYNC"),
+            ("table_index_0_UNIQUE_SYNC", pk_types, {},
+             index_zero_sync, "", "UNIQUE", "SYNC"),
+            ("table_index_4__SYNC", pk_types, {},
+             index_four_sync, "", "", "SYNC"),
+            ("table_index_3__SYNC", pk_types, {},
+             index_three_sync, "", "", "SYNC"),
+            ("table_index_2__SYNC", pk_types, {},
+             index_second_sync, "", "", "SYNC"),
+            ("table_index_1__SYNC", pk_types, {},
+             index_first_sync, "", "", "SYNC"),
+            ("table_index_0__SYNC", pk_types, {},
+             index_zero_sync, "", "", "SYNC"),
+            ("table_index_1__ASYNC", pk_types, {}, index_second, "", "", "ASYNC"),
+            ("table_index_0__ASYNC", pk_types, {}, index_first, "", "", "ASYNC"),
+            ("table_all_types", pk_types, {
+             **pk_types, **non_pk_types}, {}, "", "", ""),
+            ("table_ttl_DyNumber", pk_types, {}, {}, "DyNumber", "", ""),
+            ("table_ttl_Uint32", pk_types, {}, {}, "Uint32", "", ""),
+            ("table_ttl_Uint64", pk_types, {}, {}, "Uint64", "", ""),
+            ("table_ttl_Datetime", pk_types, {}, {}, "Datetime", "", ""),
+            ("table_ttl_Timestamp", pk_types, {}, {}, "Timestamp", "", ""),
+            ("table_ttl_Date", pk_types, {}, {}, "Date", "", ""),
+        ]
+    )
+    def test_select(self, table_name: str, pk_types: dict[str, str], all_types: dict[str, str], index: dict[str, str], ttl: str, unique: str, sync: str):
+        dml = DMLOperations(self)
+        dml.create_table(table_name, pk_types, all_types,
+                         index, ttl, unique, sync)
+        dml.insert(table_name, all_types, pk_types, index, ttl)
+        self.select_with(table_name, all_types, pk_types, index, ttl, dml)
+        self.order_by(table_name, all_types, pk_types, index, ttl, dml)
+        self.limit(table_name, all_types, pk_types, index, ttl, dml)
+        self.from_select(table_name, all_types, pk_types, index, ttl, dml)
+        self.distinct(table_name, all_types, pk_types, index, ttl, dml)
+        self.union(table_name, all_types, pk_types, index, ttl, dml)
+        self.without(table_name, all_types, pk_types, index, ttl)
+        self.tablesample_sample(table_name, all_types,
+                                pk_types, index, ttl, dml)
+
+    def limit(
+        self,
+        table_name: str,
+        all_types: dict[str, str],
+        pk_types: dict[str, str],
+        index: dict[str, str],
+        ttl: str,
+        dml: DMLOperations,
+    ):
+        statements = self.create_types_for_all_select(all_types, pk_types, index, ttl)
+
+        number_of_columns = self.get_number_of_columns(pk_types, all_types, index, ttl)
+
+        for offset in range(number_of_columns):
+            rows = self.query(f"select {", ".join(statements)} from {table_name} limit 1 OFFSET {offset}")
+            self.assert_type_after_select(offset + 1, 0, rows, all_types, pk_types, index, ttl, dml)
+
+    def create_types_for_all_select(
+        self, all_types: dict[str, str], pk_types: dict[str, str], index: dict[str, str], ttl: str
+    ):
+        statements = []
+        # delete if after https://github.com/ydb-platform/ydb/issues/16930
+        for type in all_types.keys():
+            if type != "Date32" and type != "Datetime64" and type != "Timestamp64" and type != 'Interval64':
+                statements.append(f"col_{cleanup_type_name(type)}")
+        for type in pk_types.keys():
+            if type != "Date32" and type != "Datetime64" and type != "Timestamp64" and type != 'Interval64':
+                statements.append(f"pk_{cleanup_type_name(type)}")
+        for type in index.keys():
+            if type != "Date32" and type != "Datetime64" and type != "Timestamp64" and type != 'Interval64':
+                statements.append(f"col_index_{cleanup_type_name(type)}")
+        if ttl != "":
+            statements.append(f"ttl_{cleanup_type_name(ttl)}")
+        return statements
+
+    def assert_type_after_select(
+        self,
+        value,
+        line,
+        rows,
+        all_types: dict[str, str],
+        pk_types: dict[str, str],
+        index: dict[str, str],
+        ttl: str,
+        dml: DMLOperations,
+    ):
+        count = 0
+        for type in all_types.keys():
+            if type != "Date32" and type != "Datetime64" and type != "Timestamp64" and type != 'Interval64':
+                dml.assert_type(all_types, type, value, rows[line][count])
+                count += 1
+        for type in pk_types.keys():
+            if type != "Date32" and type != "Datetime64" and type != "Timestamp64" and type != 'Interval64':
+                dml.assert_type(pk_types, type, value, rows[line][count])
+                count += 1
+        for type in index.keys():
+            if type != "Date32" and type != "Datetime64" and type != "Timestamp64" and type != 'Interval64':
+                dml.assert_type(index, type, value, rows[line][count])
+                count += 1
+        if ttl != "":
+            dml.assert_type(ttl_types, ttl, value, rows[line][count])
+            count += 1
+
+    def from_select(
+        self,
+        table_name: str,
+        all_types: dict[str, str],
+        pk_types: dict[str, str],
+        index: dict[str, str],
+        ttl: str,
+        dml: DMLOperations,
+    ):
+        statements = self.create_types_for_all_select(all_types, pk_types, index, ttl)
+
+        rows = self.query(f"from {table_name} select {", ".join(statements)}")
+        for i in range(len(rows)):
+            self.assert_type_after_select(i + 1, i, rows, all_types, pk_types, index, ttl, dml)
+
+    def distinct(
+        self,
+        table_name: str,
+        all_types: dict[str, str],
+        pk_types: dict[str, str],
+        index: dict[str, str],
+        ttl: str,
+        dml: DMLOperations,
+    ):
+        # del type != "DyNumber" and type != "UUID" after https://github.com/ydb-platform/ydb/issues/17484
+        for type in all_types.keys():
+            if (
+                type != "Date32"
+                and type != "Datetime64"
+                and type != "Timestamp64"
+                and type != 'Interval64'
+                and type != "DyNumber"
+                and type != "UUID"
+                and type != "Json"
+                and type != "JsonDocument"
+                and type != "Yson"
+            ):
+                rows_distinct = self.query(f"SELECT DISTINCT col_{cleanup_type_name(type)} from {table_name}")
+                for i in range(len(rows_distinct)):
+                    dml.assert_type(all_types, type, i + 1, rows_distinct[i][0])
+        for type in pk_types.keys():
+            if (
+                type != "Date32"
+                and type != "Datetime64"
+                and type != "Timestamp64"
+                and type != 'Interval64'
+                and type != "DyNumber"
+                and type != "UUID"
+            ):
+                rows_distinct = self.query(f"SELECT DISTINCT pk_{cleanup_type_name(type)} from {table_name}")
+                for i in range(len(rows_distinct)):
+                    dml.assert_type(pk_types, type, i + 1, rows_distinct[i][0])
+        for type in index.keys():
+            if (
+                type != "Date32"
+                and type != "Datetime64"
+                and type != "Timestamp64"
+                and type != 'Interval64'
+                and type != "DyNumber"
+                and type != "UUID"
+            ):
+                rows_distinct = self.query(f"SELECT DISTINCT col_index_{cleanup_type_name(type)} from {table_name}")
+                for i in range(len(rows_distinct)):
+                    dml.assert_type(index, type, i + 1, rows_distinct[i][0])
+        if ttl != "" and ttl != "DyNumber":
+            rows_distinct = self.query(f"SELECT DISTINCT ttl_{cleanup_type_name(ttl)} from {table_name}")
+            for i in range(len(rows_distinct)):
+                dml.assert_type(ttl_types, ttl, i + 1, rows_distinct[i][0])
+
+    def union(
+        self,
+        table_name: str,
+        all_types: dict[str, str],
+        pk_types: dict[str, str],
+        index: dict[str, str],
+        ttl: str,
+        dml: DMLOperations,
+    ):
+        statements = []
+        for type in all_types.keys():
+            if (
+                type != "Date32"
+                and type != "Datetime64"
+                and type != "Timestamp64"
+                and type != 'Interval64'
+                and type != "DyNumber"
+                and type != "UUID"
+                and type != "Json"
+                and type != "JsonDocument"
+                and type != "Yson"
+            ):
+                statements.append(f"col_{cleanup_type_name(type)}")
+        for type in pk_types.keys():
+            if (
+                type != "Date32"
+                and type != "Datetime64"
+                and type != "Timestamp64"
+                and type != 'Interval64'
+                and type != "DyNumber"
+                and type != "UUID"
+            ):
+                statements.append(f"pk_{cleanup_type_name(type)}")
+        for type in index.keys():
+            if (
+                type != "Date32"
+                and type != "Datetime64"
+                and type != "Timestamp64"
+                and type != 'Interval64'
+                and type != "DyNumber"
+                and type != "UUID"
+            ):
+                statements.append(f"col_index_{cleanup_type_name(type)}")
+        if ttl != "" and ttl != "DyNumber":
+            statements.append(f"ttl_{cleanup_type_name(ttl)}")
+        rows = self.query(
+            f"""
+                          select {", ".join(statements)} from {table_name}
+                          union
+                          select {", ".join(statements)} from {table_name}
+                          """
+        )
+        for type in all_types.keys():
+            if (
+                type != "Date32"
+                and type != "Datetime64"
+                and type != "Timestamp64"
+                and type != 'Interval64'
+                and type != "DyNumber"
+                and type != "UUID"
+                and type != "Json"
+                and type != "JsonDocument"
+                and type != "Yson"
+            ):
+                for line in range(len(rows)):
+                    dml.assert_type(all_types, type, line + 1, rows[line][f"col_{cleanup_type_name(type)}"])
+        for type in pk_types.keys():
+            if (
+                type != "Date32"
+                and type != "Datetime64"
+                and type != "Timestamp64"
+                and type != 'Interval64'
+                and type != "DyNumber"
+                and type != "UUID"
+            ):
+                for line in range(len(rows)):
+                    dml.assert_type(pk_types, type, line + 1, rows[line][f"pk_{cleanup_type_name(type)}"])
+        for type in index.keys():
+            if (
+                type != "Date32"
+                and type != "Datetime64"
+                and type != "Timestamp64"
+                and type != 'Interval64'
+                and type != "DyNumber"
+                and type != "UUID"
+            ):
+                for line in range(len(rows)):
+                    dml.assert_type(index, type, line + 1, rows[line][f"col_index_{cleanup_type_name(type)}"])
+        if ttl != "" and ttl != "DyNumber":
+            for line in range(len(rows)):
+                dml.assert_type(ttl_types, ttl, line + 1, rows[line][f"ttl_{cleanup_type_name(ttl)}"])
+
+    def select_with(
+        self,
+        table_name: str,
+        all_types: dict[str, str],
+        pk_types: dict[str, str],
+        index: dict[str, str],
+        ttl: str,
+        dml: DMLOperations,
+    ):
+        select_with_parameters = [
+            "INFER_SCHEMA",
+            "FORCE_INFER_SCHEMA",
+            "DIRECT_READ",
+            "INLINE",
+            "UNORDERED",
+            "XLOCK",
+            "IGNORETYPEV3",
+        ]
+        statements = self.create_types_for_all_select(all_types, pk_types, index, ttl)
+        for select_with_parameter in select_with_parameters:
+            select_with_sql_request = f"""
+                select {", ".join(statements)}
+                from {table_name}
+                with {select_with_parameter}
+            """
+            rows = dml.query(select_with_sql_request)
+            for i in range(len(rows)):
+                self.assert_type_after_select(i + 1, i, rows, all_types, pk_types, index, ttl, dml)
+
+    def without(
+        self, table_name: str, all_types: dict[str, str], pk_types: dict[str, str], index: dict[str, str], ttl: str
+    ):
+        statements_without = []
+        for type_name in all_types.keys():
+            if (
+                type_name == "Date32"
+                or type_name == "Datetime64"
+                or type_name == "Timestamp64"
+                or type_name == 'Interval64'
+            ):
+                statements_without.append(f"col_{cleanup_type_name(type_name)}")
+        for type_name in pk_types.keys():
+            if (
+                type_name == "Date32"
+                or type_name == "Datetime64"
+                or type_name == "Timestamp64"
+                or type_name == 'Interval64'
+            ):
+                statements_without.append(f"pk_{cleanup_type_name(type_name)}")
+        for type_name in index.keys():
+            if (
+                type_name == "Date32"
+                or type_name == "Datetime64"
+                or type_name == "Timestamp64"
+                or type_name == 'Interval64'
+            ):
+                statements_without.append(f"col_index_{cleanup_type_name(type_name)}")
+
+        for type_name in all_types.keys():
+            if (
+                type_name != "Date32"
+                and type_name != "Datetime64"
+                and type_name != "Timestamp64"
+                and type_name != 'Interval64'
+            ):
+                self.create_without(table_name, statements_without, f"col_{cleanup_type_name(type_name)}")
+        for type_name in pk_types.keys():
+            if (
+                type_name != "Date32"
+                and type_name != "Datetime64"
+                and type_name != "Timestamp64"
+                and type_name != 'Interval64'
+            ):
+                self.create_without(table_name, statements_without, f"pk_{cleanup_type_name(type_name)}")
+        for type_name in index.keys():
+            if (
+                type_name != "Date32"
+                and type_name != "Datetime64"
+                and type_name != "Timestamp64"
+                and type_name != 'Interval64'
+            ):
+                self.create_without(table_name, statements_without, f"col_index_{cleanup_type_name(type_name)}")
+        if ttl != "":
+            self.create_without(table_name, statements_without, f"ttl_{cleanup_type_name(ttl)}")
+
+    def create_without(self, table_name, statements_without, without):
+        rows = self.query(f"select * without {", ".join(statements_without)}, {without} from {table_name}")
+        for col_name in rows[0].keys():
+            assert col_name != without, f"a column {without} in the table {table_name} was not excluded"
+
+    def tablesample_sample(
+        self,
+        table_name: str,
+        all_types: dict[str, str],
+        pk_types: dict[str, str],
+        index: dict[str, str],
+        ttl: str,
+        dml: DMLOperations,
+    ):
+        statements = self.create_types_for_all_select(all_types, pk_types, index, ttl)
+        for i in range(1, 100):
+            rows = self.query(f"select {", ".join(statements)} from {table_name} TABLESAMPLE SYSTEM({i}.0)")
+            for line in range(len(rows)):
+                numb = rows[line]["pk_Int64"]
+                self.assert_type_after_select(numb, line, rows, all_types, pk_types, index, ttl, dml)
+
+            rows = self.query(
+                f"select {", ".join(statements)} from {table_name} TABLESAMPLE BERNOULLI({i}.0) REPEATABLE({i})"
+            )
+            for line in range(len(rows)):
+                numb = rows[line]["pk_Int64"]
+                self.assert_type_after_select(numb, line, rows, all_types, pk_types, index, ttl, dml)
+
+            rows = self.query(f"select {", ".join(statements)} from {table_name} SAMPLE 1.0 / {i}")
+            for line in range(len(rows)):
+                numb = rows[line]["pk_Int64"]
+                self.assert_type_after_select(numb, line, rows, all_types, pk_types, index, ttl, dml)
+
+    def order_by(
+        self,
+        table_name: str,
+        all_types: dict[str, str],
+        pk_types: dict[str, str],
+        index: dict[str, str],
+        ttl: str,
+        dml: DMLOperations,
+    ):
+        statements = self.create_types_for_all_select(all_types, pk_types, index, ttl)
+        for statement in statements:
+            if "Json" not in statement and "JsonDocument" not in statement and "Yson" not in statement:
+                rows = self.query(f"select {", ".join(statements)} from {table_name} ORDER BY {statement} ASC")
+                if "String" not in statement and "Utf8" not in statement:
+                    for line in range(len(rows)):
+                        self.assert_type_after_select(line + 1, line, rows, all_types, pk_types, index, ttl, dml)
+                else:
+                    line = 0
+                    for i in range(len(rows) // 10):
+                        self.assert_type_after_select(i + 1, line, rows, all_types, pk_types, index, ttl, dml)
+                        line += 1
+                        for j in range(10):
+                            if (i + 1) * 10 + j > len(rows):
path: ydb/tests/datashard/select/test_select.py
user: login: dennnniska
body: Сделал 
created_at: 2025-05-19T09:15:10Z
author_association: CONTRIBUTOR
diff_hunk: @@ -0,0 +1,409 @@
+import pytest
+
+from ydb.tests.sql.lib.test_base import TestBase
+from ydb.tests.datashard.lib.dml_operations import DMLOperations
+from ydb.tests.datashard.lib.types_of_variables import (
+    cleanup_type_name,
+    format_sql_value,
+    pk_types,
+    non_pk_types,
+    index_first,
+    index_second,
+    ttl_types,
+    index_first_sync,
+    index_second_sync,
+    index_three_sync,
+    index_three_sync_not_Bool,
+    index_four_sync,
+    index_zero_sync,
+)
+
+unsuppored_time_types = [
+    "Date32",
+    "Datetime64",
+    "Timestamp64",
+    "Interval64",
+]  # https://github.com/ydb-platform/ydb/issues/16930
+unsuppored_distinct_types = [
+    "DyNumber",
+    "UUID",  # https://github.com/ydb-platform/ydb/issues/17484
+]
+uncomparable_types = ["Json", "JsonDocument", "Yson"]
+
+
+class TestDML(TestBase):
+    @pytest.mark.parametrize(
+        "table_name, pk_types, all_types, index, ttl, unique, sync",
+        [
+            ("table_index_4_UNIQUE_SYNC", pk_types, {}, index_four_sync, "", "UNIQUE", "SYNC"),
+            ("table_index_3_UNIQUE_SYNC", pk_types, {}, index_three_sync_not_Bool, "", "UNIQUE", "SYNC"),
+            ("table_index_2_UNIQUE_SYNC", pk_types, {}, index_second_sync, "", "UNIQUE", "SYNC"),
+            ("table_index_1_UNIQUE_SYNC", pk_types, {}, index_first_sync, "", "UNIQUE", "SYNC"),
+            ("table_index_0_UNIQUE_SYNC", pk_types, {}, index_zero_sync, "", "UNIQUE", "SYNC"),
+            ("table_index_4__SYNC", pk_types, {}, index_four_sync, "", "", "SYNC"),
+            ("table_index_3__SYNC", pk_types, {}, index_three_sync, "", "", "SYNC"),
+            ("table_index_2__SYNC", pk_types, {}, index_second_sync, "", "", "SYNC"),
+            ("table_index_1__SYNC", pk_types, {}, index_first_sync, "", "", "SYNC"),
+            ("table_index_0__SYNC", pk_types, {}, index_zero_sync, "", "", "SYNC"),
+            ("table_index_1__ASYNC", pk_types, {}, index_second, "", "", "ASYNC"),
+            ("table_index_0__ASYNC", pk_types, {}, index_first, "", "", "ASYNC"),
+            ("table_all_types", pk_types, {**pk_types, **non_pk_types}, {}, "", "", ""),
+            ("table_ttl_DyNumber", pk_types, {}, {}, "DyNumber", "", ""),
+            ("table_ttl_Uint32", pk_types, {}, {}, "Uint32", "", ""),
+            ("table_ttl_Uint64", pk_types, {}, {}, "Uint64", "", ""),
+            ("table_ttl_Datetime", pk_types, {}, {}, "Datetime", "", ""),
+            ("table_ttl_Timestamp", pk_types, {}, {}, "Timestamp", "", ""),
+            ("table_ttl_Date", pk_types, {}, {}, "Date", "", ""),
+        ],
+    )
+    def test_select(
+        self,
+        table_name: str,
+        pk_types: dict[str, str],
+        all_types: dict[str, str],
+        index: dict[str, str],
+        ttl: str,
+        unique: str,
+        sync: str,
+    ):
+        dml = DMLOperations(self)
+        dml.create_table(table_name, pk_types, all_types, index, ttl, unique, sync)
+        dml.insert(table_name, all_types, pk_types, index, ttl)
+        self.select_with(table_name, all_types, pk_types, index, ttl, dml)
+        self.order_by(table_name, all_types, pk_types, index, ttl, dml)
+        self.limit(table_name, all_types, pk_types, index, ttl, dml)
+        self.from_select(table_name, all_types, pk_types, index, ttl, dml)
+        self.distinct(table_name, all_types, pk_types, index, ttl, dml)
+        self.union(table_name, all_types, pk_types, index, ttl, dml)
+        self.without(table_name, all_types, pk_types, index, ttl)
+        self.tablesample_sample(table_name, all_types, pk_types, index, ttl, dml)
+
+    def limit(
+        self,
+        table_name: str,
+        all_types: dict[str, str],
+        pk_types: dict[str, str],
+        index: dict[str, str],
+        ttl: str,
+        dml: DMLOperations,
+    ):
+        selected_columns = self.create_types_for_all_select(all_types, pk_types, index, ttl)
+
+        number_of_columns = self.get_number_of_columns(pk_types, all_types, index, ttl)
+
+        for offset in range(number_of_columns):
+            rows = self.query(f"select {", ".join(selected_columns)} from {table_name} limit 1 OFFSET {offset}")
+            self.assert_type_after_select(offset + 1, rows[0], all_types, pk_types, index, ttl, dml)
+
+    def create_types_for_all_select(
+        self, all_types: dict[str, str], pk_types: dict[str, str], index: dict[str, str], ttl: str
+    ):
+        statements = []
+        # delete if after https://github.com/ydb-platform/ydb/issues/16930
path: ydb/tests/datashard/select/test_select.py
user: login: lex007in
body: Этот коммент тогда не нужен
created_at: 2025-05-20T14:45:45Z
author_association: COLLABORATOR
diff_hunk: @@ -0,0 +1,409 @@
+import pytest
+
+from ydb.tests.sql.lib.test_base import TestBase
+from ydb.tests.datashard.lib.dml_operations import DMLOperations
+from ydb.tests.datashard.lib.types_of_variables import (
+    cleanup_type_name,
+    format_sql_value,
+    pk_types,
+    non_pk_types,
+    index_first,
+    index_second,
+    ttl_types,
+    index_first_sync,
+    index_second_sync,
+    index_three_sync,
+    index_three_sync_not_Bool,
+    index_four_sync,
+    index_zero_sync,
+)
+
+unsuppored_time_types = [
+    "Date32",
+    "Datetime64",
+    "Timestamp64",
+    "Interval64",
+]  # https://github.com/ydb-platform/ydb/issues/16930
+unsuppored_distinct_types = [
+    "DyNumber",
+    "UUID",  # https://github.com/ydb-platform/ydb/issues/17484
+]
+uncomparable_types = ["Json", "JsonDocument", "Yson"]
+
+
+class TestDML(TestBase):
+    @pytest.mark.parametrize(
+        "table_name, pk_types, all_types, index, ttl, unique, sync",
+        [
+            ("table_index_4_UNIQUE_SYNC", pk_types, {}, index_four_sync, "", "UNIQUE", "SYNC"),
+            ("table_index_3_UNIQUE_SYNC", pk_types, {}, index_three_sync_not_Bool, "", "UNIQUE", "SYNC"),
+            ("table_index_2_UNIQUE_SYNC", pk_types, {}, index_second_sync, "", "UNIQUE", "SYNC"),
+            ("table_index_1_UNIQUE_SYNC", pk_types, {}, index_first_sync, "", "UNIQUE", "SYNC"),
+            ("table_index_0_UNIQUE_SYNC", pk_types, {}, index_zero_sync, "", "UNIQUE", "SYNC"),
+            ("table_index_4__SYNC", pk_types, {}, index_four_sync, "", "", "SYNC"),
+            ("table_index_3__SYNC", pk_types, {}, index_three_sync, "", "", "SYNC"),
+            ("table_index_2__SYNC", pk_types, {}, index_second_sync, "", "", "SYNC"),
+            ("table_index_1__SYNC", pk_types, {}, index_first_sync, "", "", "SYNC"),
+            ("table_index_0__SYNC", pk_types, {}, index_zero_sync, "", "", "SYNC"),
+            ("table_index_1__ASYNC", pk_types, {}, index_second, "", "", "ASYNC"),
+            ("table_index_0__ASYNC", pk_types, {}, index_first, "", "", "ASYNC"),
+            ("table_all_types", pk_types, {**pk_types, **non_pk_types}, {}, "", "", ""),
+            ("table_ttl_DyNumber", pk_types, {}, {}, "DyNumber", "", ""),
+            ("table_ttl_Uint32", pk_types, {}, {}, "Uint32", "", ""),
+            ("table_ttl_Uint64", pk_types, {}, {}, "Uint64", "", ""),
+            ("table_ttl_Datetime", pk_types, {}, {}, "Datetime", "", ""),
+            ("table_ttl_Timestamp", pk_types, {}, {}, "Timestamp", "", ""),
+            ("table_ttl_Date", pk_types, {}, {}, "Date", "", ""),
+        ],
+    )
+    def test_select(
+        self,
+        table_name: str,
+        pk_types: dict[str, str],
+        all_types: dict[str, str],
+        index: dict[str, str],
+        ttl: str,
+        unique: str,
+        sync: str,
+    ):
+        dml = DMLOperations(self)
+        dml.create_table(table_name, pk_types, all_types, index, ttl, unique, sync)
+        dml.insert(table_name, all_types, pk_types, index, ttl)
+        self.select_with(table_name, all_types, pk_types, index, ttl, dml)
+        self.order_by(table_name, all_types, pk_types, index, ttl, dml)
+        self.limit(table_name, all_types, pk_types, index, ttl, dml)
+        self.from_select(table_name, all_types, pk_types, index, ttl, dml)
+        self.distinct(table_name, all_types, pk_types, index, ttl, dml)
+        self.union(table_name, all_types, pk_types, index, ttl, dml)
+        self.without(table_name, all_types, pk_types, index, ttl)
+        self.tablesample_sample(table_name, all_types, pk_types, index, ttl, dml)
+
+    def limit(
+        self,
+        table_name: str,
+        all_types: dict[str, str],
+        pk_types: dict[str, str],
+        index: dict[str, str],
+        ttl: str,
+        dml: DMLOperations,
+    ):
+        selected_columns = self.create_types_for_all_select(all_types, pk_types, index, ttl)
+
+        number_of_columns = self.get_number_of_columns(pk_types, all_types, index, ttl)
+
+        for offset in range(number_of_columns):
+            rows = self.query(f"select {", ".join(selected_columns)} from {table_name} limit 1 OFFSET {offset}")
+            self.assert_type_after_select(offset + 1, rows[0], all_types, pk_types, index, ttl, dml)
+
+    def create_types_for_all_select(
+        self, all_types: dict[str, str], pk_types: dict[str, str], index: dict[str, str], ttl: str
+    ):
+        statements = []
path: ydb/tests/datashard/select/test_select.py
user: login: lex007in
body: Если решил переименовать, то давай везде переименуем) Тут тоже только колонки.
created_at: 2025-05-20T14:46:41Z
author_association: COLLABORATOR
diff_hunk: @@ -0,0 +1,409 @@
+import pytest
+
+from ydb.tests.sql.lib.test_base import TestBase
+from ydb.tests.datashard.lib.dml_operations import DMLOperations
+from ydb.tests.datashard.lib.types_of_variables import (
+    cleanup_type_name,
+    format_sql_value,
+    pk_types,
+    non_pk_types,
+    index_first,
+    index_second,
+    ttl_types,
+    index_first_sync,
+    index_second_sync,
+    index_three_sync,
+    index_three_sync_not_Bool,
+    index_four_sync,
+    index_zero_sync,
+)
+
+unsuppored_time_types = [
+    "Date32",
+    "Datetime64",
+    "Timestamp64",
+    "Interval64",
+]  # https://github.com/ydb-platform/ydb/issues/16930
+unsuppored_distinct_types = [
+    "DyNumber",
+    "UUID",  # https://github.com/ydb-platform/ydb/issues/17484
+]
+uncomparable_types = ["Json", "JsonDocument", "Yson"]
+
+
+class TestDML(TestBase):
+    @pytest.mark.parametrize(
+        "table_name, pk_types, all_types, index, ttl, unique, sync",
+        [
+            ("table_index_4_UNIQUE_SYNC", pk_types, {}, index_four_sync, "", "UNIQUE", "SYNC"),
+            ("table_index_3_UNIQUE_SYNC", pk_types, {}, index_three_sync_not_Bool, "", "UNIQUE", "SYNC"),
+            ("table_index_2_UNIQUE_SYNC", pk_types, {}, index_second_sync, "", "UNIQUE", "SYNC"),
+            ("table_index_1_UNIQUE_SYNC", pk_types, {}, index_first_sync, "", "UNIQUE", "SYNC"),
+            ("table_index_0_UNIQUE_SYNC", pk_types, {}, index_zero_sync, "", "UNIQUE", "SYNC"),
+            ("table_index_4__SYNC", pk_types, {}, index_four_sync, "", "", "SYNC"),
+            ("table_index_3__SYNC", pk_types, {}, index_three_sync, "", "", "SYNC"),
+            ("table_index_2__SYNC", pk_types, {}, index_second_sync, "", "", "SYNC"),
+            ("table_index_1__SYNC", pk_types, {}, index_first_sync, "", "", "SYNC"),
+            ("table_index_0__SYNC", pk_types, {}, index_zero_sync, "", "", "SYNC"),
+            ("table_index_1__ASYNC", pk_types, {}, index_second, "", "", "ASYNC"),
+            ("table_index_0__ASYNC", pk_types, {}, index_first, "", "", "ASYNC"),
+            ("table_all_types", pk_types, {**pk_types, **non_pk_types}, {}, "", "", ""),
+            ("table_ttl_DyNumber", pk_types, {}, {}, "DyNumber", "", ""),
+            ("table_ttl_Uint32", pk_types, {}, {}, "Uint32", "", ""),
+            ("table_ttl_Uint64", pk_types, {}, {}, "Uint64", "", ""),
+            ("table_ttl_Datetime", pk_types, {}, {}, "Datetime", "", ""),
+            ("table_ttl_Timestamp", pk_types, {}, {}, "Timestamp", "", ""),
+            ("table_ttl_Date", pk_types, {}, {}, "Date", "", ""),
+        ],
+    )
+    def test_select(
+        self,
+        table_name: str,
+        pk_types: dict[str, str],
+        all_types: dict[str, str],
+        index: dict[str, str],
+        ttl: str,
+        unique: str,
+        sync: str,
+    ):
+        dml = DMLOperations(self)
+        dml.create_table(table_name, pk_types, all_types, index, ttl, unique, sync)
+        dml.insert(table_name, all_types, pk_types, index, ttl)
+        self.select_with(table_name, all_types, pk_types, index, ttl, dml)
+        self.order_by(table_name, all_types, pk_types, index, ttl, dml)
+        self.limit(table_name, all_types, pk_types, index, ttl, dml)
+        self.from_select(table_name, all_types, pk_types, index, ttl, dml)
+        self.distinct(table_name, all_types, pk_types, index, ttl, dml)
+        self.union(table_name, all_types, pk_types, index, ttl, dml)
+        self.without(table_name, all_types, pk_types, index, ttl)
+        self.tablesample_sample(table_name, all_types, pk_types, index, ttl, dml)
+
+    def limit(
+        self,
+        table_name: str,
+        all_types: dict[str, str],
+        pk_types: dict[str, str],
+        index: dict[str, str],
+        ttl: str,
+        dml: DMLOperations,
+    ):
+        selected_columns = self.create_types_for_all_select(all_types, pk_types, index, ttl)
+
+        number_of_columns = self.get_number_of_columns(pk_types, all_types, index, ttl)
+
+        for offset in range(number_of_columns):
+            rows = self.query(f"select {", ".join(selected_columns)} from {table_name} limit 1 OFFSET {offset}")
+            self.assert_type_after_select(offset + 1, rows[0], all_types, pk_types, index, ttl, dml)
+
+    def create_types_for_all_select(
+        self, all_types: dict[str, str], pk_types: dict[str, str], index: dict[str, str], ttl: str
+    ):
+        statements = []
+        # delete if after https://github.com/ydb-platform/ydb/issues/16930
path: ydb/tests/datashard/select/test_select.py
user: login: dennnniska
body: убрал 
created_at: 2025-05-20T15:39:45Z
author_association: CONTRIBUTOR
diff_hunk: @@ -0,0 +1,409 @@
+import pytest
+
+from ydb.tests.sql.lib.test_base import TestBase
+from ydb.tests.datashard.lib.dml_operations import DMLOperations
+from ydb.tests.datashard.lib.types_of_variables import (
+    cleanup_type_name,
+    format_sql_value,
+    pk_types,
+    non_pk_types,
+    index_first,
+    index_second,
+    ttl_types,
+    index_first_sync,
+    index_second_sync,
+    index_three_sync,
+    index_three_sync_not_Bool,
+    index_four_sync,
+    index_zero_sync,
+)
+
+unsuppored_time_types = [
+    "Date32",
+    "Datetime64",
+    "Timestamp64",
+    "Interval64",
+]  # https://github.com/ydb-platform/ydb/issues/16930
+unsuppored_distinct_types = [
+    "DyNumber",
+    "UUID",  # https://github.com/ydb-platform/ydb/issues/17484
+]
+uncomparable_types = ["Json", "JsonDocument", "Yson"]
+
+
+class TestDML(TestBase):
+    @pytest.mark.parametrize(
+        "table_name, pk_types, all_types, index, ttl, unique, sync",
+        [
+            ("table_index_4_UNIQUE_SYNC", pk_types, {}, index_four_sync, "", "UNIQUE", "SYNC"),
+            ("table_index_3_UNIQUE_SYNC", pk_types, {}, index_three_sync_not_Bool, "", "UNIQUE", "SYNC"),
+            ("table_index_2_UNIQUE_SYNC", pk_types, {}, index_second_sync, "", "UNIQUE", "SYNC"),
+            ("table_index_1_UNIQUE_SYNC", pk_types, {}, index_first_sync, "", "UNIQUE", "SYNC"),
+            ("table_index_0_UNIQUE_SYNC", pk_types, {}, index_zero_sync, "", "UNIQUE", "SYNC"),
+            ("table_index_4__SYNC", pk_types, {}, index_four_sync, "", "", "SYNC"),
+            ("table_index_3__SYNC", pk_types, {}, index_three_sync, "", "", "SYNC"),
+            ("table_index_2__SYNC", pk_types, {}, index_second_sync, "", "", "SYNC"),
+            ("table_index_1__SYNC", pk_types, {}, index_first_sync, "", "", "SYNC"),
+            ("table_index_0__SYNC", pk_types, {}, index_zero_sync, "", "", "SYNC"),
+            ("table_index_1__ASYNC", pk_types, {}, index_second, "", "", "ASYNC"),
+            ("table_index_0__ASYNC", pk_types, {}, index_first, "", "", "ASYNC"),
+            ("table_all_types", pk_types, {**pk_types, **non_pk_types}, {}, "", "", ""),
+            ("table_ttl_DyNumber", pk_types, {}, {}, "DyNumber", "", ""),
+            ("table_ttl_Uint32", pk_types, {}, {}, "Uint32", "", ""),
+            ("table_ttl_Uint64", pk_types, {}, {}, "Uint64", "", ""),
+            ("table_ttl_Datetime", pk_types, {}, {}, "Datetime", "", ""),
+            ("table_ttl_Timestamp", pk_types, {}, {}, "Timestamp", "", ""),
+            ("table_ttl_Date", pk_types, {}, {}, "Date", "", ""),
+        ],
+    )
+    def test_select(
+        self,
+        table_name: str,
+        pk_types: dict[str, str],
+        all_types: dict[str, str],
+        index: dict[str, str],
+        ttl: str,
+        unique: str,
+        sync: str,
+    ):
+        dml = DMLOperations(self)
+        dml.create_table(table_name, pk_types, all_types, index, ttl, unique, sync)
+        dml.insert(table_name, all_types, pk_types, index, ttl)
+        self.select_with(table_name, all_types, pk_types, index, ttl, dml)
+        self.order_by(table_name, all_types, pk_types, index, ttl, dml)
+        self.limit(table_name, all_types, pk_types, index, ttl, dml)
+        self.from_select(table_name, all_types, pk_types, index, ttl, dml)
+        self.distinct(table_name, all_types, pk_types, index, ttl, dml)
+        self.union(table_name, all_types, pk_types, index, ttl, dml)
+        self.without(table_name, all_types, pk_types, index, ttl)
+        self.tablesample_sample(table_name, all_types, pk_types, index, ttl, dml)
+
+    def limit(
+        self,
+        table_name: str,
+        all_types: dict[str, str],
+        pk_types: dict[str, str],
+        index: dict[str, str],
+        ttl: str,
+        dml: DMLOperations,
+    ):
+        selected_columns = self.create_types_for_all_select(all_types, pk_types, index, ttl)
+
+        number_of_columns = self.get_number_of_columns(pk_types, all_types, index, ttl)
+
+        for offset in range(number_of_columns):
+            rows = self.query(f"select {", ".join(selected_columns)} from {table_name} limit 1 OFFSET {offset}")
+            self.assert_type_after_select(offset + 1, rows[0], all_types, pk_types, index, ttl, dml)
+
+    def create_types_for_all_select(
+        self, all_types: dict[str, str], pk_types: dict[str, str], index: dict[str, str], ttl: str
+    ):
+        statements = []
path: ydb/tests/datashard/select/test_select.py
user: login: dennnniska
body: переименовал 
created_at: 2025-05-20T15:39:53Z
author_association: CONTRIBUTOR

PR comments:
user: login: github-actions[bot]
created_at: 2025-04-21T15:10:46Z
body: <!-- status pr=17498, preset=release-asan, run=41020 -->
:white_circle: `2025-04-21 15:10:45 UTC` Pre-commit [check](https://github.com/ydb-platform/ydb/actions/runs/14575835968/job/40881672283) **linux-x86_64-release-asan** for dbd0b442ed8711ce24c29bff83c3c05323a7a2fb has started.
:white_circle: `2025-04-21 15:11:12 UTC` Artifacts will be uploaded [here](https://storage.yandexcloud.net/ydb-gh-logs/ydb-platform/ydb/PR-check/14575835968/ya-x86-64-asan/index.html)
:white_circle: `2025-04-21 15:14:05 UTC` ya make is running...
:yellow_circle: `2025-04-21 15:36:15 UTC` Some tests failed, follow the links below. This fail is not in blocking policy yet Going to retry failed tests...

<details>


[Test history](https://nebius.testmo.net/automation/runs/view/146531) | [Ya make output](https://storage.yandexcloud.net/ydb-gh-logs/ydb-platform/ydb/PR-check/14575835968/ya-x86-64-asan/ya_make_output.txt) | [Test bloat](https://storage.yandexcloud.net/ydb-gh-logs/ydb-platform/ydb/PR-check/14575835968/ya-x86-64-asan/try_1/test_bloat/tree_map.html)
| TESTS | PASSED | ERRORS | FAILED | SKIPPED | MUTED<sup>[?](https://github.com/ydb-platform/ydb/tree/main/.github/config/muted_ya.txt "All mute rules are defined here")</sup> |
| ---: | ---: | ---: | ---: | ---: | ---: |
| [42](https://storage.yandexcloud.net/ydb-gh-logs/ydb-platform/ydb/PR-check/14575835968/ya-x86-64-asan/try_1/ya-test.html) | [22](https://storage.yandexcloud.net/ydb-gh-logs/ydb-platform/ydb/PR-check/14575835968/ya-x86-64-asan/try_1/ya-test.html#PASS) | 0 | [20](https://storage.yandexcloud.net/ydb-gh-logs/ydb-platform/ydb/PR-check/14575835968/ya-x86-64-asan/try_1/ya-test.html#FAIL) | 0 | 0 |

</details>

:white_circle: `2025-04-21 15:36:23 UTC` ya make is running... (failed tests rerun, try 2)
:yellow_circle: `2025-04-21 15:37:56 UTC` Some tests failed, follow the links below. This fail is not in blocking policy yet Going to retry failed tests...

<details>


[Test history](https://nebius.testmo.net/automation/runs/view/146547) | [Ya make output](https://storage.yandexcloud.net/ydb-gh-logs/ydb-platform/ydb/PR-check/14575835968/ya-x86-64-asan/ya_make_output.txt) | [Test bloat](https://storage.yandexcloud.net/ydb-gh-logs/ydb-platform/ydb/PR-check/14575835968/ya-x86-64-asan/try_1/test_bloat/tree_map.html) | [Test bloat](https://storage.yandexcloud.net/ydb-gh-logs/ydb-platform/ydb/PR-check/14575835968/ya-x86-64-asan/try_2/test_bloat/tree_map.html)
| TESTS | PASSED | ERRORS | FAILED | SKIPPED | MUTED<sup>[?](https://github.com/ydb-platform/ydb/tree/main/.github/config/muted_ya.txt "All mute rules are defined here")</sup> |
| ---: | ---: | ---: | ---: | ---: | ---: |
| [40 (only retried tests)](https://storage.yandexcloud.net/ydb-gh-logs/ydb-platform/ydb/PR-check/14575835968/ya-x86-64-asan/try_2/ya-test.html) | [20](https://storage.yandexcloud.net/ydb-gh-logs/ydb-platform/ydb/PR-check/14575835968/ya-x86-64-asan/try_2/ya-test.html#PASS) | 0 | [20](https://storage.yandexcloud.net/ydb-gh-logs/ydb-platform/ydb/PR-check/14575835968/ya-x86-64-asan/try_2/ya-test.html#FAIL) | 0 | 0 |

</details>

:white_circle: `2025-04-21 15:38:04 UTC` ya make is running... (failed tests rerun, try 3)
:yellow_circle: `2025-04-21 15:39:41 UTC` Some tests failed, follow the links below. This fail is not in blocking policy yet

[Test history](https://nebius.testmo.net/automation/runs/view/146549) | [Ya make output](https://storage.yandexcloud.net/ydb-gh-logs/ydb-platform/ydb/PR-check/14575835968/ya-x86-64-asan/ya_make_output.txt) | [Test bloat](https://storage.yandexcloud.net/ydb-gh-logs/ydb-platform/ydb/PR-check/14575835968/ya-x86-64-asan/try_1/test_bloat/tree_map.html) | [Test bloat](https://storage.yandexcloud.net/ydb-gh-logs/ydb-platform/ydb/PR-check/14575835968/ya-x86-64-asan/try_2/test_bloat/tree_map.html) | [Test bloat](https://storage.yandexcloud.net/ydb-gh-logs/ydb-platform/ydb/PR-check/14575835968/ya-x86-64-asan/try_3/test_bloat/tree_map.html)
| TESTS | PASSED | ERRORS | FAILED | SKIPPED | MUTED<sup>[?](https://github.com/ydb-platform/ydb/tree/main/.github/config/muted_ya.txt "All mute rules are defined here")</sup> |
| ---: | ---: | ---: | ---: | ---: | ---: |
| [40 (only retried tests)](https://storage.yandexcloud.net/ydb-gh-logs/ydb-platform/ydb/PR-check/14575835968/ya-x86-64-asan/try_3/ya-test.html) | [20](https://storage.yandexcloud.net/ydb-gh-logs/ydb-platform/ydb/PR-check/14575835968/ya-x86-64-asan/try_3/ya-test.html#PASS) | 0 | [20](https://storage.yandexcloud.net/ydb-gh-logs/ydb-platform/ydb/PR-check/14575835968/ya-x86-64-asan/try_3/ya-test.html#FAIL) | 0 | 0 |

:green_circle: `2025-04-21 15:39:50 UTC` Build successful.
:green_circle: `2025-04-21 15:40:06 UTC` ydbd size **3.8 GiB** changed* by **+35.2 KiB**, which is < 100.0 KiB vs main: **OK**
|[ydbd size dash](https://datalens.yandex/cu6hzmpaki700)|main: 9a6920b87c8f27fc166301651184e83e11684115 |merge: dbd0b442ed8711ce24c29bff83c3c05323a7a2fb |diff | diff %|
|:--- | ---: | ---: | ---: | ---: |
|ydbd size|**4 130 236 808** Bytes |**4 130 272 840** Bytes|**+35.2 KiB**|**+0.001%**|
|ydbd stripped size|**1 430 083 288** Bytes|**1 430 095 736** Bytes|**+12.2 KiB**|**+0.001%**|

<sup>*please be aware that the difference is based on comparing your commit and the last completed build from the post-commit, check [comparation](https://github.com/ydb-platform/ydb/compare/9a6920b87c8f27fc166301651184e83e11684115..dbd0b442ed8711ce24c29bff83c3c05323a7a2fb)</sup>
author_association: NONE
user: login: github-actions[bot]
created_at: 2025-04-21T15:16:56Z
body: <!-- status pr=17498, validate PR description status -->
:green_circle: `2025-04-21 15:16:55 UTC` The validation of the Pull Request description is successful.
author_association: NONE
user: login: github-actions[bot]
created_at: 2025-04-21T15:25:20Z
body: <!-- status pr=17498, preset=relwithdebinfo, run=41020 -->
:white_circle: `2025-04-21 15:25:19 UTC` Pre-commit [check](https://github.com/ydb-platform/ydb/actions/runs/14575835968/job/40881672292) **linux-x86_64-relwithdebinfo** for dbd0b442ed8711ce24c29bff83c3c05323a7a2fb has started.
:white_circle: `2025-04-21 15:25:41 UTC` Artifacts will be uploaded [here](https://storage.yandexcloud.net/ydb-gh-logs/ydb-platform/ydb/PR-check/14575835968/ya-x86-64/index.html)
:white_circle: `2025-04-21 15:28:40 UTC` ya make is running...
:yellow_circle: `2025-04-21 15:31:30 UTC` Some tests failed, follow the links below. Going to retry failed tests...

<details>


[Test history](https://nebius.testmo.net/automation/runs/view/146540) | [Ya make output](https://storage.yandexcloud.net/ydb-gh-logs/ydb-platform/ydb/PR-check/14575835968/ya-x86-64/ya_make_output.txt) | [Test bloat](https://storage.yandexcloud.net/ydb-gh-logs/ydb-platform/ydb/PR-check/14575835968/ya-x86-64/try_1/test_bloat/tree_map.html)
| TESTS | PASSED | ERRORS | FAILED | SKIPPED | MUTED<sup>[?](https://github.com/ydb-platform/ydb/tree/main/.github/config/muted_ya.txt "All mute rules are defined here")</sup> |
| ---: | ---: | ---: | ---: | ---: | ---: |
| [44](https://storage.yandexcloud.net/ydb-gh-logs/ydb-platform/ydb/PR-check/14575835968/ya-x86-64/try_1/ya-test.html) | [24](https://storage.yandexcloud.net/ydb-gh-logs/ydb-platform/ydb/PR-check/14575835968/ya-x86-64/try_1/ya-test.html#PASS) | 0 | [20](https://storage.yandexcloud.net/ydb-gh-logs/ydb-platform/ydb/PR-check/14575835968/ya-x86-64/try_1/ya-test.html#FAIL) | 0 | 0 |

</details>

:white_circle: `2025-04-21 15:31:38 UTC` ya make is running... (failed tests rerun, try 2)
:yellow_circle: `2025-04-21 15:32:47 UTC` Some tests failed, follow the links below. Going to retry failed tests...

<details>


[Test history](https://nebius.testmo.net/automation/runs/view/146543) | [Ya make output](https://storage.yandexcloud.net/ydb-gh-logs/ydb-platform/ydb/PR-check/14575835968/ya-x86-64/ya_make_output.txt) | [Test bloat](https://storage.yandexcloud.net/ydb-gh-logs/ydb-platform/ydb/PR-check/14575835968/ya-x86-64/try_1/test_bloat/tree_map.html) | [Test bloat](https://storage.yandexcloud.net/ydb-gh-logs/ydb-platform/ydb/PR-check/14575835968/ya-x86-64/try_2/test_bloat/tree_map.html)
| TESTS | PASSED | ERRORS | FAILED | SKIPPED | MUTED<sup>[?](https://github.com/ydb-platform/ydb/tree/main/.github/config/muted_ya.txt "All mute rules are defined here")</sup> |
| ---: | ---: | ---: | ---: | ---: | ---: |
| [40 (only retried tests)](https://storage.yandexcloud.net/ydb-gh-logs/ydb-platform/ydb/PR-check/14575835968/ya-x86-64/try_2/ya-test.html) | [20](https://storage.yandexcloud.net/ydb-gh-logs/ydb-platform/ydb/PR-check/14575835968/ya-x86-64/try_2/ya-test.html#PASS) | 0 | [20](https://storage.yandexcloud.net/ydb-gh-logs/ydb-platform/ydb/PR-check/14575835968/ya-x86-64/try_2/ya-test.html#FAIL) | 0 | 0 |

</details>

:white_circle: `2025-04-21 15:32:55 UTC` ya make is running... (failed tests rerun, try 3)
:red_circle: `2025-04-21 15:34:03 UTC` Some tests failed, follow the links below.

[Test history](https://nebius.testmo.net/automation/runs/view/146544) | [Ya make output](https://storage.yandexcloud.net/ydb-gh-logs/ydb-platform/ydb/PR-check/14575835968/ya-x86-64/ya_make_output.txt) | [Test bloat](https://storage.yandexcloud.net/ydb-gh-logs/ydb-platform/ydb/PR-check/14575835968/ya-x86-64/try_1/test_bloat/tree_map.html) | [Test bloat](https://storage.yandexcloud.net/ydb-gh-logs/ydb-platform/ydb/PR-check/14575835968/ya-x86-64/try_2/test_bloat/tree_map.html) | [Test bloat](https://storage.yandexcloud.net/ydb-gh-logs/ydb-platform/ydb/PR-check/14575835968/ya-x86-64/try_3/test_bloat/tree_map.html)
| TESTS | PASSED | ERRORS | FAILED | SKIPPED | MUTED<sup>[?](https://github.com/ydb-platform/ydb/tree/main/.github/config/muted_ya.txt "All mute rules are defined here")</sup> |
| ---: | ---: | ---: | ---: | ---: | ---: |
| [40 (only retried tests)](https://storage.yandexcloud.net/ydb-gh-logs/ydb-platform/ydb/PR-check/14575835968/ya-x86-64/try_3/ya-test.html) | [20](https://storage.yandexcloud.net/ydb-gh-logs/ydb-platform/ydb/PR-check/14575835968/ya-x86-64/try_3/ya-test.html#PASS) | 0 | [20](https://storage.yandexcloud.net/ydb-gh-logs/ydb-platform/ydb/PR-check/14575835968/ya-x86-64/try_3/ya-test.html#FAIL) | 0 | 0 |

:green_circle: `2025-04-21 15:34:09 UTC` Build successful.
:green_circle: `2025-04-21 15:34:20 UTC` ydbd size **2.2 GiB** changed* by **+13.8 KiB**, which is < 100.0 KiB vs main: **OK**
|[ydbd size dash](https://datalens.yandex/cu6hzmpaki700)|main: 9a6920b87c8f27fc166301651184e83e11684115 |merge: dbd0b442ed8711ce24c29bff83c3c05323a7a2fb |diff | diff %|
|:--- | ---: | ---: | ---: | ---: |
|ydbd size|**2 351 384 608** Bytes |**2 351 398 688** Bytes|**+13.8 KiB**|**+0.001%**|
|ydbd stripped size|**493 681 152** Bytes|**493 683 424** Bytes|**+2.2 KiB**|**+0.000%**|

<sup>*please be aware that the difference is based on comparing your commit and the last completed build from the post-commit, check [comparation](https://github.com/ydb-platform/ydb/compare/9a6920b87c8f27fc166301651184e83e11684115..dbd0b442ed8711ce24c29bff83c3c05323a7a2fb)</sup>
author_association: NONE
user: login: github-actions[bot]
created_at: 2025-04-21T16:02:59Z
body: <!-- status pr=17498, preset=release-asan, run=41025 -->
:white_circle: `2025-04-21 16:02:59 UTC` Pre-commit [check](https://github.com/ydb-platform/ydb/actions/runs/14576630938/job/40884058629) **linux-x86_64-release-asan** for 5e6e952ec435dc59e3fe4f07e37ec42e7d0027bb has started.
:white_circle: `2025-04-21 16:03:15 UTC` Artifacts will be uploaded [here](https://storage.yandexcloud.net/ydb-gh-logs/ydb-platform/ydb/PR-check/14576630938/ya-x86-64-asan/index.html)
:white_circle: `2025-04-21 16:05:40 UTC` ya make is running...
:green_circle: `2025-04-21 16:10:41 UTC` Tests successful.

[Test history](https://nebius.testmo.net/automation/runs/view/146567) | [Ya make output](https://storage.yandexcloud.net/ydb-gh-logs/ydb-platform/ydb/PR-check/14576630938/ya-x86-64-asan/ya_make_output.txt) | [Test bloat](https://storage.yandexcloud.net/ydb-gh-logs/ydb-platform/ydb/PR-check/14576630938/ya-x86-64-asan/try_1/test_bloat/tree_map.html)
| TESTS | PASSED | ERRORS | FAILED | SKIPPED | MUTED<sup>[?](https://github.com/ydb-platform/ydb/tree/main/.github/config/muted_ya.txt "All mute rules are defined here")</sup> |
| ---: | ---: | ---: | ---: | ---: | ---: |
| [42](https://storage.yandexcloud.net/ydb-gh-logs/ydb-platform/ydb/PR-check/14576630938/ya-x86-64-asan/try_1/ya-test.html) | [42](https://storage.yandexcloud.net/ydb-gh-logs/ydb-platform/ydb/PR-check/14576630938/ya-x86-64-asan/try_1/ya-test.html#PASS) | 0 | 0 | 0 | 0 |

:green_circle: `2025-04-21 16:10:47 UTC` Build successful.
:green_circle: `2025-04-21 16:11:00 UTC` ydbd size **3.8 GiB** changed* by **+35.2 KiB**, which is < 100.0 KiB vs main: **OK**
|[ydbd size dash](https://datalens.yandex/cu6hzmpaki700)|main: 9a6920b87c8f27fc166301651184e83e11684115 |merge: 5e6e952ec435dc59e3fe4f07e37ec42e7d0027bb |diff | diff %|
|:--- | ---: | ---: | ---: | ---: |
|ydbd size|**4 130 236 808** Bytes |**4 130 272 840** Bytes|**+35.2 KiB**|**+0.001%**|
|ydbd stripped size|**1 430 083 288** Bytes|**1 430 095 736** Bytes|**+12.2 KiB**|**+0.001%**|

<sup>*please be aware that the difference is based on comparing your commit and the last completed build from the post-commit, check [comparation](https://github.com/ydb-platform/ydb/compare/9a6920b87c8f27fc166301651184e83e11684115..5e6e952ec435dc59e3fe4f07e37ec42e7d0027bb)</sup>
author_association: NONE
user: login: github-actions[bot]
created_at: 2025-04-21T16:03:00Z
body: <!-- status pr=17498, preset=relwithdebinfo, run=41025 -->
:white_circle: `2025-04-21 16:02:59 UTC` Pre-commit [check](https://github.com/ydb-platform/ydb/actions/runs/14576630938/job/40884058630) **linux-x86_64-relwithdebinfo** for 5e6e952ec435dc59e3fe4f07e37ec42e7d0027bb has started.
:white_circle: `2025-04-21 16:03:14 UTC` Artifacts will be uploaded [here](https://storage.yandexcloud.net/ydb-gh-logs/ydb-platform/ydb/PR-check/14576630938/ya-x86-64/index.html)
:white_circle: `2025-04-21 16:05:42 UTC` ya make is running...
:green_circle: `2025-04-21 16:07:51 UTC` Tests successful.

[Test history](https://nebius.testmo.net/automation/runs/view/146568) | [Ya make output](https://storage.yandexcloud.net/ydb-gh-logs/ydb-platform/ydb/PR-check/14576630938/ya-x86-64/ya_make_output.txt) | [Test bloat](https://storage.yandexcloud.net/ydb-gh-logs/ydb-platform/ydb/PR-check/14576630938/ya-x86-64/try_1/test_bloat/tree_map.html)
| TESTS | PASSED | ERRORS | FAILED | SKIPPED | MUTED<sup>[?](https://github.com/ydb-platform/ydb/tree/main/.github/config/muted_ya.txt "All mute rules are defined here")</sup> |
| ---: | ---: | ---: | ---: | ---: | ---: |
| [44](https://storage.yandexcloud.net/ydb-gh-logs/ydb-platform/ydb/PR-check/14576630938/ya-x86-64/try_1/ya-test.html) | [44](https://storage.yandexcloud.net/ydb-gh-logs/ydb-platform/ydb/PR-check/14576630938/ya-x86-64/try_1/ya-test.html#PASS) | 0 | 0 | 0 | 0 |

:green_circle: `2025-04-21 16:08:00 UTC` Build successful.
:green_circle: `2025-04-21 16:08:11 UTC` ydbd size **2.2 GiB** changed* by **+13.5 KiB**, which is < 100.0 KiB vs main: **OK**
|[ydbd size dash](https://datalens.yandex/cu6hzmpaki700)|main: 2530f5d7f7203e24b274c8f1083d0009f15b83a3 |merge: 5e6e952ec435dc59e3fe4f07e37ec42e7d0027bb |diff | diff %|
|:--- | ---: | ---: | ---: | ---: |
|ydbd size|**2 351 384 816** Bytes |**2 351 398 688** Bytes|**+13.5 KiB**|**+0.001%**|
|ydbd stripped size|**493 681 280** Bytes|**493 683 424** Bytes|**+2.1 KiB**|**+0.000%**|

<sup>*please be aware that the difference is based on comparing your commit and the last completed build from the post-commit, check [comparation](https://github.com/ydb-platform/ydb/compare/2530f5d7f7203e24b274c8f1083d0009f15b83a3..5e6e952ec435dc59e3fe4f07e37ec42e7d0027bb)</sup>
author_association: NONE
user: login: github-actions[bot]
created_at: 2025-04-28T12:54:41Z
body: <!-- status pr=17498, preset=release-asan, run=41710 -->
:white_circle: `2025-04-28 12:54:41 UTC` Pre-commit [check](https://github.com/ydb-platform/ydb/actions/runs/14707896689/job/41272527631) **linux-x86_64-release-asan** for 9f6ee5c52c485acc0d6f210c27a60e8413aab526 has started.
:white_circle: `2025-04-28 12:54:44 UTC` Artifacts will be uploaded [here](https://storage.yandexcloud.net/ydb-gh-logs/ydb-platform/ydb/PR-check/14707896689/ya-x86-64-asan/index.html)
:white_circle: `2025-04-28 12:56:56 UTC` ya make is running...
:yellow_circle: `2025-04-28 13:00:36 UTC` Some tests failed, follow the links below. This fail is not in blocking policy yet Going to retry failed tests...

<details>


[Test history](https://nebius.testmo.net/automation/runs/view/151071) | [Ya make output](https://storage.yandexcloud.net/ydb-gh-logs/ydb-platform/ydb/PR-check/14707896689/ya-x86-64-asan/ya_make_output.txt) | [Test bloat](https://storage.yandexcloud.net/ydb-gh-logs/ydb-platform/ydb/PR-check/14707896689/ya-x86-64-asan/try_1/test_bloat/tree_map.html)
| TESTS | PASSED | ERRORS | FAILED | SKIPPED | MUTED<sup>[?](https://github.com/ydb-platform/ydb/tree/main/.github/config/muted_ya.txt "All mute rules are defined here")</sup> |
| ---: | ---: | ---: | ---: | ---: | ---: |
| [32](https://storage.yandexcloud.net/ydb-gh-logs/ydb-platform/ydb/PR-check/14707896689/ya-x86-64-asan/try_1/ya-test.html) | [23](https://storage.yandexcloud.net/ydb-gh-logs/ydb-platform/ydb/PR-check/14707896689/ya-x86-64-asan/try_1/ya-test.html#PASS) | 0 | [9](https://storage.yandexcloud.net/ydb-gh-logs/ydb-platform/ydb/PR-check/14707896689/ya-x86-64-asan/try_1/ya-test.html#FAIL) | 0 | 0 |

</details>

:white_circle: `2025-04-28 13:00:47 UTC` ya make is running... (failed tests rerun, try 2)
:yellow_circle: `2025-04-28 13:02:50 UTC` Some tests failed, follow the links below. This fail is not in blocking policy yet Going to retry failed tests...

<details>


[Test history](https://nebius.testmo.net/automation/runs/view/151074) | [Ya make output](https://storage.yandexcloud.net/ydb-gh-logs/ydb-platform/ydb/PR-check/14707896689/ya-x86-64-asan/ya_make_output.txt) | [Test bloat](https://storage.yandexcloud.net/ydb-gh-logs/ydb-platform/ydb/PR-check/14707896689/ya-x86-64-asan/try_1/test_bloat/tree_map.html) | [Test bloat](https://storage.yandexcloud.net/ydb-gh-logs/ydb-platform/ydb/PR-check/14707896689/ya-x86-64-asan/try_2/test_bloat/tree_map.html)
| TESTS | PASSED | ERRORS | FAILED | SKIPPED | MUTED<sup>[?](https://github.com/ydb-platform/ydb/tree/main/.github/config/muted_ya.txt "All mute rules are defined here")</sup> |
| ---: | ---: | ---: | ---: | ---: | ---: |
| [18 (only retried tests)](https://storage.yandexcloud.net/ydb-gh-logs/ydb-platform/ydb/PR-check/14707896689/ya-x86-64-asan/try_2/ya-test.html) | [9](https://storage.yandexcloud.net/ydb-gh-logs/ydb-platform/ydb/PR-check/14707896689/ya-x86-64-asan/try_2/ya-test.html#PASS) | 0 | [9](https://storage.yandexcloud.net/ydb-gh-logs/ydb-platform/ydb/PR-check/14707896689/ya-x86-64-asan/try_2/ya-test.html#FAIL) | 0 | 0 |

</details>

:white_circle: `2025-04-28 13:02:59 UTC` ya make is running... (failed tests rerun, try 3)
:yellow_circle: `2025-04-28 13:05:02 UTC` Some tests failed, follow the links below. This fail is not in blocking policy yet

[Test history](https://nebius.testmo.net/automation/runs/view/151079) | [Ya make output](https://storage.yandexcloud.net/ydb-gh-logs/ydb-platform/ydb/PR-check/14707896689/ya-x86-64-asan/ya_make_output.txt) | [Test bloat](https://storage.yandexcloud.net/ydb-gh-logs/ydb-platform/ydb/PR-check/14707896689/ya-x86-64-asan/try_1/test_bloat/tree_map.html) | [Test bloat](https://storage.yandexcloud.net/ydb-gh-logs/ydb-platform/ydb/PR-check/14707896689/ya-x86-64-asan/try_2/test_bloat/tree_map.html) | [Test bloat](https://storage.yandexcloud.net/ydb-gh-logs/ydb-platform/ydb/PR-check/14707896689/ya-x86-64-asan/try_3/test_bloat/tree_map.html)
| TESTS | PASSED | ERRORS | FAILED | SKIPPED | MUTED<sup>[?](https://github.com/ydb-platform/ydb/tree/main/.github/config/muted_ya.txt "All mute rules are defined here")</sup> |
| ---: | ---: | ---: | ---: | ---: | ---: |
| [18 (only retried tests)](https://storage.yandexcloud.net/ydb-gh-logs/ydb-platform/ydb/PR-check/14707896689/ya-x86-64-asan/try_3/ya-test.html) | [9](https://storage.yandexcloud.net/ydb-gh-logs/ydb-platform/ydb/PR-check/14707896689/ya-x86-64-asan/try_3/ya-test.html#PASS) | 0 | [9](https://storage.yandexcloud.net/ydb-gh-logs/ydb-platform/ydb/PR-check/14707896689/ya-x86-64-asan/try_3/ya-test.html#FAIL) | 0 | 0 |

:green_circle: `2025-04-28 13:05:09 UTC` Build successful.
:yellow_circle: `2025-04-28 13:05:23 UTC` ydbd size **3.8 GiB** changed* by **+775.2 KiB**, which is >= 100.0 KiB vs main: **Warning**
|[ydbd size dash](https://datalens.yandex/cu6hzmpaki700)|main: 33bb0a9334d32a94e115d600947d67864753f137 |merge: 9f6ee5c52c485acc0d6f210c27a60e8413aab526 |diff | diff %|
|:--- | ---: | ---: | ---: | ---: |
|ydbd size|**4 120 493 536** Bytes |**4 121 287 392** Bytes|**+775.2 KiB**|**+0.019%**|
|ydbd stripped size|**1 428 581 976** Bytes|**1 428 682 840** Bytes|**+98.5 KiB**|**+0.007%**|

<sup>*please be aware that the difference is based on comparing your commit and the last completed build from the post-commit, check [comparation](https://github.com/ydb-platform/ydb/compare/33bb0a9334d32a94e115d600947d67864753f137..9f6ee5c52c485acc0d6f210c27a60e8413aab526)</sup>
author_association: NONE
user: login: github-actions[bot]
created_at: 2025-04-28T13:12:45Z
body: <!-- status pr=17498, preset=relwithdebinfo, run=41710 -->
:white_circle: `2025-04-28 13:12:44 UTC` Pre-commit [check](https://github.com/ydb-platform/ydb/actions/runs/14707896689/job/41272526861) **linux-x86_64-relwithdebinfo** for 9f6ee5c52c485acc0d6f210c27a60e8413aab526 has started.
:white_circle: `2025-04-28 13:12:50 UTC` Artifacts will be uploaded [here](https://storage.yandexcloud.net/ydb-gh-logs/ydb-platform/ydb/PR-check/14707896689/ya-x86-64/index.html)
:white_circle: `2025-04-28 13:15:10 UTC` ya make is running...
:yellow_circle: `2025-04-28 13:17:35 UTC` Some tests failed, follow the links below. Going to retry failed tests...

<details>


[Test history](https://nebius.testmo.net/automation/runs/view/151096) | [Ya make output](https://storage.yandexcloud.net/ydb-gh-logs/ydb-platform/ydb/PR-check/14707896689/ya-x86-64/ya_make_output.txt) | [Test bloat](https://storage.yandexcloud.net/ydb-gh-logs/ydb-platform/ydb/PR-check/14707896689/ya-x86-64/try_1/test_bloat/tree_map.html)
| TESTS | PASSED | ERRORS | FAILED | SKIPPED | MUTED<sup>[?](https://github.com/ydb-platform/ydb/tree/main/.github/config/muted_ya.txt "All mute rules are defined here")</sup> |
| ---: | ---: | ---: | ---: | ---: | ---: |
| [34](https://storage.yandexcloud.net/ydb-gh-logs/ydb-platform/ydb/PR-check/14707896689/ya-x86-64/try_1/ya-test.html) | [25](https://storage.yandexcloud.net/ydb-gh-logs/ydb-platform/ydb/PR-check/14707896689/ya-x86-64/try_1/ya-test.html#PASS) | 0 | [9](https://storage.yandexcloud.net/ydb-gh-logs/ydb-platform/ydb/PR-check/14707896689/ya-x86-64/try_1/ya-test.html#FAIL) | 0 | 0 |

</details>

:white_circle: `2025-04-28 13:17:44 UTC` ya make is running... (failed tests rerun, try 2)
:yellow_circle: `2025-04-28 13:19:00 UTC` Some tests failed, follow the links below. Going to retry failed tests...

<details>


[Test history](https://nebius.testmo.net/automation/runs/view/151101) | [Ya make output](https://storage.yandexcloud.net/ydb-gh-logs/ydb-platform/ydb/PR-check/14707896689/ya-x86-64/ya_make_output.txt) | [Test bloat](https://storage.yandexcloud.net/ydb-gh-logs/ydb-platform/ydb/PR-check/14707896689/ya-x86-64/try_1/test_bloat/tree_map.html) | [Test bloat](https://storage.yandexcloud.net/ydb-gh-logs/ydb-platform/ydb/PR-check/14707896689/ya-x86-64/try_2/test_bloat/tree_map.html)
| TESTS | PASSED | ERRORS | FAILED | SKIPPED | MUTED<sup>[?](https://github.com/ydb-platform/ydb/tree/main/.github/config/muted_ya.txt "All mute rules are defined here")</sup> |
| ---: | ---: | ---: | ---: | ---: | ---: |
| [18 (only retried tests)](https://storage.yandexcloud.net/ydb-gh-logs/ydb-platform/ydb/PR-check/14707896689/ya-x86-64/try_2/ya-test.html) | [9](https://storage.yandexcloud.net/ydb-gh-logs/ydb-platform/ydb/PR-check/14707896689/ya-x86-64/try_2/ya-test.html#PASS) | 0 | [9](https://storage.yandexcloud.net/ydb-gh-logs/ydb-platform/ydb/PR-check/14707896689/ya-x86-64/try_2/ya-test.html#FAIL) | 0 | 0 |

</details>

:white_circle: `2025-04-28 13:19:08 UTC` ya make is running... (failed tests rerun, try 3)
:red_circle: `2025-04-28 13:20:10 UTC` Some tests failed, follow the links below.

[Test history](https://nebius.testmo.net/automation/runs/view/151107) | [Ya make output](https://storage.yandexcloud.net/ydb-gh-logs/ydb-platform/ydb/PR-check/14707896689/ya-x86-64/ya_make_output.txt) | [Test bloat](https://storage.yandexcloud.net/ydb-gh-logs/ydb-platform/ydb/PR-check/14707896689/ya-x86-64/try_1/test_bloat/tree_map.html) | [Test bloat](https://storage.yandexcloud.net/ydb-gh-logs/ydb-platform/ydb/PR-check/14707896689/ya-x86-64/try_2/test_bloat/tree_map.html) | [Test bloat](https://storage.yandexcloud.net/ydb-gh-logs/ydb-platform/ydb/PR-check/14707896689/ya-x86-64/try_3/test_bloat/tree_map.html)
| TESTS | PASSED | ERRORS | FAILED | SKIPPED | MUTED<sup>[?](https://github.com/ydb-platform/ydb/tree/main/.github/config/muted_ya.txt "All mute rules are defined here")</sup> |
| ---: | ---: | ---: | ---: | ---: | ---: |
| [18 (only retried tests)](https://storage.yandexcloud.net/ydb-gh-logs/ydb-platform/ydb/PR-check/14707896689/ya-x86-64/try_3/ya-test.html) | [9](https://storage.yandexcloud.net/ydb-gh-logs/ydb-platform/ydb/PR-check/14707896689/ya-x86-64/try_3/ya-test.html#PASS) | 0 | [9](https://storage.yandexcloud.net/ydb-gh-logs/ydb-platform/ydb/PR-check/14707896689/ya-x86-64/try_3/ya-test.html#FAIL) | 0 | 0 |

:green_circle: `2025-04-28 13:20:17 UTC` Build successful.
:yellow_circle: `2025-04-28 13:20:28 UTC` ydbd size **2.2 GiB** changed* by **+464.4 KiB**, which is >= 100.0 KiB vs main: **Warning**
|[ydbd size dash](https://datalens.yandex/cu6hzmpaki700)|main: 33bb0a9334d32a94e115d600947d67864753f137 |merge: 9f6ee5c52c485acc0d6f210c27a60e8413aab526 |diff | diff %|
|:--- | ---: | ---: | ---: | ---: |
|ydbd size|**2 342 243 864** Bytes |**2 342 719 408** Bytes|**+464.4 KiB**|**+0.020%**|
|ydbd stripped size|**492 613 728** Bytes|**492 637 152** Bytes|**+22.9 KiB**|**+0.005%**|

<sup>*please be aware that the difference is based on comparing your commit and the last completed build from the post-commit, check [comparation](https://github.com/ydb-platform/ydb/compare/33bb0a9334d32a94e115d600947d67864753f137..9f6ee5c52c485acc0d6f210c27a60e8413aab526)</sup>
author_association: NONE
user: login: github-actions[bot]
created_at: 2025-05-07T11:33:16Z
body: <!-- status pr=17498, preset=release-asan, run=42413 -->
:white_circle: `2025-05-07 11:33:15 UTC` Pre-commit [check](https://github.com/ydb-platform/ydb/actions/runs/14882178987/job/41792655547) **linux-x86_64-release-asan** for 281f2409bb5cc9d280eb17d4706244b740021955 has started.
:white_circle: `2025-05-07 11:33:45 UTC` Artifacts will be uploaded [here](https://storage.yandexcloud.net/ydb-gh-logs/ydb-platform/ydb/PR-check/14882178987/ya-x86-64-asan/index.html)
:white_circle: `2025-05-07 11:36:31 UTC` ya make is running...
:yellow_circle: `2025-05-07 11:59:12 UTC` Some tests failed, follow the links below. This fail is not in blocking policy yet Going to retry failed tests...

<details>


[Test history](https://nebius.testmo.net/automation/runs/view/156330) | [Ya make output](https://storage.yandexcloud.net/ydb-gh-logs/ydb-platform/ydb/PR-check/14882178987/ya-x86-64-asan/ya_make_output.txt) | [Test bloat](https://storage.yandexcloud.net/ydb-gh-logs/ydb-platform/ydb/PR-check/14882178987/ya-x86-64-asan/try_1/test_bloat/tree_map.html)
| TESTS | PASSED | ERRORS | FAILED | SKIPPED | MUTED<sup>[?](https://github.com/ydb-platform/ydb/tree/main/.github/config/muted_ya.txt "All mute rules are defined here")</sup> |
| ---: | ---: | ---: | ---: | ---: | ---: |
| [32](https://storage.yandexcloud.net/ydb-gh-logs/ydb-platform/ydb/PR-check/14882178987/ya-x86-64-asan/try_1/ya-test.html) | [23](https://storage.yandexcloud.net/ydb-gh-logs/ydb-platform/ydb/PR-check/14882178987/ya-x86-64-asan/try_1/ya-test.html#PASS) | 0 | [9](https://storage.yandexcloud.net/ydb-gh-logs/ydb-platform/ydb/PR-check/14882178987/ya-x86-64-asan/try_1/ya-test.html#FAIL) | 0 | 0 |

</details>

:white_circle: `2025-05-07 11:59:20 UTC` ya make is running... (failed tests rerun, try 2)
:yellow_circle: `2025-05-07 12:01:15 UTC` Some tests failed, follow the links below. This fail is not in blocking policy yet Going to retry failed tests...

<details>


[Test history](https://nebius.testmo.net/automation/runs/view/156352) | [Ya make output](https://storage.yandexcloud.net/ydb-gh-logs/ydb-platform/ydb/PR-check/14882178987/ya-x86-64-asan/ya_make_output.txt) | [Test bloat](https://storage.yandexcloud.net/ydb-gh-logs/ydb-platform/ydb/PR-check/14882178987/ya-x86-64-asan/try_1/test_bloat/tree_map.html) | [Test bloat](https://storage.yandexcloud.net/ydb-gh-logs/ydb-platform/ydb/PR-check/14882178987/ya-x86-64-asan/try_2/test_bloat/tree_map.html)
| TESTS | PASSED | ERRORS | FAILED | SKIPPED | MUTED<sup>[?](https://github.com/ydb-platform/ydb/tree/main/.github/config/muted_ya.txt "All mute rules are defined here")</sup> |
| ---: | ---: | ---: | ---: | ---: | ---: |
| [18 (only retried tests)](https://storage.yandexcloud.net/ydb-gh-logs/ydb-platform/ydb/PR-check/14882178987/ya-x86-64-asan/try_2/ya-test.html) | [9](https://storage.yandexcloud.net/ydb-gh-logs/ydb-platform/ydb/PR-check/14882178987/ya-x86-64-asan/try_2/ya-test.html#PASS) | 0 | [9](https://storage.yandexcloud.net/ydb-gh-logs/ydb-platform/ydb/PR-check/14882178987/ya-x86-64-asan/try_2/ya-test.html#FAIL) | 0 | 0 |

</details>

:white_circle: `2025-05-07 12:01:25 UTC` ya make is running... (failed tests rerun, try 3)
:yellow_circle: `2025-05-07 12:03:43 UTC` Some tests failed, follow the links below. This fail is not in blocking policy yet

[Test history](https://nebius.testmo.net/automation/runs/view/156355) | [Ya make output](https://storage.yandexcloud.net/ydb-gh-logs/ydb-platform/ydb/PR-check/14882178987/ya-x86-64-asan/ya_make_output.txt) | [Test bloat](https://storage.yandexcloud.net/ydb-gh-logs/ydb-platform/ydb/PR-check/14882178987/ya-x86-64-asan/try_1/test_bloat/tree_map.html) | [Test bloat](https://storage.yandexcloud.net/ydb-gh-logs/ydb-platform/ydb/PR-check/14882178987/ya-x86-64-asan/try_2/test_bloat/tree_map.html) | [Test bloat](https://storage.yandexcloud.net/ydb-gh-logs/ydb-platform/ydb/PR-check/14882178987/ya-x86-64-asan/try_3/test_bloat/tree_map.html)
| TESTS | PASSED | ERRORS | FAILED | SKIPPED | MUTED<sup>[?](https://github.com/ydb-platform/ydb/tree/main/.github/config/muted_ya.txt "All mute rules are defined here")</sup> |
| ---: | ---: | ---: | ---: | ---: | ---: |
| [18 (only retried tests)](https://storage.yandexcloud.net/ydb-gh-logs/ydb-platform/ydb/PR-check/14882178987/ya-x86-64-asan/try_3/ya-test.html) | [9](https://storage.yandexcloud.net/ydb-gh-logs/ydb-platform/ydb/PR-check/14882178987/ya-x86-64-asan/try_3/ya-test.html#PASS) | 0 | [9](https://storage.yandexcloud.net/ydb-gh-logs/ydb-platform/ydb/PR-check/14882178987/ya-x86-64-asan/try_3/ya-test.html#FAIL) | 0 | 0 |

:green_circle: `2025-05-07 12:03:53 UTC` Build successful.
:green_circle: `2025-05-07 12:04:08 UTC` ydbd size **3.8 GiB** changed* by **-129.6 KiB**, which is <= 0 Bytes vs main: **OK**
|[ydbd size dash](https://datalens.yandex/cu6hzmpaki700)|main: 017f2e19bdfbd65969dea8b3a3cfdb46bd4c59da |merge: 281f2409bb5cc9d280eb17d4706244b740021955 |diff | diff %|
|:--- | ---: | ---: | ---: | ---: |
|ydbd size|**4 126 470 648** Bytes |**4 126 337 912** Bytes|**-129.6 KiB**|**-0.003%**|
|ydbd stripped size|**1 432 983 000** Bytes|**1 432 722 176** Bytes|**-254.7 KiB**|**-0.018%**|

<sup>*please be aware that the difference is based on comparing your commit and the last completed build from the post-commit, check [comparation](https://github.com/ydb-platform/ydb/compare/017f2e19bdfbd65969dea8b3a3cfdb46bd4c59da..281f2409bb5cc9d280eb17d4706244b740021955)</sup>
author_association: NONE
user: login: github-actions[bot]
created_at: 2025-05-07T12:22:43Z
body: <!-- status pr=17498, preset=relwithdebinfo, run=42413 -->
:white_circle: `2025-05-07 12:22:43 UTC` Pre-commit [check](https://github.com/ydb-platform/ydb/actions/runs/14882178987/job/41792655532) **linux-x86_64-relwithdebinfo** for 281f2409bb5cc9d280eb17d4706244b740021955 has started.
:white_circle: `2025-05-07 12:22:50 UTC` Artifacts will be uploaded [here](https://storage.yandexcloud.net/ydb-gh-logs/ydb-platform/ydb/PR-check/14882178987/ya-x86-64/index.html)
:white_circle: `2025-05-07 12:25:08 UTC` ya make is running...
:yellow_circle: `2025-05-07 12:27:20 UTC` Some tests failed, follow the links below. Going to retry failed tests...

<details>


[Test history](https://nebius.testmo.net/automation/runs/view/156371) | [Ya make output](https://storage.yandexcloud.net/ydb-gh-logs/ydb-platform/ydb/PR-check/14882178987/ya-x86-64/ya_make_output.txt) | [Test bloat](https://storage.yandexcloud.net/ydb-gh-logs/ydb-platform/ydb/PR-check/14882178987/ya-x86-64/try_1/test_bloat/tree_map.html)
| TESTS | PASSED | ERRORS | FAILED | SKIPPED | MUTED<sup>[?](https://github.com/ydb-platform/ydb/tree/main/.github/config/muted_ya.txt "All mute rules are defined here")</sup> |
| ---: | ---: | ---: | ---: | ---: | ---: |
| [34](https://storage.yandexcloud.net/ydb-gh-logs/ydb-platform/ydb/PR-check/14882178987/ya-x86-64/try_1/ya-test.html) | [25](https://storage.yandexcloud.net/ydb-gh-logs/ydb-platform/ydb/PR-check/14882178987/ya-x86-64/try_1/ya-test.html#PASS) | 0 | [9](https://storage.yandexcloud.net/ydb-gh-logs/ydb-platform/ydb/PR-check/14882178987/ya-x86-64/try_1/ya-test.html#FAIL) | 0 | 0 |

</details>

:white_circle: `2025-05-07 12:27:34 UTC` ya make is running... (failed tests rerun, try 2)
:yellow_circle: `2025-05-07 12:29:35 UTC` Some tests failed, follow the links below. Going to retry failed tests...

<details>


[Test history](https://nebius.testmo.net/automation/runs/view/156373) | [Ya make output](https://storage.yandexcloud.net/ydb-gh-logs/ydb-platform/ydb/PR-check/14882178987/ya-x86-64/ya_make_output.txt) | [Test bloat](https://storage.yandexcloud.net/ydb-gh-logs/ydb-platform/ydb/PR-check/14882178987/ya-x86-64/try_1/test_bloat/tree_map.html) | [Test bloat](https://storage.yandexcloud.net/ydb-gh-logs/ydb-platform/ydb/PR-check/14882178987/ya-x86-64/try_2/test_bloat/tree_map.html)
| TESTS | PASSED | ERRORS | FAILED | SKIPPED | MUTED<sup>[?](https://github.com/ydb-platform/ydb/tree/main/.github/config/muted_ya.txt "All mute rules are defined here")</sup> |
| ---: | ---: | ---: | ---: | ---: | ---: |
| [18 (only retried tests)](https://storage.yandexcloud.net/ydb-gh-logs/ydb-platform/ydb/PR-check/14882178987/ya-x86-64/try_2/ya-test.html) | [9](https://storage.yandexcloud.net/ydb-gh-logs/ydb-platform/ydb/PR-check/14882178987/ya-x86-64/try_2/ya-test.html#PASS) | 0 | [9](https://storage.yandexcloud.net/ydb-gh-logs/ydb-platform/ydb/PR-check/14882178987/ya-x86-64/try_2/ya-test.html#FAIL) | 0 | 0 |

</details>

:white_circle: `2025-05-07 12:29:46 UTC` ya make is running... (failed tests rerun, try 3)
:red_circle: `2025-05-07 12:31:07 UTC` Some tests failed, follow the links below.

[Test history](https://nebius.testmo.net/automation/runs/view/156374) | [Ya make output](https://storage.yandexcloud.net/ydb-gh-logs/ydb-platform/ydb/PR-check/14882178987/ya-x86-64/ya_make_output.txt) | [Test bloat](https://storage.yandexcloud.net/ydb-gh-logs/ydb-platform/ydb/PR-check/14882178987/ya-x86-64/try_1/test_bloat/tree_map.html) | [Test bloat](https://storage.yandexcloud.net/ydb-gh-logs/ydb-platform/ydb/PR-check/14882178987/ya-x86-64/try_2/test_bloat/tree_map.html) | [Test bloat](https://storage.yandexcloud.net/ydb-gh-logs/ydb-platform/ydb/PR-check/14882178987/ya-x86-64/try_3/test_bloat/tree_map.html)
| TESTS | PASSED | ERRORS | FAILED | SKIPPED | MUTED<sup>[?](https://github.com/ydb-platform/ydb/tree/main/.github/config/muted_ya.txt "All mute rules are defined here")</sup> |
| ---: | ---: | ---: | ---: | ---: | ---: |
| [18 (only retried tests)](https://storage.yandexcloud.net/ydb-gh-logs/ydb-platform/ydb/PR-check/14882178987/ya-x86-64/try_3/ya-test.html) | [9](https://storage.yandexcloud.net/ydb-gh-logs/ydb-platform/ydb/PR-check/14882178987/ya-x86-64/try_3/ya-test.html#PASS) | 0 | [9](https://storage.yandexcloud.net/ydb-gh-logs/ydb-platform/ydb/PR-check/14882178987/ya-x86-64/try_3/ya-test.html#FAIL) | 0 | 0 |

:green_circle: `2025-05-07 12:31:13 UTC` Build successful.
:red_circle: `2025-05-07 12:31:25 UTC` ydbd size **2.2 GiB** changed* by **+2.4 MiB**, which is >= 2.0 MiB vs main: **Alert**
|[ydbd size dash](https://datalens.yandex/cu6hzmpaki700)|main: 017f2e19bdfbd65969dea8b3a3cfdb46bd4c59da |merge: 281f2409bb5cc9d280eb17d4706244b740021955 |diff | diff %|
|:--- | ---: | ---: | ---: | ---: |
|ydbd size|**2 343 701 888** Bytes |**2 346 269 176** Bytes|**+2.4 MiB**|**+0.110%**|
|ydbd stripped size|**493 033 920** Bytes|**493 370 608** Bytes|**+328.8 KiB**|**+0.068%**|

<sup>*please be aware that the difference is based on comparing your commit and the last completed build from the post-commit, check [comparation](https://github.com/ydb-platform/ydb/compare/017f2e19bdfbd65969dea8b3a3cfdb46bd4c59da..281f2409bb5cc9d280eb17d4706244b740021955)</sup>
author_association: NONE
user: login: github-actions[bot]
created_at: 2025-05-12T14:35:14Z
body: <!-- status pr=17498, preset=relwithdebinfo, run=42651 -->
:white_circle: `2025-05-12 14:35:13 UTC` Pre-commit [check](https://github.com/ydb-platform/ydb/actions/runs/14974997491/job/42064955613) **linux-x86_64-relwithdebinfo** for 6ca82c71f78423673fac023104880ef8d2814d38 has started.
:white_circle: `2025-05-12 14:35:24 UTC` Artifacts will be uploaded [here](https://storage.yandexcloud.net/ydb-gh-logs/ydb-platform/ydb/PR-check/14974997491/ya-x86-64/index.html)
:white_circle: `2025-05-12 14:37:37 UTC` ya make is running...
:yellow_circle: `2025-05-12 14:39:56 UTC` Some tests failed, follow the links below. Going to retry failed tests...

<details>


[Test history](https://nebius.testmo.net/automation/runs/view/158527) | [Ya make output](https://storage.yandexcloud.net/ydb-gh-logs/ydb-platform/ydb/PR-check/14974997491/ya-x86-64/ya_make_output.txt) | [Test bloat](https://storage.yandexcloud.net/ydb-gh-logs/ydb-platform/ydb/PR-check/14974997491/ya-x86-64/try_1/test_bloat/tree_map.html)
| TESTS | PASSED | ERRORS | FAILED | SKIPPED | MUTED<sup>[?](https://github.com/ydb-platform/ydb/tree/main/.github/config/muted_ya.txt "All mute rules are defined here")</sup> |
| ---: | ---: | ---: | ---: | ---: | ---: |
| [6](https://storage.yandexcloud.net/ydb-gh-logs/ydb-platform/ydb/PR-check/14974997491/ya-x86-64/try_1/ya-test.html) | [5](https://storage.yandexcloud.net/ydb-gh-logs/ydb-platform/ydb/PR-check/14974997491/ya-x86-64/try_1/ya-test.html#PASS) | 0 | [1](https://storage.yandexcloud.net/ydb-gh-logs/ydb-platform/ydb/PR-check/14974997491/ya-x86-64/try_1/ya-test.html#FAIL) | 0 | 0 |

</details>

:white_circle: `2025-05-12 14:40:06 UTC` ya make is running... (failed tests rerun, try 2)
:yellow_circle: `2025-05-12 14:42:20 UTC` Some tests failed, follow the links below. Going to retry failed tests...

<details>


[Test history](https://nebius.testmo.net/automation/runs/view/158530) | [Ya make output](https://storage.yandexcloud.net/ydb-gh-logs/ydb-platform/ydb/PR-check/14974997491/ya-x86-64/ya_make_output.txt) | [Test bloat](https://storage.yandexcloud.net/ydb-gh-logs/ydb-platform/ydb/PR-check/14974997491/ya-x86-64/try_1/test_bloat/tree_map.html) | [Test bloat](https://storage.yandexcloud.net/ydb-gh-logs/ydb-platform/ydb/PR-check/14974997491/ya-x86-64/try_2/test_bloat/tree_map.html)
| TESTS | PASSED | ERRORS | FAILED | SKIPPED | MUTED<sup>[?](https://github.com/ydb-platform/ydb/tree/main/.github/config/muted_ya.txt "All mute rules are defined here")</sup> |
| ---: | ---: | ---: | ---: | ---: | ---: |
| [2 (only retried tests)](https://storage.yandexcloud.net/ydb-gh-logs/ydb-platform/ydb/PR-check/14974997491/ya-x86-64/try_2/ya-test.html) | [1](https://storage.yandexcloud.net/ydb-gh-logs/ydb-platform/ydb/PR-check/14974997491/ya-x86-64/try_2/ya-test.html#PASS) | 0 | [1](https://storage.yandexcloud.net/ydb-gh-logs/ydb-platform/ydb/PR-check/14974997491/ya-x86-64/try_2/ya-test.html#FAIL) | 0 | 0 |

</details>

:white_circle: `2025-05-12 14:42:28 UTC` ya make is running... (failed tests rerun, try 3)
:red_circle: `2025-05-12 14:43:24 UTC` Some tests failed, follow the links below.

[Test history](https://nebius.testmo.net/automation/runs/view/158533) | [Ya make output](https://storage.yandexcloud.net/ydb-gh-logs/ydb-platform/ydb/PR-check/14974997491/ya-x86-64/ya_make_output.txt) | [Test bloat](https://storage.yandexcloud.net/ydb-gh-logs/ydb-platform/ydb/PR-check/14974997491/ya-x86-64/try_1/test_bloat/tree_map.html) | [Test bloat](https://storage.yandexcloud.net/ydb-gh-logs/ydb-platform/ydb/PR-check/14974997491/ya-x86-64/try_2/test_bloat/tree_map.html) | [Test bloat](https://storage.yandexcloud.net/ydb-gh-logs/ydb-platform/ydb/PR-check/14974997491/ya-x86-64/try_3/test_bloat/tree_map.html)
| TESTS | PASSED | ERRORS | FAILED | SKIPPED | MUTED<sup>[?](https://github.com/ydb-platform/ydb/tree/main/.github/config/muted_ya.txt "All mute rules are defined here")</sup> |
| ---: | ---: | ---: | ---: | ---: | ---: |
| [2 (only retried tests)](https://storage.yandexcloud.net/ydb-gh-logs/ydb-platform/ydb/PR-check/14974997491/ya-x86-64/try_3/ya-test.html) | [1](https://storage.yandexcloud.net/ydb-gh-logs/ydb-platform/ydb/PR-check/14974997491/ya-x86-64/try_3/ya-test.html#PASS) | 0 | [1](https://storage.yandexcloud.net/ydb-gh-logs/ydb-platform/ydb/PR-check/14974997491/ya-x86-64/try_3/ya-test.html#FAIL) | 0 | 0 |

:green_circle: `2025-05-12 14:43:30 UTC` Build successful.
:green_circle: `2025-05-12 14:43:39 UTC` ydbd size **2.2 GiB** changed* by **+64 Bytes**, which is < 100.0 KiB vs main: **OK**
|[ydbd size dash](https://datalens.yandex/cu6hzmpaki700)|main: da5cb373c58f80af6d189035a8a2d126954f059d |merge: 6ca82c71f78423673fac023104880ef8d2814d38 |diff | diff %|
|:--- | ---: | ---: | ---: | ---: |
|ydbd size|**2 351 909 104** Bytes |**2 351 909 168** Bytes|**+64 Bytes**|**+0.000%**|
|ydbd stripped size|**494 236 496** Bytes|**494 236 560** Bytes|**+64 Bytes**|**+0.000%**|

<sup>*please be aware that the difference is based on comparing your commit and the last completed build from the post-commit, check [comparation](https://github.com/ydb-platform/ydb/compare/da5cb373c58f80af6d189035a8a2d126954f059d..6ca82c71f78423673fac023104880ef8d2814d38)</sup>
author_association: NONE
user: login: github-actions[bot]
created_at: 2025-05-12T14:35:32Z
body: <!-- status pr=17498, preset=release-asan, run=42651 -->
:white_circle: `2025-05-12 14:35:31 UTC` Pre-commit [check](https://github.com/ydb-platform/ydb/actions/runs/14974997491/job/42064955673) **linux-x86_64-release-asan** for 6ca82c71f78423673fac023104880ef8d2814d38 has started.
:white_circle: `2025-05-12 14:35:43 UTC` Artifacts will be uploaded [here](https://storage.yandexcloud.net/ydb-gh-logs/ydb-platform/ydb/PR-check/14974997491/ya-x86-64-asan/index.html)
:white_circle: `2025-05-12 14:38:01 UTC` ya make is running...
:yellow_circle: `2025-05-12 14:41:59 UTC` Some tests failed, follow the links below. This fail is not in blocking policy yet Going to retry failed tests...

<details>


[Test history](https://nebius.testmo.net/automation/runs/view/158528) | [Ya make output](https://storage.yandexcloud.net/ydb-gh-logs/ydb-platform/ydb/PR-check/14974997491/ya-x86-64-asan/ya_make_output.txt) | [Test bloat](https://storage.yandexcloud.net/ydb-gh-logs/ydb-platform/ydb/PR-check/14974997491/ya-x86-64-asan/try_1/test_bloat/tree_map.html)
| TESTS | PASSED | ERRORS | FAILED | SKIPPED | MUTED<sup>[?](https://github.com/ydb-platform/ydb/tree/main/.github/config/muted_ya.txt "All mute rules are defined here")</sup> |
| ---: | ---: | ---: | ---: | ---: | ---: |
| [4](https://storage.yandexcloud.net/ydb-gh-logs/ydb-platform/ydb/PR-check/14974997491/ya-x86-64-asan/try_1/ya-test.html) | [3](https://storage.yandexcloud.net/ydb-gh-logs/ydb-platform/ydb/PR-check/14974997491/ya-x86-64-asan/try_1/ya-test.html#PASS) | 0 | [1](https://storage.yandexcloud.net/ydb-gh-logs/ydb-platform/ydb/PR-check/14974997491/ya-x86-64-asan/try_1/ya-test.html#FAIL) | 0 | 0 |

</details>

:white_circle: `2025-05-12 14:42:08 UTC` ya make is running... (failed tests rerun, try 2)
:yellow_circle: `2025-05-12 14:42:50 UTC` Some tests failed, follow the links below. This fail is not in blocking policy yet Going to retry failed tests...

<details>


[Test history](https://nebius.testmo.net/automation/runs/view/158532) | [Ya make output](https://storage.yandexcloud.net/ydb-gh-logs/ydb-platform/ydb/PR-check/14974997491/ya-x86-64-asan/ya_make_output.txt) | [Test bloat](https://storage.yandexcloud.net/ydb-gh-logs/ydb-platform/ydb/PR-check/14974997491/ya-x86-64-asan/try_1/test_bloat/tree_map.html) | [Test bloat](https://storage.yandexcloud.net/ydb-gh-logs/ydb-platform/ydb/PR-check/14974997491/ya-x86-64-asan/try_2/test_bloat/tree_map.html)
| TESTS | PASSED | ERRORS | FAILED | SKIPPED | MUTED<sup>[?](https://github.com/ydb-platform/ydb/tree/main/.github/config/muted_ya.txt "All mute rules are defined here")</sup> |
| ---: | ---: | ---: | ---: | ---: | ---: |
| [2 (only retried tests)](https://storage.yandexcloud.net/ydb-gh-logs/ydb-platform/ydb/PR-check/14974997491/ya-x86-64-asan/try_2/ya-test.html) | [1](https://storage.yandexcloud.net/ydb-gh-logs/ydb-platform/ydb/PR-check/14974997491/ya-x86-64-asan/try_2/ya-test.html#PASS) | 0 | [1](https://storage.yandexcloud.net/ydb-gh-logs/ydb-platform/ydb/PR-check/14974997491/ya-x86-64-asan/try_2/ya-test.html#FAIL) | 0 | 0 |

</details>

:white_circle: `2025-05-12 14:42:58 UTC` ya make is running... (failed tests rerun, try 3)
:yellow_circle: `2025-05-12 14:43:41 UTC` Some tests failed, follow the links below. This fail is not in blocking policy yet

[Test history](https://nebius.testmo.net/automation/runs/view/158534) | [Ya make output](https://storage.yandexcloud.net/ydb-gh-logs/ydb-platform/ydb/PR-check/14974997491/ya-x86-64-asan/ya_make_output.txt) | [Test bloat](https://storage.yandexcloud.net/ydb-gh-logs/ydb-platform/ydb/PR-check/14974997491/ya-x86-64-asan/try_1/test_bloat/tree_map.html) | [Test bloat](https://storage.yandexcloud.net/ydb-gh-logs/ydb-platform/ydb/PR-check/14974997491/ya-x86-64-asan/try_2/test_bloat/tree_map.html) | [Test bloat](https://storage.yandexcloud.net/ydb-gh-logs/ydb-platform/ydb/PR-check/14974997491/ya-x86-64-asan/try_3/test_bloat/tree_map.html)
| TESTS | PASSED | ERRORS | FAILED | SKIPPED | MUTED<sup>[?](https://github.com/ydb-platform/ydb/tree/main/.github/config/muted_ya.txt "All mute rules are defined here")</sup> |
| ---: | ---: | ---: | ---: | ---: | ---: |
| [2 (only retried tests)](https://storage.yandexcloud.net/ydb-gh-logs/ydb-platform/ydb/PR-check/14974997491/ya-x86-64-asan/try_3/ya-test.html) | [1](https://storage.yandexcloud.net/ydb-gh-logs/ydb-platform/ydb/PR-check/14974997491/ya-x86-64-asan/try_3/ya-test.html#PASS) | 0 | [1](https://storage.yandexcloud.net/ydb-gh-logs/ydb-platform/ydb/PR-check/14974997491/ya-x86-64-asan/try_3/ya-test.html#FAIL) | 0 | 0 |

:green_circle: `2025-05-12 14:43:49 UTC` Build successful.
:green_circle: `2025-05-12 14:44:02 UTC` ydbd size **3.9 GiB** changed* by **+96 Bytes**, which is < 100.0 KiB vs main: **OK**
|[ydbd size dash](https://datalens.yandex/cu6hzmpaki700)|main: da5cb373c58f80af6d189035a8a2d126954f059d |merge: 6ca82c71f78423673fac023104880ef8d2814d38 |diff | diff %|
|:--- | ---: | ---: | ---: | ---: |
|ydbd size|**4 137 940 728** Bytes |**4 137 940 824** Bytes|**+96 Bytes**|**+0.000%**|
|ydbd stripped size|**1 435 922 080** Bytes|**1 435 922 176** Bytes|**+96 Bytes**|**+0.000%**|

<sup>*please be aware that the difference is based on comparing your commit and the last completed build from the post-commit, check [comparation](https://github.com/ydb-platform/ydb/compare/da5cb373c58f80af6d189035a8a2d126954f059d..6ca82c71f78423673fac023104880ef8d2814d38)</sup>
author_association: NONE
user: login: github-actions[bot]
created_at: 2025-05-13T08:20:37Z
body: <!-- status pr=17498, preset=relwithdebinfo, run=42717 -->
:white_circle: `2025-05-13 08:20:37 UTC` Pre-commit [check](https://github.com/ydb-platform/ydb/actions/runs/14991667048/job/42116250069) **linux-x86_64-relwithdebinfo** for 736a991b722615c1777b9920a23f8afdd0a7932e has started.
:white_circle: `2025-05-13 08:20:48 UTC` Artifacts will be uploaded [here](https://storage.yandexcloud.net/ydb-gh-logs/ydb-platform/ydb/PR-check/14991667048/ya-x86-64/index.html)
:white_circle: `2025-05-13 08:23:09 UTC` ya make is running...
:green_circle: `2025-05-13 08:25:19 UTC` Tests successful.

[Test history](https://nebius.testmo.net/automation/runs/view/159012) | [Ya make output](https://storage.yandexcloud.net/ydb-gh-logs/ydb-platform/ydb/PR-check/14991667048/ya-x86-64/ya_make_output.txt) | [Test bloat](https://storage.yandexcloud.net/ydb-gh-logs/ydb-platform/ydb/PR-check/14991667048/ya-x86-64/try_1/test_bloat/tree_map.html)
| TESTS | PASSED | ERRORS | FAILED | SKIPPED | MUTED<sup>[?](https://github.com/ydb-platform/ydb/tree/main/.github/config/muted_ya.txt "All mute rules are defined here")</sup> |
| ---: | ---: | ---: | ---: | ---: | ---: |
| [44](https://storage.yandexcloud.net/ydb-gh-logs/ydb-platform/ydb/PR-check/14991667048/ya-x86-64/try_1/ya-test.html) | [44](https://storage.yandexcloud.net/ydb-gh-logs/ydb-platform/ydb/PR-check/14991667048/ya-x86-64/try_1/ya-test.html#PASS) | 0 | 0 | 0 | 0 |

:green_circle: `2025-05-13 08:25:25 UTC` Build successful.
:green_circle: `2025-05-13 08:25:35 UTC` ydbd size **2.2 GiB** changed* by **0 Bytes**, which is <= 0 Bytes vs main: **OK**
|[ydbd size dash](https://datalens.yandex/cu6hzmpaki700)|main: 44eee93d680bb084f40e934c14a1065c3a0b7a01 |merge: 736a991b722615c1777b9920a23f8afdd0a7932e |diff | diff %|
|:--- | ---: | ---: | ---: | ---: |
|ydbd size|**2 351 862 664** Bytes |**2 351 862 664** Bytes|**0 Bytes**|**0.000%**|
|ydbd stripped size|**494 228 944** Bytes|**494 228 944** Bytes|**0 Bytes**|**0.000%**|

<sup>*please be aware that the difference is based on comparing your commit and the last completed build from the post-commit, check [comparation](https://github.com/ydb-platform/ydb/compare/44eee93d680bb084f40e934c14a1065c3a0b7a01..736a991b722615c1777b9920a23f8afdd0a7932e)</sup>
author_association: NONE
user: login: github-actions[bot]
created_at: 2025-05-13T08:20:47Z
body: <!-- status pr=17498, preset=release-asan, run=42717 -->
:white_circle: `2025-05-13 08:20:47 UTC` Pre-commit [check](https://github.com/ydb-platform/ydb/actions/runs/14991667048/job/42116250103) **linux-x86_64-release-asan** for 736a991b722615c1777b9920a23f8afdd0a7932e has started.
:white_circle: `2025-05-13 08:20:57 UTC` Artifacts will be uploaded [here](https://storage.yandexcloud.net/ydb-gh-logs/ydb-platform/ydb/PR-check/14991667048/ya-x86-64-asan/index.html)
:white_circle: `2025-05-13 08:23:14 UTC` ya make is running...
:green_circle: `2025-05-13 08:28:02 UTC` Tests successful.

[Test history](https://nebius.testmo.net/automation/runs/view/159013) | [Ya make output](https://storage.yandexcloud.net/ydb-gh-logs/ydb-platform/ydb/PR-check/14991667048/ya-x86-64-asan/ya_make_output.txt) | [Test bloat](https://storage.yandexcloud.net/ydb-gh-logs/ydb-platform/ydb/PR-check/14991667048/ya-x86-64-asan/try_1/test_bloat/tree_map.html)
| TESTS | PASSED | ERRORS | FAILED | SKIPPED | MUTED<sup>[?](https://github.com/ydb-platform/ydb/tree/main/.github/config/muted_ya.txt "All mute rules are defined here")</sup> |
| ---: | ---: | ---: | ---: | ---: | ---: |
| [42](https://storage.yandexcloud.net/ydb-gh-logs/ydb-platform/ydb/PR-check/14991667048/ya-x86-64-asan/try_1/ya-test.html) | [42](https://storage.yandexcloud.net/ydb-gh-logs/ydb-platform/ydb/PR-check/14991667048/ya-x86-64-asan/try_1/ya-test.html#PASS) | 0 | 0 | 0 | 0 |

:green_circle: `2025-05-13 08:28:09 UTC` Build successful.
:green_circle: `2025-05-13 08:28:21 UTC` ydbd size **3.9 GiB** changed* by **-80 Bytes**, which is <= 0 Bytes vs main: **OK**
|[ydbd size dash](https://datalens.yandex/cu6hzmpaki700)|main: 44eee93d680bb084f40e934c14a1065c3a0b7a01 |merge: 736a991b722615c1777b9920a23f8afdd0a7932e |diff | diff %|
|:--- | ---: | ---: | ---: | ---: |
|ydbd size|**4 137 918 456** Bytes |**4 137 918 376** Bytes|**-80 Bytes**|**-0.000%**|
|ydbd stripped size|**1 435 911 392** Bytes|**1 435 911 328** Bytes|**-64 Bytes**|**-0.000%**|

<sup>*please be aware that the difference is based on comparing your commit and the last completed build from the post-commit, check [comparation](https://github.com/ydb-platform/ydb/compare/44eee93d680bb084f40e934c14a1065c3a0b7a01..736a991b722615c1777b9920a23f8afdd0a7932e)</sup>
author_association: NONE
user: login: github-actions[bot]
created_at: 2025-05-16T10:26:49Z
body: <!-- status pr=17498, preset=relwithdebinfo, run=43155 -->
:white_circle: `2025-05-16 10:26:49 UTC` Pre-commit [check](https://github.com/ydb-platform/ydb/actions/runs/15065386735/job/42348949369) **linux-x86_64-relwithdebinfo** for ddf89e73d0cd135ca49f255ff4ea5072c8a1956e has started.
:white_circle: `2025-05-16 10:27:12 UTC` Artifacts will be uploaded [here](https://storage.yandexcloud.net/ydb-gh-logs/ydb-platform/ydb/PR-check/15065386735/ya-x86-64/index.html)
:white_circle: `2025-05-16 10:29:59 UTC` ya make is running...
:green_circle: `2025-05-16 10:31:58 UTC` Tests successful.

[Test history](https://nebius.testmo.net/automation/runs/view/161704) | [Ya make output](https://storage.yandexcloud.net/ydb-gh-logs/ydb-platform/ydb/PR-check/15065386735/ya-x86-64/ya_make_output.txt) | [Test bloat](https://storage.yandexcloud.net/ydb-gh-logs/ydb-platform/ydb/PR-check/15065386735/ya-x86-64/try_1/test_bloat/tree_map.html)
| TESTS | PASSED | ERRORS | FAILED | SKIPPED | MUTED<sup>[?](https://github.com/ydb-platform/ydb/tree/main/.github/config/muted_ya.txt "All mute rules are defined here")</sup> |
| ---: | ---: | ---: | ---: | ---: | ---: |
| [44](https://storage.yandexcloud.net/ydb-gh-logs/ydb-platform/ydb/PR-check/15065386735/ya-x86-64/try_1/ya-test.html) | [44](https://storage.yandexcloud.net/ydb-gh-logs/ydb-platform/ydb/PR-check/15065386735/ya-x86-64/try_1/ya-test.html#PASS) | 0 | 0 | 0 | 0 |

:green_circle: `2025-05-16 10:32:04 UTC` Build successful.
:yellow_circle: `2025-05-16 10:32:15 UTC` ydbd size **2.2 GiB** changed* by **+228.6 KiB**, which is >= 100.0 KiB vs main: **Warning**
|[ydbd size dash](https://datalens.yandex/cu6hzmpaki700)|main: 4a8f76ce64378dfa725472677202cc6831a2c4b9 |merge: ddf89e73d0cd135ca49f255ff4ea5072c8a1956e |diff | diff %|
|:--- | ---: | ---: | ---: | ---: |
|ydbd size|**2 353 150 216** Bytes |**2 353 384 296** Bytes|**+228.6 KiB**|**+0.010%**|
|ydbd stripped size|**494 602 504** Bytes|**494 609 544** Bytes|**+6.9 KiB**|**+0.001%**|

<sup>*please be aware that the difference is based on comparing your commit and the last completed build from the post-commit, check [comparation](https://github.com/ydb-platform/ydb/compare/4a8f76ce64378dfa725472677202cc6831a2c4b9..ddf89e73d0cd135ca49f255ff4ea5072c8a1956e)</sup>
author_association: NONE
user: login: github-actions[bot]
created_at: 2025-05-16T10:27:44Z
body: <!-- status pr=17498, preset=release-asan, run=43155 -->
:white_circle: `2025-05-16 10:27:44 UTC` Pre-commit [check](https://github.com/ydb-platform/ydb/actions/runs/15065386735/job/42348949375) **linux-x86_64-release-asan** for ddf89e73d0cd135ca49f255ff4ea5072c8a1956e has started.
:white_circle: `2025-05-16 10:28:30 UTC` Artifacts will be uploaded [here](https://storage.yandexcloud.net/ydb-gh-logs/ydb-platform/ydb/PR-check/15065386735/ya-x86-64-asan/index.html)
:white_circle: `2025-05-16 10:32:54 UTC` ya make is running...
:green_circle: `2025-05-16 10:43:24 UTC` Tests successful.

[Test history](https://nebius.testmo.net/automation/runs/view/161710) | [Ya make output](https://storage.yandexcloud.net/ydb-gh-logs/ydb-platform/ydb/PR-check/15065386735/ya-x86-64-asan/ya_make_output.txt) | [Test bloat](https://storage.yandexcloud.net/ydb-gh-logs/ydb-platform/ydb/PR-check/15065386735/ya-x86-64-asan/try_1/test_bloat/tree_map.html)
| TESTS | PASSED | ERRORS | FAILED | SKIPPED | MUTED<sup>[?](https://github.com/ydb-platform/ydb/tree/main/.github/config/muted_ya.txt "All mute rules are defined here")</sup> |
| ---: | ---: | ---: | ---: | ---: | ---: |
| [42](https://storage.yandexcloud.net/ydb-gh-logs/ydb-platform/ydb/PR-check/15065386735/ya-x86-64-asan/try_1/ya-test.html) | [42](https://storage.yandexcloud.net/ydb-gh-logs/ydb-platform/ydb/PR-check/15065386735/ya-x86-64-asan/try_1/ya-test.html#PASS) | 0 | 0 | 0 | 0 |

:green_circle: `2025-05-16 10:43:32 UTC` Build successful.
:yellow_circle: `2025-05-16 10:43:52 UTC` ydbd size **3.9 GiB** changed* by **+287.0 KiB**, which is >= 100.0 KiB vs main: **Warning**
|[ydbd size dash](https://datalens.yandex/cu6hzmpaki700)|main: 4a8f76ce64378dfa725472677202cc6831a2c4b9 |merge: ddf89e73d0cd135ca49f255ff4ea5072c8a1956e |diff | diff %|
|:--- | ---: | ---: | ---: | ---: |
|ydbd size|**4 140 252 184** Bytes |**4 140 546 096** Bytes|**+287.0 KiB**|**+0.007%**|
|ydbd stripped size|**1 437 294 008** Bytes|**1 437 332 728** Bytes|**+37.8 KiB**|**+0.003%**|

<sup>*please be aware that the difference is based on comparing your commit and the last completed build from the post-commit, check [comparation](https://github.com/ydb-platform/ydb/compare/4a8f76ce64378dfa725472677202cc6831a2c4b9..ddf89e73d0cd135ca49f255ff4ea5072c8a1956e)</sup>
author_association: NONE
user: login: github-actions[bot]
created_at: 2025-05-18T11:30:43Z
body: <!-- status pr=17498, preset=release-asan, run=43303 -->
:white_circle: `2025-05-18 11:30:42 UTC` Pre-commit [check](https://github.com/ydb-platform/ydb/actions/runs/15095457314/job/42429509400) **linux-x86_64-release-asan** for 10e3c821313d8e7dcd012d2f0cfd43e5fbdb722e has started.
:white_circle: `2025-05-18 11:30:54 UTC` Artifacts will be uploaded [here](https://storage.yandexcloud.net/ydb-gh-logs/ydb-platform/ydb/PR-check/15095457314/ya-x86-64-asan/index.html)
:white_circle: `2025-05-18 11:33:14 UTC` ya make is running...
:yellow_circle: `2025-05-18 11:42:03 UTC` Some tests failed, follow the links below. This fail is not in blocking policy yet Going to retry failed tests...

<details>


[Test history](https://nebius.testmo.net/automation/runs/view/162711) | [Ya make output](https://storage.yandexcloud.net/ydb-gh-logs/ydb-platform/ydb/PR-check/15095457314/ya-x86-64-asan/ya_make_output.txt) | [Test bloat](https://storage.yandexcloud.net/ydb-gh-logs/ydb-platform/ydb/PR-check/15095457314/ya-x86-64-asan/try_1/test_bloat/tree_map.html)
| TESTS | PASSED | ERRORS | FAILED | SKIPPED | MUTED<sup>[?](https://github.com/ydb-platform/ydb/tree/main/.github/config/muted_ya.txt "All mute rules are defined here")</sup> |
| ---: | ---: | ---: | ---: | ---: | ---: |
| [42](https://storage.yandexcloud.net/ydb-gh-logs/ydb-platform/ydb/PR-check/15095457314/ya-x86-64-asan/try_1/ya-test.html) | [23](https://storage.yandexcloud.net/ydb-gh-logs/ydb-platform/ydb/PR-check/15095457314/ya-x86-64-asan/try_1/ya-test.html#PASS) | 0 | [19](https://storage.yandexcloud.net/ydb-gh-logs/ydb-platform/ydb/PR-check/15095457314/ya-x86-64-asan/try_1/ya-test.html#FAIL) | 0 | 0 |

</details>

:white_circle: `2025-05-18 11:42:11 UTC` ya make is running... (failed tests rerun, try 2)
:yellow_circle: `2025-05-18 11:44:05 UTC` Some tests failed, follow the links below. This fail is not in blocking policy yet Going to retry failed tests...

<details>


[Test history](https://nebius.testmo.net/automation/runs/view/162714) | [Ya make output](https://storage.yandexcloud.net/ydb-gh-logs/ydb-platform/ydb/PR-check/15095457314/ya-x86-64-asan/ya_make_output.txt) | [Test bloat](https://storage.yandexcloud.net/ydb-gh-logs/ydb-platform/ydb/PR-check/15095457314/ya-x86-64-asan/try_1/test_bloat/tree_map.html) | [Test bloat](https://storage.yandexcloud.net/ydb-gh-logs/ydb-platform/ydb/PR-check/15095457314/ya-x86-64-asan/try_2/test_bloat/tree_map.html)
| TESTS | PASSED | ERRORS | FAILED | SKIPPED | MUTED<sup>[?](https://github.com/ydb-platform/ydb/tree/main/.github/config/muted_ya.txt "All mute rules are defined here")</sup> |
| ---: | ---: | ---: | ---: | ---: | ---: |
| [38 (only retried tests)](https://storage.yandexcloud.net/ydb-gh-logs/ydb-platform/ydb/PR-check/15095457314/ya-x86-64-asan/try_2/ya-test.html) | [19](https://storage.yandexcloud.net/ydb-gh-logs/ydb-platform/ydb/PR-check/15095457314/ya-x86-64-asan/try_2/ya-test.html#PASS) | 0 | [19](https://storage.yandexcloud.net/ydb-gh-logs/ydb-platform/ydb/PR-check/15095457314/ya-x86-64-asan/try_2/ya-test.html#FAIL) | 0 | 0 |

</details>

:white_circle: `2025-05-18 11:44:15 UTC` ya make is running... (failed tests rerun, try 3)
:yellow_circle: `2025-05-18 11:46:00 UTC` Some tests failed, follow the links below. This fail is not in blocking policy yet

[Test history](https://nebius.testmo.net/automation/runs/view/162718) | [Ya make output](https://storage.yandexcloud.net/ydb-gh-logs/ydb-platform/ydb/PR-check/15095457314/ya-x86-64-asan/ya_make_output.txt) | [Test bloat](https://storage.yandexcloud.net/ydb-gh-logs/ydb-platform/ydb/PR-check/15095457314/ya-x86-64-asan/try_1/test_bloat/tree_map.html) | [Test bloat](https://storage.yandexcloud.net/ydb-gh-logs/ydb-platform/ydb/PR-check/15095457314/ya-x86-64-asan/try_2/test_bloat/tree_map.html) | [Test bloat](https://storage.yandexcloud.net/ydb-gh-logs/ydb-platform/ydb/PR-check/15095457314/ya-x86-64-asan/try_3/test_bloat/tree_map.html)
| TESTS | PASSED | ERRORS | FAILED | SKIPPED | MUTED<sup>[?](https://github.com/ydb-platform/ydb/tree/main/.github/config/muted_ya.txt "All mute rules are defined here")</sup> |
| ---: | ---: | ---: | ---: | ---: | ---: |
| [38 (only retried tests)](https://storage.yandexcloud.net/ydb-gh-logs/ydb-platform/ydb/PR-check/15095457314/ya-x86-64-asan/try_3/ya-test.html) | [19](https://storage.yandexcloud.net/ydb-gh-logs/ydb-platform/ydb/PR-check/15095457314/ya-x86-64-asan/try_3/ya-test.html#PASS) | 0 | [19](https://storage.yandexcloud.net/ydb-gh-logs/ydb-platform/ydb/PR-check/15095457314/ya-x86-64-asan/try_3/ya-test.html#FAIL) | 0 | 0 |

:green_circle: `2025-05-18 11:46:06 UTC` Build successful.
:green_circle: `2025-05-18 11:46:21 UTC` ydbd size **3.9 GiB** changed* by **-96 Bytes**, which is <= 0 Bytes vs main: **OK**
|[ydbd size dash](https://datalens.yandex/cu6hzmpaki700)|main: dee22ec17f9818abef2a8bfb2a2ad405c97eabb9 |merge: 10e3c821313d8e7dcd012d2f0cfd43e5fbdb722e |diff | diff %|
|:--- | ---: | ---: | ---: | ---: |
|ydbd size|**4 141 785 720** Bytes |**4 141 785 624** Bytes|**-96 Bytes**|**-0.000%**|
|ydbd stripped size|**1 437 649 848** Bytes|**1 437 649 784** Bytes|**-64 Bytes**|**-0.000%**|

<sup>*please be aware that the difference is based on comparing your commit and the last completed build from the post-commit, check [comparation](https://github.com/ydb-platform/ydb/compare/dee22ec17f9818abef2a8bfb2a2ad405c97eabb9..10e3c821313d8e7dcd012d2f0cfd43e5fbdb722e)</sup>
author_association: NONE
user: login: github-actions[bot]
created_at: 2025-05-18T11:30:43Z
body: <!-- status pr=17498, preset=relwithdebinfo, run=43303 -->
:white_circle: `2025-05-18 11:30:43 UTC` Pre-commit [check](https://github.com/ydb-platform/ydb/actions/runs/15095457314/job/42429509397) **linux-x86_64-relwithdebinfo** for 10e3c821313d8e7dcd012d2f0cfd43e5fbdb722e has started.
:white_circle: `2025-05-18 11:30:57 UTC` Artifacts will be uploaded [here](https://storage.yandexcloud.net/ydb-gh-logs/ydb-platform/ydb/PR-check/15095457314/ya-x86-64/index.html)
:white_circle: `2025-05-18 11:33:20 UTC` ya make is running...
:yellow_circle: `2025-05-18 11:41:50 UTC` Some tests failed, follow the links below. Going to retry failed tests...

<details>


[Test history](https://nebius.testmo.net/automation/runs/view/162712) | [Ya make output](https://storage.yandexcloud.net/ydb-gh-logs/ydb-platform/ydb/PR-check/15095457314/ya-x86-64/ya_make_output.txt) | [Test bloat](https://storage.yandexcloud.net/ydb-gh-logs/ydb-platform/ydb/PR-check/15095457314/ya-x86-64/try_1/test_bloat/tree_map.html)
| TESTS | PASSED | ERRORS | FAILED | SKIPPED | MUTED<sup>[?](https://github.com/ydb-platform/ydb/tree/main/.github/config/muted_ya.txt "All mute rules are defined here")</sup> |
| ---: | ---: | ---: | ---: | ---: | ---: |
| [44](https://storage.yandexcloud.net/ydb-gh-logs/ydb-platform/ydb/PR-check/15095457314/ya-x86-64/try_1/ya-test.html) | [25](https://storage.yandexcloud.net/ydb-gh-logs/ydb-platform/ydb/PR-check/15095457314/ya-x86-64/try_1/ya-test.html#PASS) | 0 | [19](https://storage.yandexcloud.net/ydb-gh-logs/ydb-platform/ydb/PR-check/15095457314/ya-x86-64/try_1/ya-test.html#FAIL) | 0 | 0 |

</details>

:white_circle: `2025-05-18 11:41:58 UTC` ya make is running... (failed tests rerun, try 2)
:yellow_circle: `2025-05-18 11:43:04 UTC` Some tests failed, follow the links below. Going to retry failed tests...

<details>


[Test history](https://nebius.testmo.net/automation/runs/view/162713) | [Ya make output](https://storage.yandexcloud.net/ydb-gh-logs/ydb-platform/ydb/PR-check/15095457314/ya-x86-64/ya_make_output.txt) | [Test bloat](https://storage.yandexcloud.net/ydb-gh-logs/ydb-platform/ydb/PR-check/15095457314/ya-x86-64/try_1/test_bloat/tree_map.html) | [Test bloat](https://storage.yandexcloud.net/ydb-gh-logs/ydb-platform/ydb/PR-check/15095457314/ya-x86-64/try_2/test_bloat/tree_map.html)
| TESTS | PASSED | ERRORS | FAILED | SKIPPED | MUTED<sup>[?](https://github.com/ydb-platform/ydb/tree/main/.github/config/muted_ya.txt "All mute rules are defined here")</sup> |
| ---: | ---: | ---: | ---: | ---: | ---: |
| [38 (only retried tests)](https://storage.yandexcloud.net/ydb-gh-logs/ydb-platform/ydb/PR-check/15095457314/ya-x86-64/try_2/ya-test.html) | [19](https://storage.yandexcloud.net/ydb-gh-logs/ydb-platform/ydb/PR-check/15095457314/ya-x86-64/try_2/ya-test.html#PASS) | 0 | [19](https://storage.yandexcloud.net/ydb-gh-logs/ydb-platform/ydb/PR-check/15095457314/ya-x86-64/try_2/ya-test.html#FAIL) | 0 | 0 |

</details>

:white_circle: `2025-05-18 11:43:12 UTC` ya make is running... (failed tests rerun, try 3)
:red_circle: `2025-05-18 11:44:32 UTC` Some tests failed, follow the links below.

[Test history](https://nebius.testmo.net/automation/runs/view/162716) | [Ya make output](https://storage.yandexcloud.net/ydb-gh-logs/ydb-platform/ydb/PR-check/15095457314/ya-x86-64/ya_make_output.txt) | [Test bloat](https://storage.yandexcloud.net/ydb-gh-logs/ydb-platform/ydb/PR-check/15095457314/ya-x86-64/try_1/test_bloat/tree_map.html) | [Test bloat](https://storage.yandexcloud.net/ydb-gh-logs/ydb-platform/ydb/PR-check/15095457314/ya-x86-64/try_2/test_bloat/tree_map.html) | [Test bloat](https://storage.yandexcloud.net/ydb-gh-logs/ydb-platform/ydb/PR-check/15095457314/ya-x86-64/try_3/test_bloat/tree_map.html)
| TESTS | PASSED | ERRORS | FAILED | SKIPPED | MUTED<sup>[?](https://github.com/ydb-platform/ydb/tree/main/.github/config/muted_ya.txt "All mute rules are defined here")</sup> |
| ---: | ---: | ---: | ---: | ---: | ---: |
| [38 (only retried tests)](https://storage.yandexcloud.net/ydb-gh-logs/ydb-platform/ydb/PR-check/15095457314/ya-x86-64/try_3/ya-test.html) | [19](https://storage.yandexcloud.net/ydb-gh-logs/ydb-platform/ydb/PR-check/15095457314/ya-x86-64/try_3/ya-test.html#PASS) | 0 | [19](https://storage.yandexcloud.net/ydb-gh-logs/ydb-platform/ydb/PR-check/15095457314/ya-x86-64/try_3/ya-test.html#FAIL) | 0 | 0 |

:green_circle: `2025-05-18 11:44:38 UTC` Build successful.
:green_circle: `2025-05-18 11:44:48 UTC` ydbd size **2.2 GiB** changed* by **0 Bytes**, which is <= 0 Bytes vs main: **OK**
|[ydbd size dash](https://datalens.yandex/cu6hzmpaki700)|main: dee22ec17f9818abef2a8bfb2a2ad405c97eabb9 |merge: 10e3c821313d8e7dcd012d2f0cfd43e5fbdb722e |diff | diff %|
|:--- | ---: | ---: | ---: | ---: |
|ydbd size|**2 354 367 768** Bytes |**2 354 367 768** Bytes|**0 Bytes**|**0.000%**|
|ydbd stripped size|**494 719 752** Bytes|**494 719 752** Bytes|**0 Bytes**|**0.000%**|

<sup>*please be aware that the difference is based on comparing your commit and the last completed build from the post-commit, check [comparation](https://github.com/ydb-platform/ydb/compare/dee22ec17f9818abef2a8bfb2a2ad405c97eabb9..10e3c821313d8e7dcd012d2f0cfd43e5fbdb722e)</sup>
author_association: NONE
user: login: github-actions[bot]
created_at: 2025-05-18T12:38:27Z
body: <!-- status pr=17498, preset=relwithdebinfo, run=43306 -->
:white_circle: `2025-05-18 12:38:27 UTC` Pre-commit [check](https://github.com/ydb-platform/ydb/actions/runs/15095998511/job/42430751414) **linux-x86_64-relwithdebinfo** for ababf834d80925a9cdb9eeb90339840c5e453d31 has started.
:white_circle: `2025-05-18 12:38:31 UTC` Artifacts will be uploaded [here](https://storage.yandexcloud.net/ydb-gh-logs/ydb-platform/ydb/PR-check/15095998511/ya-x86-64/index.html)
:white_circle: `2025-05-18 12:40:42 UTC` ya make is running...
:green_circle: `2025-05-18 12:42:37 UTC` Tests successful.

[Test history](https://nebius.testmo.net/automation/runs/view/162730) | [Ya make output](https://storage.yandexcloud.net/ydb-gh-logs/ydb-platform/ydb/PR-check/15095998511/ya-x86-64/ya_make_output.txt) | [Test bloat](https://storage.yandexcloud.net/ydb-gh-logs/ydb-platform/ydb/PR-check/15095998511/ya-x86-64/try_1/test_bloat/tree_map.html)
| TESTS | PASSED | ERRORS | FAILED | SKIPPED | MUTED<sup>[?](https://github.com/ydb-platform/ydb/tree/main/.github/config/muted_ya.txt "All mute rules are defined here")</sup> |
| ---: | ---: | ---: | ---: | ---: | ---: |
| [44](https://storage.yandexcloud.net/ydb-gh-logs/ydb-platform/ydb/PR-check/15095998511/ya-x86-64/try_1/ya-test.html) | [44](https://storage.yandexcloud.net/ydb-gh-logs/ydb-platform/ydb/PR-check/15095998511/ya-x86-64/try_1/ya-test.html#PASS) | 0 | 0 | 0 | 0 |

:green_circle: `2025-05-18 12:42:43 UTC` Build successful.
:green_circle: `2025-05-18 12:42:52 UTC` ydbd size **2.2 GiB** changed* by **0 Bytes**, which is <= 0 Bytes vs main: **OK**
|[ydbd size dash](https://datalens.yandex/cu6hzmpaki700)|main: dee22ec17f9818abef2a8bfb2a2ad405c97eabb9 |merge: ababf834d80925a9cdb9eeb90339840c5e453d31 |diff | diff %|
|:--- | ---: | ---: | ---: | ---: |
|ydbd size|**2 354 367 768** Bytes |**2 354 367 768** Bytes|**0 Bytes**|**0.000%**|
|ydbd stripped size|**494 719 752** Bytes|**494 719 752** Bytes|**0 Bytes**|**0.000%**|

<sup>*please be aware that the difference is based on comparing your commit and the last completed build from the post-commit, check [comparation](https://github.com/ydb-platform/ydb/compare/dee22ec17f9818abef2a8bfb2a2ad405c97eabb9..ababf834d80925a9cdb9eeb90339840c5e453d31)</sup>
author_association: NONE
user: login: github-actions[bot]
created_at: 2025-05-18T12:38:35Z
body: <!-- status pr=17498, preset=release-asan, run=43306 -->
:white_circle: `2025-05-18 12:38:35 UTC` Pre-commit [check](https://github.com/ydb-platform/ydb/actions/runs/15095998511/job/42430751412) **linux-x86_64-release-asan** for ababf834d80925a9cdb9eeb90339840c5e453d31 has started.
:white_circle: `2025-05-18 12:38:39 UTC` Artifacts will be uploaded [here](https://storage.yandexcloud.net/ydb-gh-logs/ydb-platform/ydb/PR-check/15095998511/ya-x86-64-asan/index.html)
:white_circle: `2025-05-18 12:40:56 UTC` ya make is running...
:green_circle: `2025-05-18 12:46:04 UTC` Tests successful.

[Test history](https://nebius.testmo.net/automation/runs/view/162731) | [Ya make output](https://storage.yandexcloud.net/ydb-gh-logs/ydb-platform/ydb/PR-check/15095998511/ya-x86-64-asan/ya_make_output.txt) | [Test bloat](https://storage.yandexcloud.net/ydb-gh-logs/ydb-platform/ydb/PR-check/15095998511/ya-x86-64-asan/try_1/test_bloat/tree_map.html)
| TESTS | PASSED | ERRORS | FAILED | SKIPPED | MUTED<sup>[?](https://github.com/ydb-platform/ydb/tree/main/.github/config/muted_ya.txt "All mute rules are defined here")</sup> |
| ---: | ---: | ---: | ---: | ---: | ---: |
| [42](https://storage.yandexcloud.net/ydb-gh-logs/ydb-platform/ydb/PR-check/15095998511/ya-x86-64-asan/try_1/ya-test.html) | [42](https://storage.yandexcloud.net/ydb-gh-logs/ydb-platform/ydb/PR-check/15095998511/ya-x86-64-asan/try_1/ya-test.html#PASS) | 0 | 0 | 0 | 0 |

:green_circle: `2025-05-18 12:46:10 UTC` Build successful.
:green_circle: `2025-05-18 12:46:23 UTC` ydbd size **3.9 GiB** changed* by **-96 Bytes**, which is <= 0 Bytes vs main: **OK**
|[ydbd size dash](https://datalens.yandex/cu6hzmpaki700)|main: dee22ec17f9818abef2a8bfb2a2ad405c97eabb9 |merge: ababf834d80925a9cdb9eeb90339840c5e453d31 |diff | diff %|
|:--- | ---: | ---: | ---: | ---: |
|ydbd size|**4 141 785 720** Bytes |**4 141 785 624** Bytes|**-96 Bytes**|**-0.000%**|
|ydbd stripped size|**1 437 649 848** Bytes|**1 437 649 784** Bytes|**-64 Bytes**|**-0.000%**|

<sup>*please be aware that the difference is based on comparing your commit and the last completed build from the post-commit, check [comparation](https://github.com/ydb-platform/ydb/compare/dee22ec17f9818abef2a8bfb2a2ad405c97eabb9..ababf834d80925a9cdb9eeb90339840c5e453d31)</sup>
author_association: NONE
user: login: github-actions[bot]
created_at: 2025-05-19T08:21:57Z
body: <!-- status pr=17498, preset=release-asan, run=43356 -->
:white_circle: `2025-05-19 08:21:57 UTC` Pre-commit [check](https://github.com/ydb-platform/ydb/actions/runs/15107953823/job/42460662724) **linux-x86_64-release-asan** for be0962f269d9417a84cd159952811877c3b97860 has started.
:white_circle: `2025-05-19 08:22:08 UTC` Artifacts will be uploaded [here](https://storage.yandexcloud.net/ydb-gh-logs/ydb-platform/ydb/PR-check/15107953823/ya-x86-64-asan/index.html)
:white_circle: `2025-05-19 08:24:31 UTC` ya make is running...
:green_circle: `2025-05-19 08:50:33 UTC` Tests successful.

[Test history](https://nebius.testmo.net/automation/runs/view/163115) | [Ya make output](https://storage.yandexcloud.net/ydb-gh-logs/ydb-platform/ydb/PR-check/15107953823/ya-x86-64-asan/ya_make_output.txt) | [Test bloat](https://storage.yandexcloud.net/ydb-gh-logs/ydb-platform/ydb/PR-check/15107953823/ya-x86-64-asan/try_1/test_bloat/tree_map.html)
| TESTS | PASSED | ERRORS | FAILED | SKIPPED | MUTED<sup>[?](https://github.com/ydb-platform/ydb/tree/main/.github/config/muted_ya.txt "All mute rules are defined here")</sup> |
| ---: | ---: | ---: | ---: | ---: | ---: |
| [42](https://storage.yandexcloud.net/ydb-gh-logs/ydb-platform/ydb/PR-check/15107953823/ya-x86-64-asan/try_1/ya-test.html) | [42](https://storage.yandexcloud.net/ydb-gh-logs/ydb-platform/ydb/PR-check/15107953823/ya-x86-64-asan/try_1/ya-test.html#PASS) | 0 | 0 | 0 | 0 |

:green_circle: `2025-05-19 08:50:42 UTC` Build successful.
:green_circle: `2025-05-19 08:50:58 UTC` ydbd size **3.9 GiB** changed* by **+13.0 KiB**, which is < 100.0 KiB vs main: **OK**
|[ydbd size dash](https://datalens.yandex/cu6hzmpaki700)|main: f714649e2afef5b93270d3081171d1dd8c3b9885 |merge: be0962f269d9417a84cd159952811877c3b97860 |diff | diff %|
|:--- | ---: | ---: | ---: | ---: |
|ydbd size|**4 141 809 224** Bytes |**4 141 822 520** Bytes|**+13.0 KiB**|**+0.000%**|
|ydbd stripped size|**1 437 656 568** Bytes|**1 437 658 392** Bytes|**+1.8 KiB**|**+0.000%**|

<sup>*please be aware that the difference is based on comparing your commit and the last completed build from the post-commit, check [comparation](https://github.com/ydb-platform/ydb/compare/f714649e2afef5b93270d3081171d1dd8c3b9885..be0962f269d9417a84cd159952811877c3b97860)</sup>
author_association: NONE
user: login: github-actions[bot]
created_at: 2025-05-19T08:24:12Z
body: <!-- status pr=17498, preset=relwithdebinfo, run=43356 -->
:white_circle: `2025-05-19 08:24:11 UTC` Pre-commit [check](https://github.com/ydb-platform/ydb/actions/runs/15107953823/job/42460662722) **linux-x86_64-relwithdebinfo** for be0962f269d9417a84cd159952811877c3b97860 has started.
:white_circle: `2025-05-19 08:24:23 UTC` Artifacts will be uploaded [here](https://storage.yandexcloud.net/ydb-gh-logs/ydb-platform/ydb/PR-check/15107953823/ya-x86-64/index.html)
:white_circle: `2025-05-19 08:26:39 UTC` ya make is running...
:green_circle: `2025-05-19 08:52:38 UTC` Tests successful.

[Test history](https://nebius.testmo.net/automation/runs/view/163117) | [Ya make output](https://storage.yandexcloud.net/ydb-gh-logs/ydb-platform/ydb/PR-check/15107953823/ya-x86-64/ya_make_output.txt) | [Test bloat](https://storage.yandexcloud.net/ydb-gh-logs/ydb-platform/ydb/PR-check/15107953823/ya-x86-64/try_1/test_bloat/tree_map.html)
| TESTS | PASSED | ERRORS | FAILED | SKIPPED | MUTED<sup>[?](https://github.com/ydb-platform/ydb/tree/main/.github/config/muted_ya.txt "All mute rules are defined here")</sup> |
| ---: | ---: | ---: | ---: | ---: | ---: |
| [44](https://storage.yandexcloud.net/ydb-gh-logs/ydb-platform/ydb/PR-check/15107953823/ya-x86-64/try_1/ya-test.html) | [44](https://storage.yandexcloud.net/ydb-gh-logs/ydb-platform/ydb/PR-check/15107953823/ya-x86-64/try_1/ya-test.html#PASS) | 0 | 0 | 0 | 0 |

:green_circle: `2025-05-19 08:52:49 UTC` Build successful.
:green_circle: `2025-05-19 08:52:59 UTC` ydbd size **2.2 GiB** changed* by **+13.1 KiB**, which is < 100.0 KiB vs main: **OK**
|[ydbd size dash](https://datalens.yandex/cu6hzmpaki700)|main: f714649e2afef5b93270d3081171d1dd8c3b9885 |merge: be0962f269d9417a84cd159952811877c3b97860 |diff | diff %|
|:--- | ---: | ---: | ---: | ---: |
|ydbd size|**2 354 375 264** Bytes |**2 354 388 688** Bytes|**+13.1 KiB**|**+0.001%**|
|ydbd stripped size|**494 721 160** Bytes|**494 726 088** Bytes|**+4.8 KiB**|**+0.001%**|

<sup>*please be aware that the difference is based on comparing your commit and the last completed build from the post-commit, check [comparation](https://github.com/ydb-platform/ydb/compare/f714649e2afef5b93270d3081171d1dd8c3b9885..be0962f269d9417a84cd159952811877c3b97860)</sup>
author_association: NONE
user: login: github-actions[bot]
created_at: 2025-05-19T09:18:25Z
body: <!-- status pr=17498, preset=relwithdebinfo, run=43369 -->
:white_circle: `2025-05-19 09:18:24 UTC` Pre-commit [check](https://github.com/ydb-platform/ydb/actions/runs/15109085869/job/42464263556) **linux-x86_64-relwithdebinfo** for 758a6998a52d72e0bb744ec0a9238d72bb3f9478 has started.
:white_circle: `2025-05-19 09:18:36 UTC` Artifacts will be uploaded [here](https://storage.yandexcloud.net/ydb-gh-logs/ydb-platform/ydb/PR-check/15109085869/ya-x86-64/index.html)
:white_circle: `2025-05-19 09:20:56 UTC` ya make is running...
:green_circle: `2025-05-19 09:23:08 UTC` Tests successful.

[Test history](https://nebius.testmo.net/automation/runs/view/163162) | [Ya make output](https://storage.yandexcloud.net/ydb-gh-logs/ydb-platform/ydb/PR-check/15109085869/ya-x86-64/ya_make_output.txt) | [Test bloat](https://storage.yandexcloud.net/ydb-gh-logs/ydb-platform/ydb/PR-check/15109085869/ya-x86-64/try_1/test_bloat/tree_map.html)
| TESTS | PASSED | ERRORS | FAILED | SKIPPED | MUTED<sup>[?](https://github.com/ydb-platform/ydb/tree/main/.github/config/muted_ya.txt "All mute rules are defined here")</sup> |
| ---: | ---: | ---: | ---: | ---: | ---: |
| [44](https://storage.yandexcloud.net/ydb-gh-logs/ydb-platform/ydb/PR-check/15109085869/ya-x86-64/try_1/ya-test.html) | [44](https://storage.yandexcloud.net/ydb-gh-logs/ydb-platform/ydb/PR-check/15109085869/ya-x86-64/try_1/ya-test.html#PASS) | 0 | 0 | 0 | 0 |

:green_circle: `2025-05-19 09:23:18 UTC` Build successful.
:green_circle: `2025-05-19 09:23:28 UTC` ydbd size **2.2 GiB** changed* by **-9.7 KiB**, which is <= 0 Bytes vs main: **OK**
|[ydbd size dash](https://datalens.yandex/cu6hzmpaki700)|main: f714649e2afef5b93270d3081171d1dd8c3b9885 |merge: 758a6998a52d72e0bb744ec0a9238d72bb3f9478 |diff | diff %|
|:--- | ---: | ---: | ---: | ---: |
|ydbd size|**2 354 375 264** Bytes |**2 354 365 360** Bytes|**-9.7 KiB**|**-0.000%**|
|ydbd stripped size|**494 721 160** Bytes|**494 718 792** Bytes|**-2.3 KiB**|**-0.000%**|

<sup>*please be aware that the difference is based on comparing your commit and the last completed build from the post-commit, check [comparation](https://github.com/ydb-platform/ydb/compare/f714649e2afef5b93270d3081171d1dd8c3b9885..758a6998a52d72e0bb744ec0a9238d72bb3f9478)</sup>
author_association: NONE
user: login: github-actions[bot]
created_at: 2025-05-19T09:18:32Z
body: <!-- status pr=17498, preset=release-asan, run=43369 -->
:white_circle: `2025-05-19 09:18:31 UTC` Pre-commit [check](https://github.com/ydb-platform/ydb/actions/runs/15109085869/job/42464263540) **linux-x86_64-release-asan** for 758a6998a52d72e0bb744ec0a9238d72bb3f9478 has started.
:white_circle: `2025-05-19 09:18:42 UTC` Artifacts will be uploaded [here](https://storage.yandexcloud.net/ydb-gh-logs/ydb-platform/ydb/PR-check/15109085869/ya-x86-64-asan/index.html)
:white_circle: `2025-05-19 09:20:57 UTC` ya make is running...
:green_circle: `2025-05-19 09:25:31 UTC` Tests successful.

[Test history](https://nebius.testmo.net/automation/runs/view/163163) | [Ya make output](https://storage.yandexcloud.net/ydb-gh-logs/ydb-platform/ydb/PR-check/15109085869/ya-x86-64-asan/ya_make_output.txt) | [Test bloat](https://storage.yandexcloud.net/ydb-gh-logs/ydb-platform/ydb/PR-check/15109085869/ya-x86-64-asan/try_1/test_bloat/tree_map.html)
| TESTS | PASSED | ERRORS | FAILED | SKIPPED | MUTED<sup>[?](https://github.com/ydb-platform/ydb/tree/main/.github/config/muted_ya.txt "All mute rules are defined here")</sup> |
| ---: | ---: | ---: | ---: | ---: | ---: |
| [42](https://storage.yandexcloud.net/ydb-gh-logs/ydb-platform/ydb/PR-check/15109085869/ya-x86-64-asan/try_1/ya-test.html) | [42](https://storage.yandexcloud.net/ydb-gh-logs/ydb-platform/ydb/PR-check/15109085869/ya-x86-64-asan/try_1/ya-test.html#PASS) | 0 | 0 | 0 | 0 |

:green_circle: `2025-05-19 09:25:37 UTC` Build successful.
:green_circle: `2025-05-19 09:25:50 UTC` ydbd size **3.9 GiB** changed* by **-7.3 KiB**, which is <= 0 Bytes vs main: **OK**
|[ydbd size dash](https://datalens.yandex/cu6hzmpaki700)|main: f714649e2afef5b93270d3081171d1dd8c3b9885 |merge: 758a6998a52d72e0bb744ec0a9238d72bb3f9478 |diff | diff %|
|:--- | ---: | ---: | ---: | ---: |
|ydbd size|**4 141 809 224** Bytes |**4 141 801 728** Bytes|**-7.3 KiB**|**-0.000%**|
|ydbd stripped size|**1 437 656 568** Bytes|**1 437 654 936** Bytes|**-1.6 KiB**|**-0.000%**|

<sup>*please be aware that the difference is based on comparing your commit and the last completed build from the post-commit, check [comparation](https://github.com/ydb-platform/ydb/compare/f714649e2afef5b93270d3081171d1dd8c3b9885..758a6998a52d72e0bb744ec0a9238d72bb3f9478)</sup>
author_association: NONE
user: login: github-actions[bot]
created_at: 2025-05-20T15:40:21Z
body: <!-- status pr=17498, preset=release-asan, run=43600 -->
:white_circle: `2025-05-20 15:40:21 UTC` Pre-commit [check](https://github.com/ydb-platform/ydb/actions/runs/15141878059/job/42567839918) **linux-x86_64-release-asan** for 5fd5a5c2497a653bf6758fb2fc9f4d7f20455f70 has started.
:white_circle: `2025-05-20 15:40:32 UTC` Artifacts will be uploaded [here](https://storage.yandexcloud.net/ydb-gh-logs/ydb-platform/ydb/PR-check/15141878059/ya-x86-64-asan/index.html)
:white_circle: `2025-05-20 15:42:47 UTC` ya make is running...
:green_circle: `2025-05-20 15:47:45 UTC` Tests successful.

[Test history](https://nebius.testmo.net/automation/runs/view/164282) | [Ya make output](https://storage.yandexcloud.net/ydb-gh-logs/ydb-platform/ydb/PR-check/15141878059/ya-x86-64-asan/ya_make_output.txt) | [Test bloat](https://storage.yandexcloud.net/ydb-gh-logs/ydb-platform/ydb/PR-check/15141878059/ya-x86-64-asan/try_1/test_bloat/tree_map.html)
| TESTS | PASSED | ERRORS | FAILED | SKIPPED | MUTED<sup>[?](https://github.com/ydb-platform/ydb/tree/main/.github/config/muted_ya.txt "All mute rules are defined here")</sup> |
| ---: | ---: | ---: | ---: | ---: | ---: |
| [42](https://storage.yandexcloud.net/ydb-gh-logs/ydb-platform/ydb/PR-check/15141878059/ya-x86-64-asan/try_1/ya-test.html) | [42](https://storage.yandexcloud.net/ydb-gh-logs/ydb-platform/ydb/PR-check/15141878059/ya-x86-64-asan/try_1/ya-test.html#PASS) | 0 | 0 | 0 | 0 |

:green_circle: `2025-05-20 15:47:55 UTC` Build successful.
:yellow_circle: `2025-05-20 15:48:09 UTC` ydbd size **3.9 GiB** changed* by **+704.4 KiB**, which is >= 100.0 KiB vs main: **Warning**
|[ydbd size dash](https://datalens.yandex/cu6hzmpaki700)|main: cdcb2e62c1d7ad53c2c218d85fe086da57ec3fc8 |merge: 5fd5a5c2497a653bf6758fb2fc9f4d7f20455f70 |diff | diff %|
|:--- | ---: | ---: | ---: | ---: |
|ydbd size|**4 142 985 560** Bytes |**4 143 706 824** Bytes|**+704.4 KiB**|**+0.017%**|
|ydbd stripped size|**1 437 904 024** Bytes|**1 438 137 400** Bytes|**+227.9 KiB**|**+0.016%**|

<sup>*please be aware that the difference is based on comparing your commit and the last completed build from the post-commit, check [comparation](https://github.com/ydb-platform/ydb/compare/cdcb2e62c1d7ad53c2c218d85fe086da57ec3fc8..5fd5a5c2497a653bf6758fb2fc9f4d7f20455f70)</sup>
author_association: NONE
user: login: github-actions[bot]
created_at: 2025-05-20T15:40:22Z
body: <!-- status pr=17498, preset=relwithdebinfo, run=43600 -->
:white_circle: `2025-05-20 15:40:22 UTC` Pre-commit [check](https://github.com/ydb-platform/ydb/actions/runs/15141878059/job/42567839932) **linux-x86_64-relwithdebinfo** for 5fd5a5c2497a653bf6758fb2fc9f4d7f20455f70 has started.
:white_circle: `2025-05-20 15:40:33 UTC` Artifacts will be uploaded [here](https://storage.yandexcloud.net/ydb-gh-logs/ydb-platform/ydb/PR-check/15141878059/ya-x86-64/index.html)
:white_circle: `2025-05-20 15:42:50 UTC` ya make is running...
:green_circle: `2025-05-20 15:44:53 UTC` Tests successful.

[Test history](https://nebius.testmo.net/automation/runs/view/164283) | [Ya make output](https://storage.yandexcloud.net/ydb-gh-logs/ydb-platform/ydb/PR-check/15141878059/ya-x86-64/ya_make_output.txt) | [Test bloat](https://storage.yandexcloud.net/ydb-gh-logs/ydb-platform/ydb/PR-check/15141878059/ya-x86-64/try_1/test_bloat/tree_map.html)
| TESTS | PASSED | ERRORS | FAILED | SKIPPED | MUTED<sup>[?](https://github.com/ydb-platform/ydb/tree/main/.github/config/muted_ya.txt "All mute rules are defined here")</sup> |
| ---: | ---: | ---: | ---: | ---: | ---: |
| [44](https://storage.yandexcloud.net/ydb-gh-logs/ydb-platform/ydb/PR-check/15141878059/ya-x86-64/try_1/ya-test.html) | [44](https://storage.yandexcloud.net/ydb-gh-logs/ydb-platform/ydb/PR-check/15141878059/ya-x86-64/try_1/ya-test.html#PASS) | 0 | 0 | 0 | 0 |

:green_circle: `2025-05-20 15:45:00 UTC` Build successful.
:yellow_circle: `2025-05-20 15:45:10 UTC` ydbd size **2.2 GiB** changed* by **+397.7 KiB**, which is >= 100.0 KiB vs main: **Warning**
|[ydbd size dash](https://datalens.yandex/cu6hzmpaki700)|main: 02d1aa7fdd7470b2662838cb871032857c556ace |merge: 5fd5a5c2497a653bf6758fb2fc9f4d7f20455f70 |diff | diff %|
|:--- | ---: | ---: | ---: | ---: |
|ydbd size|**2 355 134 000** Bytes |**2 355 541 216** Bytes|**+397.7 KiB**|**+0.017%**|
|ydbd stripped size|**494 790 600** Bytes|**494 870 856** Bytes|**+78.4 KiB**|**+0.016%**|

<sup>*please be aware that the difference is based on comparing your commit and the last completed build from the post-commit, check [comparation](https://github.com/ydb-platform/ydb/compare/02d1aa7fdd7470b2662838cb871032857c556ace..5fd5a5c2497a653bf6758fb2fc9f4d7f20455f70)</sup>
author_association: NONE