nit

ydb/tests/olap/scenario/helpers/data_generators.py

@@ -42,14 +42,30 @@ def next_row(self) -> None:
         pass
 
 
-class ColumnValueGeneratorNull(IColumnValueGenerator):
-    """NULL column value generator.
+class ColumnValueGeneratorConst(IColumnValueGenerator):
+    """Const column value generator.
 
-    Allways generate NULL value."""
+    Allways generate specified value."""
+
+    def __init__(self, value: Any) -> None:
+        """Constructor.
+
+         Args:
+            value: Value to generate.
+        Example:
+            DataGeneratorPerColumn(
+                self.schema2, 10,
+                ColumnValueGeneratorDefault(init_value=10))
+                    .with_column('not_level', ColumnValueGeneratorConst(42)
+            )
+        """
+
+        super().__init__()
+        self._value = value
 
     @override
-    def generate_value(column: ScenarioTestHelper.Column) -> Any:
-        return None
+    def generate_value(self, column: ScenarioTestHelper.Column) -> Any:
+        return self._value
 
 
 class ColumnValueGeneratorRandom(IColumnValueGenerator):

ydb/tests/olap/scenario/helpers/table_helper.py

@@ -364,7 +364,7 @@ def reset_tiering(self) -> AlterTableLikeObject:
         return self(ResetSetting('TIERING'))
 
     def set_ttl(self, interval: str, column: str) -> AlterTableLikeObject:
-        """Set row TTL.
+        """Set TTL for rows.
 
         The method is similar to calling {AlterTableLikeObject.action} with a {SetSetting} instance.
 

ydb/tests/olap/scenario/helpers/tiering_helper.py

@@ -1,12 +1,11 @@
-# TODO: pre-review refactor
 from __future__ import annotations
 from ydb.tests.olap.scenario.helpers.scenario_tests_helper import (
     ScenarioTestHelper,
     TestContext,
 )
-from abc import abstractmethod, ABC
+from abc import abstractmethod
 
-from typing import override, Dict, Optional
+from typing import override, Dict
 from dataclasses import dataclass
 import json
 
@@ -55,7 +54,7 @@ def with_rule(self, rule: TieringRule):
         return self
 
     def to_json(self) -> str:
-        return json.dumps({"rules": list(map(lambda x: x.to_dict(), self.rules))})
+        return json.dumps({'rules': list(map(lambda x: x.to_dict(), self.rules))})
 
 
 @dataclass
@@ -81,7 +80,7 @@ def __init__(self, name: str, default_column: str, config: TieringPolicy) -> Non
 
         Args:
             name: Name (relative path) of the altered object.
-            default_column: Default column.
+            default_column: Default column used for tiering.
             config: Tiering rules to apply."""
 
         super().__init__(name)
@@ -98,25 +97,24 @@ def title(self):
 
     @override
     def to_yql(self, ctx: TestContext) -> str:
-        return f'ALTER OBJECT `{self._name}` (TYPE TIERING_RULE) SET (defaultColumn = {self._default_column}, description = `{self._config.to_json()}`)'
-
-    @override
-    def _type(self) -> str:
-        return 'tiering_rule'
+        return f'ALTER OBJECT `{self._name}` (TYPE TIERING_RULE)' \
+               f' SET (defaultColumn = {self._default_column}, description = `{self._config.to_json()}`)'
 
 
 class CreateTieringRule(AlterTieringRule):
     """Create a tiering rule.
 
      See {ScenarioTestHelper.IYqlble}.
     """
+
     @override
     def title(self):
         return 'Create tiering rule'
 
     @override
     def to_yql(self, ctx: TestContext) -> str:
-        return f'CREATE OBJECT `{self._name}` (TYPE TIERING_RULE) WITH (defaultColumn = {self._default_column}, description = `{self._config.to_json()}`)'
+        return f'CREATE OBJECT `{self._name}` (TYPE TIERING_RULE)' \
+               f' WITH (defaultColumn = {self._default_column}, description = `{self._config.to_json()}`)'
 
 
 class AlterTier(ScenarioTestHelper.IYqlble):
@@ -129,14 +127,15 @@ def __init__(self, name: str, config: TierConfig) -> None:
         """Constructor.
 
         Args:
-            name: Name (relative path) of the altered object."""
+            name: Name (relative path) of the altered object.
+            config: Tier configuration."""
 
         super().__init__(name)
         self._config: TierConfig = config
 
     @override
     def params(self) -> Dict[str, str]:
