tests of ttl utility functions on SS (ydb-platform#12092)

 Conflicts:
	ydb/core/tx/schemeshard/common/validation.cpp

ydb/core/tx/columnshard/blobs_action/transaction/tx_blobs_written.cpp

@@ -119,6 +119,7 @@ TTxBlobsWritingFinished::TTxBlobsWritingFinished(TColumnShard* self, const NKiki
     : TBase(self, "TTxBlobsWritingFinished")
     , Packs(std::move(packs))
     , WritingActions(writingActions) {
+    Y_UNUSED(writeStatus);
     for (auto&& i : noDataWrites) {
         auto ev = NEvents::TDataEvents::TEvWriteResult::BuildCompleted(Self->TabletID());
         auto op = Self->GetOperationsManager().GetOperationVerified((TOperationWriteId)i.GetWriteMeta().GetWriteId());
@@ -127,6 +128,7 @@ TTxBlobsWritingFinished::TTxBlobsWritingFinished(TColumnShard* self, const NKiki
 }
 
 bool TTxBlobsWritingFailed::DoExecute(TTransactionContext& txc, const TActorContext& ctx) {
+    Y_UNUSED(ctx);
     for (auto&& pack : Packs) {
         const auto& writeMeta = pack.GetWriteMeta();
         AFL_VERIFY(!writeMeta.HasLongTxId());

ydb/core/tx/columnshard/test_helper/columnshard_ut_common.cpp

@@ -208,6 +208,7 @@ void ScanIndexStats(TTestBasicRuntime& runtime, TActorId& sender, const std::vec
 }
 
 void ProposeCommit(TTestBasicRuntime& runtime, TActorId& sender, ui64 shardId, ui64 txId, const std::vector<ui64>& writeIds, const ui64 lockId) {
+    Y_UNUSED(writeIds);
     auto write = std::make_unique<NEvents::TDataEvents::TEvWrite>(txId, NKikimrDataEvents::TEvWrite::MODE_PREPARE);
     auto* lock = write->Record.MutableLocks()->AddLocks();
     lock->SetLockId(lockId);

ydb/core/tx/schemeshard/common/validation.cpp

@@ -1,5 +1,12 @@
 #include "validation.h"
 
+#include <util/string/builder.h>
+#include <ydb/library/yql/parser/pg_wrapper/interface/type_desc.h>
+
+extern "C" {
+#include <ydb/library/yql/parser/pg_wrapper/postgresql/src/include/catalog/pg_type_d.h>
+}
+
 namespace NKikimr::NSchemeShard::NValidation {
 
 bool TTTLValidator::ValidateUnit(const NScheme::TTypeId columnType, NKikimrSchemeOp::TTTLSettings::EUnit unit, TString& errStr) {
@@ -32,10 +39,30 @@ bool TTTLValidator::ValidateUnit(const NScheme::TTypeId columnType, NKikimrSchem
 
 bool TTTLValidator::ValidateTiers(const NKikimrSchemeOp::TTTLSettings::TEnabled ttlSettings, TString& errStr) {
     for (ui64 i = 0; i < ttlSettings.TiersSize(); ++i) {
-        if (ttlSettings.GetTiers(i).HasDelete() && i + 1 != ttlSettings.TiersSize()) {
-            errStr = "Only the last tier in TTL settings can have Delete action";
+        const auto& tier = ttlSettings.GetTiers(i);
+        if (!tier.HasApplyAfterSeconds()) {
+            errStr = TStringBuilder() << "Tier " << i << ": missing ApplyAfterSeconds";
             return false;
         }
+        if (i != 0 && tier.GetApplyAfterSeconds() <= ttlSettings.GetTiers(i - 1).GetApplyAfterSeconds()) {
+            errStr = TStringBuilder() << "Tiers in the sequence must have increasing ApplyAfterSeconds: "
+                                      << ttlSettings.GetTiers(i - 1).GetApplyAfterSeconds() << " (tier " << i - 1
+                                      << ") >= " << tier.GetApplyAfterSeconds() << " (tier " << i << ")";
+            return false;
+        }
+        switch (tier.GetActionCase()) {
+            case NKikimrSchemeOp::TTTLSettings_TTier::kDelete:
+                if (i + 1 != ttlSettings.TiersSize()) {
+                    errStr = TStringBuilder() << "Tier " << i << ": only the last tier in TTL settings can have Delete action";
+                    return false;
+                }
+                break;
+            case NKikimrSchemeOp::TTTLSettings_TTier::kEvictToExternalStorage:
+                break;
+            case NKikimrSchemeOp::TTTLSettings_TTier::ACTION_NOT_SET:
+                errStr = TStringBuilder() << "Tier " << i << ": missing Action";
+                return false;
+        }
     }
     return true;
 }

ydb/core/tx/schemeshard/ut_ttl/ut_ttl.cpp

@@ -1195,7 +1195,7 @@ Y_UNIT_TEST_SUITE(TSchemeShardTTLTests) {
                 }
               }
             }
-        )", {{NKikimrScheme::StatusInvalidParameter, "Only the last tier in TTL settings can have Delete action"}});
+        )", {{NKikimrScheme::StatusInvalidParameter, "Tier 0: only the last tier in TTL settings can have Delete action"}});
 
         TestAlterTable(runtime, ++txId, "/MyRoot", R"(
             Name: "TTLEnabledTable"

ydb/core/tx/schemeshard/ut_ttl/ut_ttl_utility.cpp

@@ -0,0 +1,100 @@
+#include <ydb/core/tx/schemeshard/common/validation.h>
+#include <ydb/core/tx/schemeshard/schemeshard_info_types.h>
+
+#include <library/cpp/testing/unittest/registar.h>
+
+using namespace NKikimr;
+using namespace NSchemeShard;
+
+Y_UNIT_TEST_SUITE(TSchemeShardTTLUtility) {
+    void TestValidateTiers(const std::vector<NKikimrSchemeOp::TTTLSettings::TTier>& tiers, const TConclusionStatus& expectedResult) {
+        NKikimrSchemeOp::TTTLSettings::TEnabled input;
+        for (const auto& tier : tiers) {
+            *input.AddTiers() = tier;
+        }
+
+        TString error;
+        UNIT_ASSERT_VALUES_EQUAL(NValidation::TTTLValidator::ValidateTiers(input, error), expectedResult.IsSuccess());
+        if (expectedResult.IsFail()) {
+            UNIT_ASSERT_STRING_CONTAINS(error, expectedResult.GetErrorMessage());
+        }
+    }
+
+    Y_UNIT_TEST(ValidateTiers) {
+        NKikimrSchemeOp::TTTLSettings::TTier tierNoAction;
+        tierNoAction.SetApplyAfterSeconds(60);
+        NKikimrSchemeOp::TTTLSettings::TTier tierNoDuration;
+        tierNoDuration.MutableDelete();
+        auto makeDeleteTier = [](const ui32 seconds) {
+            NKikimrSchemeOp::TTTLSettings::TTier tier;
+            tier.MutableDelete();
+            tier.SetApplyAfterSeconds(seconds);
+            return tier;
+        };
+        auto makeEvictTier = [](const ui32 seconds) {
+            NKikimrSchemeOp::TTTLSettings::TTier tier;
+            tier.MutableEvictToExternalStorage()->SetStorageName("/Root/abc");
+            tier.SetApplyAfterSeconds(seconds);
+            return tier;
+        };
+
+        TestValidateTiers({ tierNoAction }, TConclusionStatus::Fail("Tier 0: missing Action"));
+        TestValidateTiers({ tierNoDuration }, TConclusionStatus::Fail("Tier 0: missing ApplyAfterSeconds"));
+        TestValidateTiers({ makeDeleteTier(1) }, TConclusionStatus::Success());
+        TestValidateTiers({ makeEvictTier(1) }, TConclusionStatus::Success());
+        TestValidateTiers({ makeEvictTier(1), makeDeleteTier(2) }, TConclusionStatus::Success());
+        TestValidateTiers({ makeEvictTier(1), makeEvictTier(2), makeDeleteTier(3) }, TConclusionStatus::Success());
+        TestValidateTiers({ makeEvictTier(1), makeEvictTier(2) }, TConclusionStatus::Success());
+        TestValidateTiers({ makeEvictTier(2), makeEvictTier(1) }, TConclusionStatus::Fail("Tiers in the sequence must have increasing ApplyAfterSeconds: 2 (tier 0) >= 1 (tier 1)"));
+        TestValidateTiers({ makeDeleteTier(1), makeEvictTier(2) }, TConclusionStatus::Fail("Tier 0: only the last tier in TTL settings can have Delete action"));
+        TestValidateTiers({ makeDeleteTier(1), makeDeleteTier(2) }, TConclusionStatus::Fail("Tier 0: only the last tier in TTL settings can have Delete action"));
+    }
+
+    void ValidateGetExpireAfter(const NKikimrSchemeOp::TTTLSettings::TEnabled& ttlSettings, const bool allowNonDeleteTiers, const TConclusion<TDuration>& expectedResult) {
+        auto result = GetExpireAfter(ttlSettings, allowNonDeleteTiers);
+        UNIT_ASSERT_VALUES_EQUAL(result.IsSuccess(), expectedResult.IsSuccess());
+        if (expectedResult.IsFail()) {
+            UNIT_ASSERT_STRING_CONTAINS(result.GetErrorMessage(), expectedResult.GetErrorMessage());
+        }
+    }
+
+    Y_UNIT_TEST(GetExpireAfter) {
+        NKikimrSchemeOp::TTTLSettings::TTier evictTier;
+        evictTier.MutableEvictToExternalStorage()->SetStorageName("/Root/abc");
+        evictTier.SetApplyAfterSeconds(1800);
+        NKikimrSchemeOp::TTTLSettings::TTier deleteTier;
+        deleteTier.MutableDelete();
+        deleteTier.SetApplyAfterSeconds(3600);
+
+        {
+            NKikimrSchemeOp::TTTLSettings::TEnabled input;
+            ValidateGetExpireAfter(input, true, TDuration::Zero());
+            ValidateGetExpireAfter(input, false, TDuration::Zero());
+        }
+        {
+            NKikimrSchemeOp::TTTLSettings::TEnabled input;
+            input.SetExpireAfterSeconds(60);
+            ValidateGetExpireAfter(input, true, TDuration::Seconds(60));
+            ValidateGetExpireAfter(input, false, TDuration::Seconds(60));
+        }
+        {
+            NKikimrSchemeOp::TTTLSettings::TEnabled input;
+            *input.AddTiers() = deleteTier;
+            ValidateGetExpireAfter(input, true, TDuration::Seconds(3600));
+            ValidateGetExpireAfter(input, false, TDuration::Seconds(3600));
+        }
+        {
+            NKikimrSchemeOp::TTTLSettings::TEnabled input;
+            *input.AddTiers() = evictTier;
+            *input.AddTiers() = deleteTier;
+            ValidateGetExpireAfter(input, true, TDuration::Seconds(3600));
+            ValidateGetExpireAfter(input, false, TConclusionStatus::Fail("Only DELETE via TTL is allowed for row-oriented tables"));
+        }
+        {
+            NKikimrSchemeOp::TTTLSettings::TEnabled input;
+            *input.AddTiers() = evictTier;
+            ValidateGetExpireAfter(input, true, TConclusionStatus::Fail("TTL settings does not contain DELETE action"));
+            ValidateGetExpireAfter(input, false, TConclusionStatus::Fail("Only DELETE via TTL is allowed for row-oriented tables"));
+        }
+    }
+}

ydb/core/tx/schemeshard/ut_ttl/ya.make

@@ -21,6 +21,7 @@ PEERDIR(
 
 SRCS(
     ut_ttl.cpp
+    ut_ttl_utility.cpp
 )
 
 YQL_LAST_ABI_VERSION()