-        return {self._type(): self._name, 'config': self._config.to_proto_str()}
+        return {'tier': self._name, 'config': self._config.to_proto_str()}
 
     @override
     def title(self):
@@ -146,10 +145,6 @@ def title(self):
     def to_yql(self, ctx: TestContext) -> str:
         return f'ALTER OBJECT `{self._name}` (TYPE TIER) SET (tierConfig = `{self._config.to_proto_str()}`)'
 
-    @override
-    def _type(self) -> str:
-        'tier'
-
 
 class CreateTier(AlterTier):
     """Create a tier.
@@ -172,26 +167,29 @@ class DropObjectBase(ScenarioTestHelper.IYqlble):
      See {ScenarioTestHelper.IYqlble}.
     """
 
-    def __init__(self, name: str, object_type: str) -> None:
+    def __init__(self, name: str) -> None:
         """Constructor.
 
         Args:
             name: Name (relative path) of the altered object."""
 
         super().__init__(name)
-        self._object_type = object_type
 
     @override
     def params(self) -> Dict[str, str]:
-        return {'object_type': self._object_type}
+        return {'object_type': self._object_type()}
 
     @override
     def title(self):
-        return f'Drop {self._object_type.lower()}'
+        return f'Drop {self._object_type().lower()}'
 
     @override
     def to_yql(self, ctx: TestContext) -> str:
-        return f'DROP OBJECT `{self._name}` (TYPE {self._object_type})'
+        return f'DROP OBJECT `{self._name}` (TYPE {self._object_type()})'
+
+    @abstractmethod
+    def _object_type(self) -> str:
+        pass
 
 
 class DropTier(DropObjectBase):
@@ -200,13 +198,9 @@ class DropTier(DropObjectBase):
      See {ScenarioTestHelper.IYqlble}.
     """
 
-    def __init__(self, name: str) -> None:
-        """Constructor.
-
-        Args:
-            name: Name (relative path) of the altered object."""
-
-        super().__init__(name, 'TIER')
+    @override
+    def _object_type(self):
+        return 'TIER'
 
 
 class DropTieringRule(DropObjectBase):
@@ -215,10 +209,6 @@ class DropTieringRule(DropObjectBase):
      See {ScenarioTestHelper.IYqlble}.
     """
 
-    def __init__(self, name: str) -> None:
-        """Constructor.
-
-        Args:
-            name: Name (relative path) of the altered object."""
-
-        super().__init__(name, 'TIERING_RULE')
+    @override
+    def _object_type(self):
+        return 'TIERING_RULE'

ydb/tests/olap/scenario/test_alter_tiering.py

@@ -16,10 +16,11 @@
     TieringPolicy,
     TieringRule,
     DropTier,
-    DropTieringRule
+    DropTieringRule,
 )
 import helpers.data_generators as dg
 from helpers.table_helper import AlterTable
+
 from ydb import PrimitiveType
 from ydb import StatusCode
 import datetime
@@ -32,9 +33,9 @@ class TestAlterTiering(BaseTestSet):
     schema1 = (
         ScenarioTestHelper.Schema()
         .with_column(name='timestamp', type=PrimitiveType.Timestamp, not_null=True)
-        .with_column(name='writer', type=PrimitiveType.Uint32)
-        .with_column(name='value', type=PrimitiveType.Uint64)
-        .with_key_columns('timestamp')
+        .with_column(name='writer', type=PrimitiveType.Uint32, not_null=True)
+        .with_column(name='value', type=PrimitiveType.Uint64, not_null=True)
+        .with_key_columns('timestamp', 'writer', 'value')
     )
 
     class TestThread(threading.Thread):
@@ -65,9 +66,10 @@ def _upsert(self, ctx: TestContext, table: str, writer_id: int, duration: dateti
                 table,
                 dg.DataGeneratorPerColumn(self.schema1, 100)
                     .with_column('timestamp', dg.ColumnValueGeneratorRandom(null_probability=0))
-                    .with_column('writer', dg.DataGeneratorConst(writer_id))
+                    .with_column('writer', dg.ColumnValueGeneratorConst(writer_id))
                     .with_column('value', dg.ColumnValueGeneratorSequential(next_value))
             )
+            next_value += 100
         result = sth.execute_scan_query(f'SELECT COUNT(*) FROM `{sth.get_full_path(table)}` WHERE writer == {writer_id}')
         assert result.result_set.rows[0][0] == next_value