(refactoring) Unified style

1 files changed, 359 insertions, 375 deletions

diff --git a/ydb/core/tx/schemeshard/schemeshard_schema.h b/ydb/core/tx/schemeshard/schemeshard_schema.h
index 1353c51bdf0..d74cdb771c6 100644
--- a/ydb/core/tx/schemeshard/schemeshard_schema.h
+++ b/ydb/core/tx/schemeshard/schemeshard_schema.h
@@ -1,16 +1,13 @@
 #pragma once
 
-#include <ydb/core/tx/schemeshard/schemeshard_types.h>
-
-#include <ydb/core/tablet_flat/flat_cxx_database.h>
-
-#include <ydb/core/protos/tx.pb.h>
-#include <ydb/core/protos/tx_datashard.pb.h>
+#include "schemeshard_types.h"
 
 #include <ydb/core/base/pathid.h>
+#include <ydb/core/protos/tx_datashard.pb.h>
+#include <ydb/core/protos/tx.pb.h>
+#include <ydb/core/tablet_flat/flat_cxx_database.h>
 
-namespace NKikimr {
-namespace NSchemeShard {
+namespace NKikimr::NSchemeShard {
 
 struct Schema : NIceDb::Schema {
     struct Paths : Table<1> {
@@ -29,7 +26,7 @@ struct Schema : NIceDb::Schema {
         struct DirAlterVersion :       Column<13, NScheme::NTypeIds::Uint64> {};
         struct UserAttrsAlterVersion : Column<14, NScheme::NTypeIds::Uint64> {};
         struct ACLVersion :            Column<15, NScheme::NTypeIds::Uint64> {};
-        struct ParentOwnerId :         Column<16, NScheme::NTypeIds::Uint64> { using Type = TOwnerId; static constexpr Type Default = InvalidOwnerId;};
+        struct ParentOwnerId :         Column<16, NScheme::NTypeIds::Uint64> { using Type = TOwnerId; static constexpr Type Default = InvalidOwnerId; };
 
         using TKey = TableKey<Id>;
         using TColumns = TableColumns<Id, ParentId, Name, CreateFinished, PathType, StepCreated, CreateTxId,
@@ -37,10 +34,10 @@ struct Schema : NIceDb::Schema {
     };
 
     struct MigratedPaths : Table<50> {
-        struct OwnerPathId :               Column<1, NScheme::NTypeIds::Uint64> { using Type = TOwnerId;};
-        struct LocalPathId :               Column<2, NScheme::NTypeIds::Uint64> { using Type = TLocalPathId;};
-        struct ParentOwnerId :         Column<3, NScheme::NTypeIds::Uint64> { using Type = TOwnerId;};
-        struct ParentLocalId :         Column<4, NScheme::NTypeIds::Uint64> { using Type = TLocalPathId;};
+        struct OwnerPathId :           Column<1, NScheme::NTypeIds::Uint64> { using Type = TOwnerId; };
+        struct LocalPathId :           Column<2, NScheme::NTypeIds::Uint64> { using Type = TLocalPathId; };
+        struct ParentOwnerId :         Column<3, NScheme::NTypeIds::Uint64> { using Type = TOwnerId; };
+        struct ParentLocalId :         Column<4, NScheme::NTypeIds::Uint64> { using Type = TLocalPathId; };
         struct Name :                  Column<5, NScheme::NTypeIds::Utf8> {};
         struct PathType :              Column<6, NScheme::NTypeIds::Uint32> {};
         struct StepCreated :           Column<7, NScheme::NTypeIds::Uint64> { using Type = TStepId; };
@@ -56,7 +53,7 @@ struct Schema : NIceDb::Schema {
 
         using TKey = TableKey<OwnerPathId, LocalPathId>;
         using TColumns = TableColumns<OwnerPathId, LocalPathId, ParentOwnerId, ParentLocalId, Name, PathType, StepCreated, CreateTxId,
-                                      StepDropped, DropTxId, Owner, ACL, LastTxId, DirAlterVersion, UserAttrsAlterVersion, ACLVersion>;
+            StepDropped, DropTxId, Owner, ACL, LastTxId, DirAlterVersion, UserAttrsAlterVersion, ACLVersion>;
     };
 
     struct TxInFlight : Table<2> { // not in use
@@ -67,8 +64,8 @@ struct Schema : NIceDb::Schema {
         struct MinStep :        Column<8, NScheme::NTypeIds::Uint64> { using Type = TStepId; };
         struct ExtraBytes :     Column<10, NScheme::NTypeIds::String> {};
         struct StartTime :      Column<11, NScheme::NTypeIds::Uint64> {};
-        struct DataTotalSize:   Column<12, NScheme::NTypeIds::Uint64> {};
-        struct PlanStep:        Column<13, NScheme::NTypeIds::Uint64> {};
+        struct DataTotalSize :  Column<12, NScheme::NTypeIds::Uint64> {};
+        struct PlanStep :       Column<13, NScheme::NTypeIds::Uint64> {};
 
         using TKey = TableKey<TxId>;
         using TColumns = TableColumns<
@@ -80,7 +77,8 @@ struct Schema : NIceDb::Schema {
             ExtraBytes,
             StartTime,
             DataTotalSize,
-            PlanStep>;
+            PlanStep
+        >;
     };
 
     struct TxDependencies : Table<3> {
@@ -110,11 +108,11 @@ struct Schema : NIceDb::Schema {
 
     /// @note (Tables|Columns).TabId = Paths.Id = Shards.PathId (correct name - PathId)
     struct Tables : Table<5> {
-        struct TabId :          Column<1, NScheme::NTypeIds::Uint64> {};
-        struct NextColId :      Column<2, NScheme::NTypeIds::Uint32> {};
+        struct TabId : Column<1, NScheme::NTypeIds::Uint64> {};
+        struct NextColId : Column<2, NScheme::NTypeIds::Uint32> {};
         struct PartitionConfig : Column<3, NScheme::NTypeIds::Utf8> {}; // TPartitionConfig, String?
-        struct AlterVersion :   Column<4, NScheme::NTypeIds::Uint64> {};
-        struct AlterTable :     Column<5, NScheme::NTypeIds::Utf8> {};   // TTableDescription
+        struct AlterVersion : Column<4, NScheme::NTypeIds::Uint64> {};
+        struct AlterTable : Column<5, NScheme::NTypeIds::Utf8> {};   // TTableDescription
         struct AlterTableFull : Column<6, NScheme::NTypeIds::String> {};   // TTableDescription
         struct PartitioningVersion : Column<7, NScheme::NTypeIds::Uint64> {};
         struct TTLSettings : Column<8, NScheme::NTypeIds::String> {};
@@ -135,8 +133,8 @@ struct Schema : NIceDb::Schema {
     };
 
     struct MigratedTables : Table<54> {
-        struct OwnerPathId :         Column<1, NScheme::NTypeIds::Uint64> { using Type = TOwnerId;};
-        struct LocalPathId :         Column<2, NScheme::NTypeIds::Uint64> { using Type = TLocalPathId;};
+        struct OwnerPathId :         Column<1, NScheme::NTypeIds::Uint64> { using Type = TOwnerId; };
+        struct LocalPathId :         Column<2, NScheme::NTypeIds::Uint64> { using Type = TLocalPathId; };
 
         struct NextColId :           Column<3, NScheme::NTypeIds::Uint32> {};
         struct PartitionConfig :     Column<4, NScheme::NTypeIds::Utf8> {}; // TPartitionConfig, String?
@@ -174,17 +172,16 @@ struct Schema : NIceDb::Schema {
         struct Family :         Column<8, NScheme::NTypeIds::Uint32> {};
         struct DefaultKind :    Column<9, NScheme::NTypeIds::Uint32> { using Type = ETableColumnDefaultKind; static constexpr Type Default = Type::None; };
         struct DefaultValue :   Column<10, NScheme::NTypeIds::String> {};
-        struct NotNull:         Column<11, NScheme::NTypeIds::Bool> {};
+        struct NotNull :        Column<11, NScheme::NTypeIds::Bool> {};
 
         using TKey = TableKey<TabId, ColId>;
-        using TColumns = TableColumns<TabId,
-                                      ColId, ColName, ColType, ColKeyOrder, CreateVersion, DeleteVersion,
-                                      Family, DefaultKind, DefaultValue, NotNull, ColTypeData>;
+        using TColumns = TableColumns<TabId, ColId, ColName, ColType, ColKeyOrder,
+            CreateVersion, DeleteVersion, Family, DefaultKind, DefaultValue, NotNull, ColTypeData>;
     };
 
     struct MigratedColumns : Table<55> {
-        struct OwnerPathId :    Column<1, NScheme::NTypeIds::Uint64> { using Type = TOwnerId;};
-        struct LocalPathId :    Column<2, NScheme::NTypeIds::Uint64> { using Type = TLocalPathId;};
+        struct OwnerPathId :    Column<1, NScheme::NTypeIds::Uint64> { using Type = TOwnerId; };
+        struct LocalPathId :    Column<2, NScheme::NTypeIds::Uint64> { using Type = TLocalPathId; };
         struct ColId :          Column<3, NScheme::NTypeIds::Uint32> {};
 
         struct ColName :        Column<4, NScheme::NTypeIds::Utf8> {};
@@ -196,12 +193,11 @@ struct Schema : NIceDb::Schema {
         struct Family :         Column<9, NScheme::NTypeIds::Uint32> {};
         struct DefaultKind :    Column<10, NScheme::NTypeIds::Uint32> { using Type = ETableColumnDefaultKind; static constexpr Type Default = Type::None; };
         struct DefaultValue :   Column<11, NScheme::NTypeIds::String> {};
-        struct NotNull:         Column<12, NScheme::NTypeIds::Bool> {};
+        struct NotNull :        Column<12, NScheme::NTypeIds::Bool> {};
 
         using TKey = TableKey<OwnerPathId, LocalPathId, ColId>;
-        using TColumns = TableColumns<OwnerPathId, LocalPathId, ColId,
-                                      ColName, ColType, ColKeyOrder, CreateVersion, DeleteVersion,
-                                      Family, DefaultKind, DefaultValue, NotNull, ColTypeData>;
+        using TColumns = TableColumns<OwnerPathId, LocalPathId, ColId, ColName, ColType, ColKeyOrder,
+            CreateVersion, DeleteVersion, Family, DefaultKind, DefaultValue, NotNull, ColTypeData>;
     };
 
     struct ColumnAlters : Table<13> {
@@ -216,16 +212,16 @@ struct Schema : NIceDb::Schema {
         struct Family :         Column<8, NScheme::NTypeIds::Uint32> {};
         struct DefaultKind :    Column<9, NScheme::NTypeIds::Uint32> { using Type = ETableColumnDefaultKind; static constexpr Type Default = Type::None; };
         struct DefaultValue :   Column<10, NScheme::NTypeIds::String> {};
-        struct NotNull:         Column<11, NScheme::NTypeIds::Bool> {};
+        struct NotNull :        Column<11, NScheme::NTypeIds::Bool> {};
 
         using TKey = TableKey<TabId, ColId>;
-        using TColumns = TableColumns<TabId, ColId, ColName, ColType, ColKeyOrder, CreateVersion, DeleteVersion,
-                                      Family, DefaultKind, DefaultValue, NotNull, ColTypeData>;
+        using TColumns = TableColumns<TabId, ColId, ColName, ColType, ColKeyOrder,
+            CreateVersion, DeleteVersion, Family, DefaultKind, DefaultValue, NotNull, ColTypeData>;
     };
 
     struct MigratedColumnAlters : Table<63> {
-        struct OwnerPathId :    Column<1, NScheme::NTypeIds::Uint64> { using Type = TOwnerId;};
-        struct LocalPathId :    Column<2, NScheme::NTypeIds::Uint64> { using Type = TLocalPathId;};
+        struct OwnerPathId :    Column<1, NScheme::NTypeIds::Uint64> { using Type = TOwnerId; };
+        struct LocalPathId :    Column<2, NScheme::NTypeIds::Uint64> { using Type = TLocalPathId; };
         struct ColId :          Column<3, NScheme::NTypeIds::Uint32> {};
 
         struct ColName :        Column<4, NScheme::NTypeIds::Utf8> {};
@@ -237,11 +233,11 @@ struct Schema : NIceDb::Schema {
         struct Family :         Column<9, NScheme::NTypeIds::Uint32> {};
         struct DefaultKind :    Column<10, NScheme::NTypeIds::Uint32> { using Type = ETableColumnDefaultKind; static constexpr Type Default = Type::None; };
         struct DefaultValue :   Column<11, NScheme::NTypeIds::String> {};
-        struct NotNull:         Column<12, NScheme::NTypeIds::Bool> {};
+        struct NotNull :        Column<12, NScheme::NTypeIds::Bool> {};
 
         using TKey = TableKey<OwnerPathId, LocalPathId, ColId>;
-        using TColumns = TableColumns<OwnerPathId, LocalPathId, ColId, ColName, ColType, ColKeyOrder, CreateVersion, DeleteVersion,
-                                      Family, DefaultKind, DefaultValue, NotNull, ColTypeData>;
+        using TColumns = TableColumns<OwnerPathId, LocalPathId, ColId, ColName, ColType, ColKeyOrder,
+            CreateVersion, DeleteVersion, Family, DefaultKind, DefaultValue, NotNull, ColTypeData>;
     };
 
     struct Shards : Table<7> {
@@ -251,19 +247,19 @@ struct Schema : NIceDb::Schema {
         // there can be only 1 schema Tx on a shard at any moment in time
         struct LastTxId :       Column<4, NScheme::NTypeIds::Uint64> { using Type = TTxId; };
         struct TabletType :     Column<5, NScheme::NTypeIds::Uint32> { using Type = TTabletTypes::EType; static constexpr Type Default = ETabletType::TypeInvalid; };
-        struct OwnerPathId :    Column<6, NScheme::NTypeIds::Uint64> { using Type = TOwnerId; static constexpr Type Default = InvalidOwnerId;};
+        struct OwnerPathId :    Column<6, NScheme::NTypeIds::Uint64> { using Type = TOwnerId; static constexpr Type Default = InvalidOwnerId; };
 
         using TKey = TableKey<ShardIdx>;
         using TColumns = TableColumns<ShardIdx, TabletId, PathId, LastTxId, TabletType, OwnerPathId>;
     };
 
     struct MigratedShards : Table<52> {
-        struct OwnerShardId :   Column<1, NScheme::NTypeIds::Uint64> { using Type = TOwnerId;};
-        struct LocalShardId :   Column<2, NScheme::NTypeIds::Uint64> { using Type = TLocalShardIdx;};
+        struct OwnerShardId :   Column<1, NScheme::NTypeIds::Uint64> { using Type = TOwnerId; };
+        struct LocalShardId :   Column<2, NScheme::NTypeIds::Uint64> { using Type = TLocalShardIdx; };
 
-        struct TabletId :       Column<3, NScheme::NTypeIds::Uint64> { using Type = TTabletId;};
-        struct OwnerPathId :    Column<4, NScheme::NTypeIds::Uint64> { using Type = TOwnerId;};
-        struct LocalPathId :    Column<5, NScheme::NTypeIds::Uint64> { using Type = TLocalPathId;};
+        struct TabletId :       Column<3, NScheme::NTypeIds::Uint64> { using Type = TTabletId; };
+        struct OwnerPathId :    Column<4, NScheme::NTypeIds::Uint64> { using Type = TOwnerId; };
+        struct LocalPathId :    Column<5, NScheme::NTypeIds::Uint64> { using Type = TLocalPathId; };
 
         // there can be only 1 schema Tx on a shard at any moment in time
         struct LastTxId :       Column<6, NScheme::NTypeIds::Uint64> { using Type = TTxId; };
@@ -278,19 +274,19 @@ struct Schema : NIceDb::Schema {
         struct ChannelId :      Column<2, NScheme::NTypeIds::Uint32> {};
 
         struct PoolName :       Column<4, NScheme::NTypeIds::Utf8> {};
-        struct Binding:         Column<5, NScheme::NTypeIds::String> {};
+        struct Binding :        Column<5, NScheme::NTypeIds::String> {};
 
         using TKey = TableKey<ShardId, ChannelId>;
         using TColumns = TableColumns<ShardId, ChannelId, PoolName, Binding>;
     };
 
     struct MigratedChannelsBinding : Table<53> {
-        struct OwnerShardId :   Column<1, NScheme::NTypeIds::Uint64> { using Type = TOwnerId;};
-        struct LocalShardId :   Column<2, NScheme::NTypeIds::Uint64> { using Type = TLocalShardIdx;};
+        struct OwnerShardId :   Column<1, NScheme::NTypeIds::Uint64> { using Type = TOwnerId; };
+        struct LocalShardId :   Column<2, NScheme::NTypeIds::Uint64> { using Type = TLocalShardIdx; };
         struct ChannelId :      Column<3, NScheme::NTypeIds::Uint32> {};
 
         struct PoolName :       Column<4, NScheme::NTypeIds::Utf8> {};
-        struct Binding:         Column<5, NScheme::NTypeIds::String> {};
+        struct Binding :        Column<5, NScheme::NTypeIds::String> {};
 
         using TKey = TableKey<OwnerShardId, LocalShardId, ChannelId>;
         using TColumns = TableColumns<OwnerShardId, LocalShardId, ChannelId, PoolName, Binding>;
@@ -308,49 +304,49 @@ struct Schema : NIceDb::Schema {
         using TColumns = TableColumns<TabId, Id, RangeEnd, DatashardIdx, LastCondErase, NextCondErase>;
     };
 
-    struct TablePartitionStats: Table<101> { // HACK: Force to use policy with multiple levels
+    struct TablePartitionStats : Table<101> { // HACK: Force to use policy with multiple levels
         // key
-        struct TableOwnerId: Column<1, NScheme::NTypeIds::Uint64> {using Type = TOwnerId;};
-        struct TableLocalId: Column<2, NScheme::NTypeIds::Uint64> {using Type = TLocalPathId;};
-        struct PartitionId: Column<3, NScheme::NTypeIds::Uint64> {};
+        struct TableOwnerId : Column<1, NScheme::NTypeIds::Uint64> { using Type = TOwnerId; };
+        struct TableLocalId : Column<2, NScheme::NTypeIds::Uint64> { using Type = TLocalPathId; };
+        struct PartitionId : Column<3, NScheme::NTypeIds::Uint64> {};
 
         // seqno
-        struct SeqNoGeneration: Column<4, NScheme::NTypeIds::Uint64> {};
-        struct SeqNoRound: Column<5, NScheme::NTypeIds::Uint64> {};
+        struct SeqNoGeneration : Column<4, NScheme::NTypeIds::Uint64> {};
+        struct SeqNoRound : Column<5, NScheme::NTypeIds::Uint64> {};
 
         // stats
-        struct RowCount: Column<6, NScheme::NTypeIds::Uint64> {};
-        struct DataSize: Column<7, NScheme::NTypeIds::Uint64> {};
-        struct IndexSize: Column<8, NScheme::NTypeIds::Uint64> {};
-
-        struct LastAccessTime: Column<9, NScheme::NTypeIds::Uint64> { using Type = TInstant::TValue; };
-        struct LastUpdateTime: Column<10, NScheme::NTypeIds::Uint64> { using Type = TInstant::TValue; };
-
-        struct ImmediateTxCompleted: Column<11, NScheme::NTypeIds::Uint64> {};
-        struct PlannedTxCompleted: Column<12, NScheme::NTypeIds::Uint64> {};
-        struct TxRejectedByOverload: Column<13, NScheme::NTypeIds::Uint64> {};
-        struct TxRejectedBySpace: Column<14, NScheme::NTypeIds::Uint64> {};
-        struct TxCompleteLag: Column<15, NScheme::NTypeIds::Uint64> { using Type = TInstant::TValue; };
-        struct InFlightTxCount: Column<16, NScheme::NTypeIds::Uint64> {};
-
-        struct RowUpdates: Column<17, NScheme::NTypeIds::Uint64> {};
-        struct RowDeletes: Column<18, NScheme::NTypeIds::Uint64> {};
-        struct RowReads: Column<19, NScheme::NTypeIds::Uint64> {};
-        struct RangeReads: Column<20, NScheme::NTypeIds::Uint64> {};
-        struct RangeReadRows: Column<21, NScheme::NTypeIds::Uint64> {};
-
-        struct CPU: Column<22, NScheme::NTypeIds::Uint64> {};
-        struct Memory: Column<23, NScheme::NTypeIds::Uint64> {};
-        struct Network: Column<24, NScheme::NTypeIds::Uint64> {};
-        struct Storage: Column<25, NScheme::NTypeIds::Uint64> {};
-        struct ReadThroughput: Column<26, NScheme::NTypeIds::Uint64> {};
-        struct WriteThroughput: Column<27, NScheme::NTypeIds::Uint64> {};
-        struct ReadIops: Column<28, NScheme::NTypeIds::Uint64> {};
-        struct WriteIops: Column<29, NScheme::NTypeIds::Uint64> {};
-
-        struct SearchHeight: Column<30, NScheme::NTypeIds::Uint64> { static constexpr ui64 Default = 0; };
-        struct FullCompactionTs: Column<31, NScheme::NTypeIds::Uint64> { static constexpr ui64 Default = 0; };
-        struct MemDataSize: Column<32, NScheme::NTypeIds::Uint64> { static constexpr ui64 Default = 0; };
+        struct RowCount : Column<6, NScheme::NTypeIds::Uint64> {};
+        struct DataSize : Column<7, NScheme::NTypeIds::Uint64> {};
+        struct IndexSize : Column<8, NScheme::NTypeIds::Uint64> {};
+
+        struct LastAccessTime : Column<9, NScheme::NTypeIds::Uint64> { using Type = TInstant::TValue; };
+        struct LastUpdateTime : Column<10, NScheme::NTypeIds::Uint64> { using Type = TInstant::TValue; };
+
+        struct ImmediateTxCompleted : Column<11, NScheme::NTypeIds::Uint64> {};
+        struct PlannedTxCompleted : Column<12, NScheme::NTypeIds::Uint64> {};
+        struct TxRejectedByOverload : Column<13, NScheme::NTypeIds::Uint64> {};
+        struct TxRejectedBySpace : Column<14, NScheme::NTypeIds::Uint64> {};
+        struct TxCompleteLag : Column<15, NScheme::NTypeIds::Uint64> { using Type = TInstant::TValue; };
+        struct InFlightTxCount : Column<16, NScheme::NTypeIds::Uint64> {};
+
+        struct RowUpdates : Column<17, NScheme::NTypeIds::Uint64> {};
+        struct RowDeletes : Column<18, NScheme::NTypeIds::Uint64> {};
+        struct RowReads : Column<19, NScheme::NTypeIds::Uint64> {};
+        struct RangeReads : Column<20, NScheme::NTypeIds::Uint64> {};
+        struct RangeReadRows : Column<21, NScheme::NTypeIds::Uint64> {};
+
+        struct CPU : Column<22, NScheme::NTypeIds::Uint64> {};
+        struct Memory : Column<23, NScheme::NTypeIds::Uint64> {};
+        struct Network : Column<24, NScheme::NTypeIds::Uint64> {};
+        struct Storage : Column<25, NScheme::NTypeIds::Uint64> {};
+        struct ReadThroughput : Column<26, NScheme::NTypeIds::Uint64> {};
+        struct WriteThroughput : Column<27, NScheme::NTypeIds::Uint64> {};
+        struct ReadIops : Column<28, NScheme::NTypeIds::Uint64> {};
+        struct WriteIops : Column<29, NScheme::NTypeIds::Uint64> {};
+
+        struct SearchHeight : Column<30, NScheme::NTypeIds::Uint64> { static constexpr ui64 Default = 0; };
+        struct FullCompactionTs : Column<31, NScheme::NTypeIds::Uint64> { static constexpr ui64 Default = 0; };
+        struct MemDataSize : Column<32, NScheme::NTypeIds::Uint64> { static constexpr ui64 Default = 0; };
 
         // PartCount, PartOwners & ShardState are volatile data
 
@@ -392,8 +388,8 @@ struct Schema : NIceDb::Schema {
     };
 
     struct MigratedTablePartitions : Table<56> {
-        struct OwnerPathId :    Column<1, NScheme::NTypeIds::Uint64> { using Type = TOwnerId;};
-        struct LocalPathId :    Column<2, NScheme::NTypeIds::Uint64> { using Type = TLocalPathId;};
+        struct OwnerPathId :    Column<1, NScheme::NTypeIds::Uint64> { using Type = TOwnerId; };
+        struct LocalPathId :    Column<2, NScheme::NTypeIds::Uint64> { using Type = TLocalPathId; };
         struct Id :             Column<3, NScheme::NTypeIds::Uint64> {};
 
         struct RangeEnd :       Column<4, NScheme::NTypeIds::String> { using Type = TString; };
@@ -460,8 +456,8 @@ struct Schema : NIceDb::Schema {
     };
 
     struct RtmrVolumes : Table<20> {
-        struct PathId :         Column<1, NScheme::NTypeIds::Uint64> {};
-        struct PartitionsCount :Column<2, NScheme::NTypeIds::Uint32> {};
+        struct PathId : Column<1, NScheme::NTypeIds::Uint64> {};
+        struct PartitionsCount : Column<2, NScheme::NTypeIds::Uint32> {};
 
         using TKey = TableKey<PathId>;
         using TColumns = TableColumns<PathId, PartitionsCount>;
@@ -495,18 +491,17 @@ struct Schema : NIceDb::Schema {
     };
 
     struct AlterSolomonVolumes : Table<75> {
-        struct OwnerPathId :    Column<1, NScheme::NTypeIds::Uint64> { using Type = TOwnerId;};
-        struct LocalPathId :    Column<2, NScheme::NTypeIds::Uint64> { using Type = TLocalPathId;};
+        struct OwnerPathId :    Column<1, NScheme::NTypeIds::Uint64> { using Type = TOwnerId; };
+        struct LocalPathId :    Column<2, NScheme::NTypeIds::Uint64> { using Type = TLocalPathId; };
         struct Version :        Column<3, NScheme::NTypeIds::Uint64> {};
 
-
         using TKey = TableKey<OwnerPathId, LocalPathId>;
         using TColumns = TableColumns<OwnerPathId, LocalPathId, Version>;
     };
 
     struct AlterSolomonPartitions : Table<76> {
-        struct OwnerPathId :    Column<1, NScheme::NTypeIds::Uint64> { using Type = TOwnerId;};
-        struct LocalPathId :    Column<2, NScheme::NTypeIds::Uint64> { using Type = TLocalPathId;};
+        struct OwnerPathId :    Column<1, NScheme::NTypeIds::Uint64> { using Type = TOwnerId; };
+        struct LocalPathId :    Column<2, NScheme::NTypeIds::Uint64> { using Type = TLocalPathId; };
 
         struct ShardOwnerId :   Column<3, NScheme::NTypeIds::Uint64> { using Type = TOwnerId; };
         struct ShardLocalIdx :  Column<4, NScheme::NTypeIds::Uint64> { using Type = TLocalShardIdx; };
@@ -524,7 +519,7 @@ struct Schema : NIceDb::Schema {
         using TColumns = TableColumns<ShardIdx>;
     };
 
-    struct MigratedShardsToDelete: Table<60> {
+    struct MigratedShardsToDelete : Table<60> {
         struct ShardOwnerId : Column<1, NScheme::NTypeIds::Uint64> { using Type = TOwnerId; };
         struct ShardLocalIdx : Column<2, NScheme::NTypeIds::Uint64> { using Type = TLocalShardIdx; };
 
@@ -532,18 +527,18 @@ struct Schema : NIceDb::Schema {
         using TColumns = TableColumns<ShardOwnerId, ShardLocalIdx>;
     };
 
-    struct BackupSettings: Table<15> {
-        struct PathId: Column<1, NScheme::NTypeIds::Uint64> {using Type = TLocalPathId;};
-        struct TableName: Column<2, NScheme::NTypeIds::Utf8> {};
-        struct YTSettings: Column<3, NScheme::NTypeIds::String> {};
-        struct S3Settings: Column<6, NScheme::NTypeIds::String> {};
+    struct BackupSettings : Table<15> {
+        struct PathId : Column<1, NScheme::NTypeIds::Uint64> { using Type = TLocalPathId; };
+        struct TableName : Column<2, NScheme::NTypeIds::Utf8> {};
+        struct YTSettings : Column<3, NScheme::NTypeIds::String> {};
+        struct S3Settings : Column<6, NScheme::NTypeIds::String> {};
         struct TableDescription : Column<7, NScheme::NTypeIds::String> {};
         struct NumberOfRetries : Column<8, NScheme::NTypeIds::Uint32> {};
         struct ScanSettings : Column<9, NScheme::NTypeIds::String> {};
-        struct NeedToBill: Column<10, NScheme::NTypeIds::Bool> {};
+        struct NeedToBill : Column<10, NScheme::NTypeIds::Bool> {};
         // deprecated
-        struct CreateDestinationFlag: Column<4, NScheme::NTypeIds::Bool> {};
-        struct EraseOldDataFlag: Column<5, NScheme::NTypeIds::Bool> {};
+        struct CreateDestinationFlag : Column<4, NScheme::NTypeIds::Bool> {};
+        struct EraseOldDataFlag : Column<5, NScheme::NTypeIds::Bool> {};
 
         using TKey = TableKey<PathId>;
         using TColumns = TableColumns<
@@ -560,20 +555,20 @@ struct Schema : NIceDb::Schema {
         >;
     };
 
-    struct MigratedBackupSettings: Table<64> {
-        struct OwnerPathId :    Column<1, NScheme::NTypeIds::Uint64> { using Type = TOwnerId;};
-        struct LocalPathId :    Column<2, NScheme::NTypeIds::Uint64> { using Type = TLocalPathId;};
+    struct MigratedBackupSettings : Table<64> {
+        struct OwnerPathId : Column<1, NScheme::NTypeIds::Uint64> { using Type = TOwnerId; };
+        struct LocalPathId : Column<2, NScheme::NTypeIds::Uint64> { using Type = TLocalPathId; };
 
-        struct TableName: Column<3, NScheme::NTypeIds::Utf8> {};
-        struct YTSettings: Column<4, NScheme::NTypeIds::String> {};
-        struct S3Settings: Column<7, NScheme::NTypeIds::String> {};
+        struct TableName : Column<3, NScheme::NTypeIds::Utf8> {};
+        struct YTSettings : Column<4, NScheme::NTypeIds::String> {};
+        struct S3Settings : Column<7, NScheme::NTypeIds::String> {};
         struct TableDescription : Column<8, NScheme::NTypeIds::String> {};
         struct NumberOfRetries : Column<9, NScheme::NTypeIds::Uint32> {};
         struct ScanSettings : Column<10, NScheme::NTypeIds::String> {};
-        struct NeedToBill: Column<11, NScheme::NTypeIds::Bool> {};
+        struct NeedToBill : Column<11, NScheme::NTypeIds::Bool> {};
         // deprecated
-        struct CreateDestinationFlag: Column<5, NScheme::NTypeIds::Bool> {};
-        struct EraseOldDataFlag: Column<6, NScheme::NTypeIds::Bool> {};
+        struct CreateDestinationFlag : Column<5, NScheme::NTypeIds::Bool> {};
+        struct EraseOldDataFlag : Column<6, NScheme::NTypeIds::Bool> {};
 
         using TKey = TableKey<OwnerPathId, LocalPathId>;
         using TColumns = TableColumns<
@@ -591,18 +586,17 @@ struct Schema : NIceDb::Schema {
         >;
     };
 
-    struct CompletedBackups: Table<16> {
-        struct PathId:               Column<1, NScheme::NTypeIds::Uint64> {};
-        struct TxId:                 Column<2, NScheme::NTypeIds::Uint64> { using Type = TTxId; };
-        struct DateTimeOfCompletion: Column<3, NScheme::NTypeIds::Uint64> {};
-
-        struct SuccessShardCount:    Column<4, NScheme::NTypeIds::Uint32> {};
-        struct TotalShardCount:      Column<5, NScheme::NTypeIds::Uint32> {};
-        struct StartTime:            Column<6, NScheme::NTypeIds::Uint64> {};
-        struct YTSettings:           Column<7, NScheme::NTypeIds::String> {};
-        struct S3Settings:           Column<9, NScheme::NTypeIds::String> {};
-        struct DataTotalSize:        Column<8, NScheme::NTypeIds::Uint64> {};
-        struct Kind:                 Column<10, NScheme::NTypeIds::Byte> {};
+    struct CompletedBackups : Table<16> {
+        struct PathId : Column<1, NScheme::NTypeIds::Uint64> {};
+        struct TxId : Column<2, NScheme::NTypeIds::Uint64> { using Type = TTxId; };
+        struct DateTimeOfCompletion : Column<3, NScheme::NTypeIds::Uint64> {};
+        struct SuccessShardCount : Column<4, NScheme::NTypeIds::Uint32> {};
+        struct TotalShardCount : Column<5, NScheme::NTypeIds::Uint32> {};
+        struct StartTime : Column<6, NScheme::NTypeIds::Uint64> {};
+        struct YTSettings : Column<7, NScheme::NTypeIds::String> {};
+        struct S3Settings : Column<9, NScheme::NTypeIds::String> {};
+        struct DataTotalSize : Column<8, NScheme::NTypeIds::Uint64> {};
+        struct Kind : Column<10, NScheme::NTypeIds::Byte> {};
 
         using TKey = TableKey<PathId, TxId, DateTimeOfCompletion>;
         using TColumns = TableColumns<
@@ -619,22 +613,20 @@ struct Schema : NIceDb::Schema {
         >;
     };
 
-    struct MigratedCompletedBackups: Table<65> {
-        struct OwnerPathId :          Column<1, NScheme::NTypeIds::Uint64> { using Type = TOwnerId;};
-        struct LocalPathId :          Column<2, NScheme::NTypeIds::Uint64> { using Type = TLocalPathId;};
-        struct TxId :                 Column<3, NScheme::NTypeIds::Uint64> { using Type = TTxId; };
-        struct DateTimeOfCompletion:  Column<5, NScheme::NTypeIds::Uint64> {};
-
-        struct SuccessShardCount:     Column<6, NScheme::NTypeIds::Uint32> {};
-        struct TotalShardCount:       Column<7, NScheme::NTypeIds::Uint32> {};
-        struct StartTime:             Column<8, NScheme::NTypeIds::Uint64> {};
-        struct YTSettings:            Column<9, NScheme::NTypeIds::String> {};
-        struct S3Settings:            Column<11, NScheme::NTypeIds::String> {};
-        struct DataTotalSize:         Column<10, NScheme::NTypeIds::Uint64> {};
-        struct Kind:                  Column<12, NScheme::NTypeIds::Byte> {};
+    struct MigratedCompletedBackups : Table<65> {
+        struct OwnerPathId : Column<1, NScheme::NTypeIds::Uint64> { using Type = TOwnerId; };
+        struct LocalPathId : Column<2, NScheme::NTypeIds::Uint64> { using Type = TLocalPathId; };
+        struct TxId : Column<3, NScheme::NTypeIds::Uint64> { using Type = TTxId; };
+        struct DateTimeOfCompletion : Column<5, NScheme::NTypeIds::Uint64> {};
+        struct SuccessShardCount : Column<6, NScheme::NTypeIds::Uint32> {};
+        struct TotalShardCount : Column<7, NScheme::NTypeIds::Uint32> {};
+        struct StartTime : Column<8, NScheme::NTypeIds::Uint64> {};
+        struct YTSettings : Column<9, NScheme::NTypeIds::String> {};
+        struct S3Settings : Column<11, NScheme::NTypeIds::String> {};
+        struct DataTotalSize : Column<10, NScheme::NTypeIds::Uint64> {};
+        struct Kind : Column<12, NScheme::NTypeIds::Byte> {};
 
         using TKey = TableKey<OwnerPathId, LocalPathId, TxId, DateTimeOfCompletion>;
-
         using TColumns = TableColumns<
             OwnerPathId,
             LocalPathId,
@@ -651,11 +643,10 @@ struct Schema : NIceDb::Schema {
     };
 
     // *ShardBackupStatus is deprecated, use TxShardStatus instead
-    struct ShardBackupStatus: Table<17> {
-        struct TxId :     Column<1, NScheme::NTypeIds::Uint64> { using Type = TTxId; };
+    struct ShardBackupStatus : Table<17> {
+        struct TxId : Column<1, NScheme::NTypeIds::Uint64> { using Type = TTxId; };
         struct ShardIdx : Column<2, NScheme::NTypeIds::Uint64> { using Type = TLocalShardIdx; };
-
-        struct Explain :  Column<3, NScheme::NTypeIds::Utf8> {};
+        struct Explain : Column<3, NScheme::NTypeIds::Utf8> {};
 
         using TKey = TableKey<TxId, ShardIdx>;
         using TColumns = TableColumns<
@@ -665,12 +656,11 @@ struct Schema : NIceDb::Schema {
         >;
     };
 
-    struct MigratedShardBackupStatus: Table<66> {
-        struct TxId :           Column<1, NScheme::NTypeIds::Uint64> { using Type = TTxId; };
-        struct OwnerShardId :   Column<2, NScheme::NTypeIds::Uint64> { using Type = TOwnerId;};
-        struct LocalShardId :   Column<3, NScheme::NTypeIds::Uint64> { using Type = TLocalShardIdx;};
-
-        struct Explain:         Column<4, NScheme::NTypeIds::Utf8> {};
+    struct MigratedShardBackupStatus : Table<66> {
+        struct TxId : Column<1, NScheme::NTypeIds::Uint64> { using Type = TTxId; };
+        struct OwnerShardId : Column<2, NScheme::NTypeIds::Uint64> { using Type = TOwnerId; };
+        struct LocalShardId : Column<3, NScheme::NTypeIds::Uint64> { using Type = TLocalShardIdx; };
+        struct Explain : Column<4, NScheme::NTypeIds::Utf8> {};
 
         using TKey = TableKey<TxId, OwnerShardId, LocalShardId>;
         using TColumns = TableColumns<
@@ -678,13 +668,13 @@ struct Schema : NIceDb::Schema {
             OwnerShardId,
             LocalShardId,
             Explain
-            >;
+        >;
     };
 
     struct TxShardStatus : Table<87> {
         struct TxId : Column<1, NScheme::NTypeIds::Uint64> { using Type = TTxId; };
-        struct OwnerShardId : Column<2, NScheme::NTypeIds::Uint64> { using Type = TOwnerId;};
-        struct LocalShardId : Column<3, NScheme::NTypeIds::Uint64> { using Type = TLocalShardIdx;};
+        struct OwnerShardId : Column<2, NScheme::NTypeIds::Uint64> { using Type = TOwnerId; };
+        struct LocalShardId : Column<3, NScheme::NTypeIds::Uint64> { using Type = TLocalShardIdx; };
 
         struct Success : Column<4, NScheme::NTypeIds::Bool> {};
         struct Error : Column<5, NScheme::NTypeIds::Utf8> {};
@@ -703,24 +693,24 @@ struct Schema : NIceDb::Schema {
         >;
     };
 
-    struct SubDomains: Table<18> {
-        struct PathId          : Column<1, NScheme::NTypeIds::Uint64> {};
-        struct AlterVersion    : Column<2, NScheme::NTypeIds::Uint64> {};
-        struct PlanResolution  : Column<3, NScheme::NTypeIds::Uint64> {};
+    struct SubDomains : Table<18> {
+        struct PathId : Column<1, NScheme::NTypeIds::Uint64> {};
+        struct AlterVersion : Column<2, NScheme::NTypeIds::Uint64> {};
+        struct PlanResolution : Column<3, NScheme::NTypeIds::Uint64> {};
         struct TimeCastBuckets : Column<4, NScheme::NTypeIds::Uint32> {};
-        struct DepthLimit      : Column<5, NScheme::NTypeIds::Uint64> {};
-        struct PathsLimit      : Column<6, NScheme::NTypeIds::Uint64> {};
-        struct ChildrenLimit   : Column<7, NScheme::NTypeIds::Uint64> {};
-        struct ShardsLimit     : Column<8, NScheme::NTypeIds::Uint64> {};
+        struct DepthLimit : Column<5, NScheme::NTypeIds::Uint64> {};
+        struct PathsLimit : Column<6, NScheme::NTypeIds::Uint64> {};
+        struct ChildrenLimit : Column<7, NScheme::NTypeIds::Uint64> {};
+        struct ShardsLimit : Column<8, NScheme::NTypeIds::Uint64> {};
         struct PathShardsLimit : Column<9, NScheme::NTypeIds::Uint64> {};
         struct TableColumnsLimit : Column<10, NScheme::NTypeIds::Uint64> {};
         struct TableColumnNameLengthLimit : Column<11, NScheme::NTypeIds::Uint64> {};
         struct TableKeyColumnsLimit : Column<12, NScheme::NTypeIds::Uint64> {};
         struct TableIndicesLimit : Column<13, NScheme::NTypeIds::Uint64> {};
         struct AclByteSizeLimit : Column<14, NScheme::NTypeIds::Uint64> {};
-        struct ConsistentCopyingTargetsLimit: Column<15, NScheme::NTypeIds::Uint64> {};
-        struct PathElementLength: Column<16, NScheme::NTypeIds::Uint64> {};
-        struct ExtraPathSymbolsAllowed: Column<17, NScheme::NTypeIds::Utf8> {};
+        struct ConsistentCopyingTargetsLimit : Column<15, NScheme::NTypeIds::Uint64> {};
+        struct PathElementLength : Column<16, NScheme::NTypeIds::Uint64> {};
+        struct ExtraPathSymbolsAllowed : Column<17, NScheme::NTypeIds::Utf8> {};
         struct ResourcesDomainOwnerPathId : Column<18, NScheme::NTypeIds::Uint64> { using Type = TOwnerId; static constexpr Type Default = InvalidOwnerId; };
         struct ResourcesDomainLocalPathId : Column<19, NScheme::NTypeIds::Uint64> { using Type = TLocalPathId; static constexpr Type Default = InvalidLocalPathId; };
         struct SharedHiveId : Column<20, NScheme::NTypeIds::Uint64> { using Type = TTabletId; static constexpr Type Default = InvalidTabletId; };
@@ -764,19 +754,19 @@ struct Schema : NIceDb::Schema {
         >;
     };
 
-    struct SubDomainShards: Table<19> {
-        struct PathId: Column<1, NScheme::NTypeIds::Uint64> {};
-        struct ShardIdx: Column<2, NScheme::NTypeIds::Uint64> { using Type = TLocalShardIdx; };
+    struct SubDomainShards : Table<19> {
+        struct PathId : Column<1, NScheme::NTypeIds::Uint64> {};
+        struct ShardIdx : Column<2, NScheme::NTypeIds::Uint64> { using Type = TLocalShardIdx; };
 
         using TKey = TableKey<PathId, ShardIdx>;
         using TColumns = TableColumns<PathId, ShardIdx>;
     };
 
-    struct SubDomainsAlterData: Table<33> {
-        struct PathId: Column<1, NScheme::NTypeIds::Uint64> {};
-        struct AlterVersion: Column<2, NScheme::NTypeIds::Uint64> {};
-        struct PlanResolution: Column<3, NScheme::NTypeIds::Uint64> {};
-        struct TimeCastBuckets: Column<4, NScheme::NTypeIds::Uint32> {};
+    struct SubDomainsAlterData : Table<33> {
+        struct PathId : Column<1, NScheme::NTypeIds::Uint64> {};
+        struct AlterVersion : Column<2, NScheme::NTypeIds::Uint64> {};
+        struct PlanResolution : Column<3, NScheme::NTypeIds::Uint64> {};
+        struct TimeCastBuckets : Column<4, NScheme::NTypeIds::Uint32> {};
         struct ResourcesDomainOwnerPathId : Column<5, NScheme::NTypeIds::Uint64> { using Type = TOwnerId; static constexpr Type Default = InvalidOwnerId; };
         struct ResourcesDomainLocalPathId : Column<6, NScheme::NTypeIds::Uint64> { using Type = TLocalPathId; static constexpr Type Default = InvalidLocalPathId; };
         struct SharedHiveId : Column<7, NScheme::NTypeIds::Uint64> { using Type = TTabletId; static constexpr Type Default = InvalidTabletId; };
@@ -797,176 +787,174 @@ struct Schema : NIceDb::Schema {
         >;
     };
 
-    struct SubDomainShardsAlterData: Table<34> {
-        struct PathId: Column<1, NScheme::NTypeIds::Uint64> {};
-        struct ShardIdx: Column<2, NScheme::NTypeIds::Uint64> { using Type = TLocalShardIdx; };
+    struct SubDomainShardsAlterData : Table<34> {
+        struct PathId : Column<1, NScheme::NTypeIds::Uint64> {};
+        struct ShardIdx : Column<2, NScheme::NTypeIds::Uint64> { using Type = TLocalShardIdx; };
 
         using TKey = TableKey<PathId, ShardIdx>;
         using TColumns = TableColumns<PathId, ShardIdx>;
     };
 
     struct SubDomainSchemeQuotas : Table<77> {
-        struct PathId: Column<1, NScheme::NTypeIds::Uint64> {};
-        struct QuotaIdx: Column<2, NScheme::NTypeIds::Uint64> {};
-        struct BucketSize: Column<3, NScheme::NTypeIds::Double> {};
-        struct BucketDurationUs: Column<4, NScheme::NTypeIds::Uint64> {};
-        struct Available: Column<5, NScheme::NTypeIds::Double> {};
-        struct LastUpdateUs: Column<6, NScheme::NTypeIds::Uint64> {};
+        struct PathId : Column<1, NScheme::NTypeIds::Uint64> {};
+        struct QuotaIdx : Column<2, NScheme::NTypeIds::Uint64> {};
+        struct BucketSize : Column<3, NScheme::NTypeIds::Double> {};
+        struct BucketDurationUs : Column<4, NScheme::NTypeIds::Uint64> {};
+        struct Available : Column<5, NScheme::NTypeIds::Double> {};
+        struct LastUpdateUs : Column<6, NScheme::NTypeIds::Uint64> {};
 
         using TKey = TableKey<PathId, QuotaIdx>;
         using TColumns = TableColumns<PathId, QuotaIdx, BucketSize, BucketDurationUs, Available, LastUpdateUs>;
     };
 
-    struct StoragePools: Table<27> {
-        struct PathId: Column<1, NScheme::NTypeIds::Uint64> {};
-        struct PoolName: Column<4, NScheme::NTypeIds::Utf8> {};
-        struct PoolKind: Column<5, NScheme::NTypeIds::Utf8> {};
+    struct StoragePools : Table<27> {
+        struct PathId : Column<1, NScheme::NTypeIds::Uint64> {};
+        struct PoolName : Column<4, NScheme::NTypeIds::Utf8> {};
+        struct PoolKind : Column<5, NScheme::NTypeIds::Utf8> {};
 
         using TKey = TableKey<PathId, PoolName, PoolKind>;
         using TColumns = TableColumns<PathId, PoolName, PoolKind>;
     };
 
-    struct StoragePoolsAlterData: Table<35> {
-        struct PathId: Column<1, NScheme::NTypeIds::Uint64> {};
-        struct PoolName: Column<4, NScheme::NTypeIds::Utf8> {};
-        struct PoolKind: Column<5, NScheme::NTypeIds::Utf8> {};
+    struct StoragePoolsAlterData : Table<35> {
+        struct PathId : Column<1, NScheme::NTypeIds::Uint64> {};
+        struct PoolName : Column<4, NScheme::NTypeIds::Utf8> {};
+        struct PoolKind : Column<5, NScheme::NTypeIds::Utf8> {};
 
         using TKey = TableKey<PathId, PoolName, PoolKind>;
         using TColumns = TableColumns<PathId, PoolName, PoolKind>;
     };
 
     struct BlockStorePartitions : Table<22> {
-        struct PathId: Column<1, NScheme::NTypeIds::Uint64> {};
-        struct PartitionId: Column<2, NScheme::NTypeIds::Uint32> {};
-        struct ShardIdx: Column<3, NScheme::NTypeIds::Uint64> { using Type = TLocalShardIdx; };
-        struct AlterVersion: Column<4, NScheme::NTypeIds::Uint64> {};
+        struct PathId : Column<1, NScheme::NTypeIds::Uint64> {};
+        struct PartitionId : Column<2, NScheme::NTypeIds::Uint32> {};
+        struct ShardIdx : Column<3, NScheme::NTypeIds::Uint64> { using Type = TLocalShardIdx; };
+        struct AlterVersion : Column<4, NScheme::NTypeIds::Uint64> {};
 
         using TKey = TableKey<PathId, PartitionId>;
         using TColumns = TableColumns<PathId, PartitionId, ShardIdx, AlterVersion>;
     };
 
     struct BlockStoreVolumes : Table<23> {
-        struct PathId: Column<1, NScheme::NTypeIds::Uint64> {};
-        struct VolumeConfig: Column<2, NScheme::NTypeIds::String> {};
-        struct AlterVersion: Column<3, NScheme::NTypeIds::Uint64> {};
-        struct MountToken: Column<4, NScheme::NTypeIds::Utf8> {};
-        struct TokenVersion: Column<5, NScheme::NTypeIds::Uint64> {};
+        struct PathId : Column<1, NScheme::NTypeIds::Uint64> {};
+        struct VolumeConfig : Column<2, NScheme::NTypeIds::String> {};
+        struct AlterVersion : Column<3, NScheme::NTypeIds::Uint64> {};
+        struct MountToken : Column<4, NScheme::NTypeIds::Utf8> {};
+        struct TokenVersion : Column<5, NScheme::NTypeIds::Uint64> {};
 
         using TKey = TableKey<PathId>;
         using TColumns = TableColumns<PathId, VolumeConfig, AlterVersion, MountToken, TokenVersion>;
     };
 
     struct BlockStoreVolumeAlters : Table<24> {
-        struct PathId: Column<1, NScheme::NTypeIds::Uint64> {};
-        struct VolumeConfig: Column<2, NScheme::NTypeIds::String> {};
-        struct AlterVersion: Column<3, NScheme::NTypeIds::Uint64> {};
-        struct PartitionCount: Column<4, NScheme::NTypeIds::Uint32> {};
+        struct PathId : Column<1, NScheme::NTypeIds::Uint64> {};
+        struct VolumeConfig : Column<2, NScheme::NTypeIds::String> {};
+        struct AlterVersion : Column<3, NScheme::NTypeIds::Uint64> {};
+        struct PartitionCount : Column<4, NScheme::NTypeIds::Uint32> {};
 
         using TKey = TableKey<PathId>;
         using TColumns = TableColumns<PathId, VolumeConfig, AlterVersion, PartitionCount>;
     };
 
     struct FileStoreInfos : Table<78> {
-        struct PathId: Column<1, NScheme::NTypeIds::Uint64> {};
-        struct Config: Column<2, NScheme::NTypeIds::String> {};
-        struct Version: Column<3, NScheme::NTypeIds::Uint64> {};
+        struct PathId : Column<1, NScheme::NTypeIds::Uint64> {};
+        struct Config : Column<2, NScheme::NTypeIds::String> {};
+        struct Version : Column<3, NScheme::NTypeIds::Uint64> {};
 
         using TKey = TableKey<PathId>;
         using TColumns = TableColumns<PathId, Config, Version>;
     };
 
     struct FileStoreAlters : Table<79> {
-        struct PathId: Column<1, NScheme::NTypeIds::Uint64> {};
-        struct Config: Column<2, NScheme::NTypeIds::String> {};
-        struct Version: Column<3, NScheme::NTypeIds::Uint64> {};
+        struct PathId : Column<1, NScheme::NTypeIds::Uint64> {};
+        struct Config : Column<2, NScheme::NTypeIds::String> {};
+        struct Version : Column<3, NScheme::NTypeIds::Uint64> {};
 
         using TKey = TableKey<PathId>;
         using TColumns = TableColumns<PathId, Config, Version>;
     };
 
     struct KesusInfos : Table<26> {
-        struct PathId: Column<1, NScheme::NTypeIds::Uint64> {};
-        struct Config: Column<2, NScheme::NTypeIds::String> {};
-        struct Version: Column<3, NScheme::NTypeIds::Uint64> { static constexpr ui64 Default = 1; };
+        struct PathId : Column<1, NScheme::NTypeIds::Uint64> {};
+        struct Config : Column<2, NScheme::NTypeIds::String> {};
+        struct Version : Column<3, NScheme::NTypeIds::Uint64> { static constexpr ui64 Default = 1; };
 
         using TKey = TableKey<PathId>;
         using TColumns = TableColumns<PathId, Config, Version>;
     };
 
     struct MigratedKesusInfos : Table<83> {
-        struct OwnerPathId :  Column<1, NScheme::NTypeIds::Uint64> { using Type = TOwnerId;};
-        struct LocalPathId :  Column<2, NScheme::NTypeIds::Uint64> { using Type = TLocalPathId;};
-
-        struct Config: Column<3, NScheme::NTypeIds::String> {};
-        struct Version: Column<4, NScheme::NTypeIds::Uint64> { static constexpr ui64 Default = 1; };
+        struct OwnerPathId : Column<1, NScheme::NTypeIds::Uint64> { using Type = TOwnerId; };
+        struct LocalPathId : Column<2, NScheme::NTypeIds::Uint64> { using Type = TLocalPathId; };
+        struct Config : Column<3, NScheme::NTypeIds::String> {};
+        struct Version : Column<4, NScheme::NTypeIds::Uint64> { static constexpr ui64 Default = 1; };
 
         using TKey = TableKey<OwnerPathId, LocalPathId>;
         using TColumns = TableColumns<OwnerPathId, LocalPathId, Config, Version>;
     };
 
     struct KesusAlters : Table<32> {
-        struct PathId: Column<1, NScheme::NTypeIds::Uint64> {};
-        struct Config: Column<2, NScheme::NTypeIds::String> {};
-        struct Version: Column<3, NScheme::NTypeIds::Uint64> {};
+        struct PathId : Column<1, NScheme::NTypeIds::Uint64> {};
+        struct Config : Column<2, NScheme::NTypeIds::String> {};
+        struct Version : Column<3, NScheme::NTypeIds::Uint64> {};
 
         using TKey = TableKey<PathId>;
         using TColumns = TableColumns<PathId, Config, Version>;
     };
 
     struct MigratedKesusAlters : Table<84> {
-        struct OwnerPathId :  Column<1, NScheme::NTypeIds::Uint64> { using Type = TOwnerId;};
-        struct LocalPathId :  Column<2, NScheme::NTypeIds::Uint64> { using Type = TLocalPathId;};
-
-        struct Config: Column<3, NScheme::NTypeIds::String> {};
-        struct Version: Column<4, NScheme::NTypeIds::Uint64> {};
+        struct OwnerPathId : Column<1, NScheme::NTypeIds::Uint64> { using Type = TOwnerId; };
+        struct LocalPathId : Column<2, NScheme::NTypeIds::Uint64> { using Type = TLocalPathId; };
+        struct Config : Column<3, NScheme::NTypeIds::String> {};
+        struct Version : Column<4, NScheme::NTypeIds::Uint64> {};
 
         using TKey = TableKey<OwnerPathId, LocalPathId>;
         using TColumns = TableColumns<OwnerPathId, LocalPathId, Config, Version>;
     };
 
     struct AdoptedShards : Table<31> {
-        struct ShardIdx:     Column<1, NScheme::NTypeIds::Uint64> { using Type = TLocalShardIdx; };
-        struct PrevOwner:    Column<2, NScheme::NTypeIds::Uint64> {};
-        struct PrevShardIdx: Column<3, NScheme::NTypeIds::Uint64> { using Type = TLocalShardIdx; };
-        struct TabletId :    Column<4, NScheme::NTypeIds::Uint64> { using Type = TTabletId; };
+        struct ShardIdx : Column<1, NScheme::NTypeIds::Uint64> { using Type = TLocalShardIdx; };
+        struct PrevOwner : Column<2, NScheme::NTypeIds::Uint64> {};
+        struct PrevShardIdx : Column<3, NScheme::NTypeIds::Uint64> { using Type = TLocalShardIdx; };
+        struct TabletId : Column<4, NScheme::NTypeIds::Uint64> { using Type = TTabletId; };
 
         using TKey = TableKey<ShardIdx>;
         using TColumns = TableColumns<ShardIdx, PrevOwner, PrevShardIdx, TabletId>;
     };
 
     struct UserAttributes : Table<36> {
-        struct PathId:     Column<1, NScheme::NTypeIds::Uint64> {};
-        struct AttrName:   Column<2, NScheme::NTypeIds::Utf8> {};
-        struct AttrValue:  Column<3, NScheme::NTypeIds::Utf8> {};
+        struct PathId : Column<1, NScheme::NTypeIds::Uint64> {};
+        struct AttrName : Column<2, NScheme::NTypeIds::Utf8> {};
+        struct AttrValue : Column<3, NScheme::NTypeIds::Utf8> {};
 
         using TKey = TableKey<PathId, AttrName>;
         using TColumns = TableColumns<PathId, AttrName, AttrValue>;
     };
 
     struct MigratedUserAttributes : Table<51> {
-        struct OwnerPathId :  Column<1, NScheme::NTypeIds::Uint64> { using Type = TOwnerId;};
-        struct LocalPathId :  Column<2, NScheme::NTypeIds::Uint64> { using Type = TLocalPathId;};
-        struct AttrName:      Column<3, NScheme::NTypeIds::Utf8> {};
-        struct AttrValue:     Column<4, NScheme::NTypeIds::Utf8> {};
+        struct OwnerPathId : Column<1, NScheme::NTypeIds::Uint64> { using Type = TOwnerId; };
+        struct LocalPathId : Column<2, NScheme::NTypeIds::Uint64> { using Type = TLocalPathId; };
+        struct AttrName : Column<3, NScheme::NTypeIds::Utf8> {};
+        struct AttrValue : Column<4, NScheme::NTypeIds::Utf8> {};
 
         using TKey = TableKey<OwnerPathId, LocalPathId, AttrName>;
         using TColumns = TableColumns<OwnerPathId, LocalPathId, AttrName, AttrValue>;
     };
 
     struct UserAttributesAlterData : Table<37> {
-        struct PathId:     Column<1, NScheme::NTypeIds::Uint64> {};
-        struct AttrName:   Column<2, NScheme::NTypeIds::Utf8> {};
-        struct AttrValue:  Column<3, NScheme::NTypeIds::Utf8> {};
+        struct PathId : Column<1, NScheme::NTypeIds::Uint64> {};
+        struct AttrName : Column<2, NScheme::NTypeIds::Utf8> {};
+        struct AttrValue : Column<3, NScheme::NTypeIds::Utf8> {};
 
         using TKey = TableKey<PathId, AttrName>;
         using TColumns = TableColumns<PathId, AttrName, AttrValue>;
     };
 
     struct MigratedUserAttributesAlterData : Table<62> {
-        struct OwnerPathId :  Column<1, NScheme::NTypeIds::Uint64> { using Type = TOwnerId;};
-        struct LocalPathId :  Column<2, NScheme::NTypeIds::Uint64> { using Type = TLocalPathId;};
-        struct AttrName:      Column<3, NScheme::NTypeIds::Utf8> {};
-        struct AttrValue:     Column<4, NScheme::NTypeIds::Utf8> {};
+        struct OwnerPathId : Column<1, NScheme::NTypeIds::Uint64> { using Type = TOwnerId; };
+        struct LocalPathId : Column<2, NScheme::NTypeIds::Uint64> { using Type = TLocalPathId; };
+        struct AttrName : Column<3, NScheme::NTypeIds::Utf8> {};
+        struct AttrValue : Column<4, NScheme::NTypeIds::Utf8> {};
 
         using TKey = TableKey<OwnerPathId, LocalPathId, AttrName>;
         using TColumns = TableColumns<OwnerPathId, LocalPathId, AttrName, AttrValue>;
@@ -975,19 +963,19 @@ struct Schema : NIceDb::Schema {
     struct TableIndex : Table<38> {
         struct PathId :         Column<1, NScheme::NTypeIds::Uint64> {};
         struct AlterVersion :   Column<3, NScheme::NTypeIds::Uint64> {};
-        struct IndexType :      Column<4, NScheme::NTypeIds::Uint32> {using Type = NKikimrSchemeOp::EIndexType; static constexpr Type Default = NKikimrSchemeOp::EIndexTypeInvalid;};
-        struct State :          Column<5, NScheme::NTypeIds::Uint32> {using Type = NKikimrSchemeOp::EIndexState; static constexpr Type Default = NKikimrSchemeOp::EIndexStateInvalid;};
+        struct IndexType :      Column<4, NScheme::NTypeIds::Uint32> { using Type = NKikimrSchemeOp::EIndexType; static constexpr Type Default = NKikimrSchemeOp::EIndexTypeInvalid; };
+        struct State :          Column<5, NScheme::NTypeIds::Uint32> { using Type = NKikimrSchemeOp::EIndexState; static constexpr Type Default = NKikimrSchemeOp::EIndexStateInvalid; };
 
         using TKey = TableKey<PathId>;
         using TColumns = TableColumns<PathId, AlterVersion, IndexType, State>;
     };
 
     struct MigratedTableIndex : Table<67> {
-        struct OwnerPathId :    Column<1, NScheme::NTypeIds::Uint64> { using Type = TOwnerId;};
-        struct LocalPathId :    Column<2, NScheme::NTypeIds::Uint64> { using Type = TLocalPathId;};
+        struct OwnerPathId :    Column<1, NScheme::NTypeIds::Uint64> { using Type = TOwnerId; };
+        struct LocalPathId :    Column<2, NScheme::NTypeIds::Uint64> { using Type = TLocalPathId; };
         struct AlterVersion :   Column<3, NScheme::NTypeIds::Uint64> {};
-        struct IndexType :      Column<4, NScheme::NTypeIds::Uint32> {using Type = NKikimrSchemeOp::EIndexType; static constexpr Type Default = NKikimrSchemeOp::EIndexTypeInvalid;};
-        struct State :          Column<5, NScheme::NTypeIds::Uint32> {using Type = NKikimrSchemeOp::EIndexState; static constexpr Type Default = NKikimrSchemeOp::EIndexStateInvalid;};
+        struct IndexType :      Column<4, NScheme::NTypeIds::Uint32> { using Type = NKikimrSchemeOp::EIndexType; static constexpr Type Default = NKikimrSchemeOp::EIndexTypeInvalid; };
+        struct State :          Column<5, NScheme::NTypeIds::Uint32> { using Type = NKikimrSchemeOp::EIndexState; static constexpr Type Default = NKikimrSchemeOp::EIndexStateInvalid; };
 
         using TKey = TableKey<OwnerPathId, LocalPathId>;
         using TColumns = TableColumns<OwnerPathId, LocalPathId, AlterVersion, IndexType, State>;
@@ -996,8 +984,8 @@ struct Schema : NIceDb::Schema {
     struct TableIndexAlterData : Table<39> {
         struct PathId :         Column<1, NScheme::NTypeIds::Uint64> {};
         struct AlterVersion :   Column<3, NScheme::NTypeIds::Uint64> {};
-        struct IndexType :      Column<4, NScheme::NTypeIds::Uint32> {using Type = NKikimrSchemeOp::EIndexType; static constexpr Type Default = NKikimrSchemeOp::EIndexTypeInvalid;};
-        struct State :          Column<5, NScheme::NTypeIds::Uint32> {using Type = NKikimrSchemeOp::EIndexState; static constexpr Type Default = NKikimrSchemeOp::EIndexStateInvalid;};
+        struct IndexType :      Column<4, NScheme::NTypeIds::Uint32> { using Type = NKikimrSchemeOp::EIndexType; static constexpr Type Default = NKikimrSchemeOp::EIndexTypeInvalid; };
+        struct State :          Column<5, NScheme::NTypeIds::Uint32> { using Type = NKikimrSchemeOp::EIndexState; static constexpr Type Default = NKikimrSchemeOp::EIndexStateInvalid; };
 
         using TKey = TableKey<PathId>;
         using TColumns = TableColumns<PathId, AlterVersion, IndexType, State>;
@@ -1012,9 +1000,9 @@ struct Schema : NIceDb::Schema {
         using TColumns = TableColumns<PathId, KeyId, KeyName>;
     };
 
-    struct MigratedTableIndexKeys: Table<68> {
-        struct OwnerPathId :  Column<1, NScheme::NTypeIds::Uint64> { using Type = TOwnerId;};
-        struct LocalPathId :  Column<2, NScheme::NTypeIds::Uint64> { using Type = TLocalPathId;};
+    struct MigratedTableIndexKeys : Table<68> {
+        struct OwnerPathId :  Column<1, NScheme::NTypeIds::Uint64> { using Type = TOwnerId; };
+        struct LocalPathId :  Column<2, NScheme::NTypeIds::Uint64> { using Type = TLocalPathId; };
         struct KeyId :        Column<3, NScheme::NTypeIds::Uint32> {};
         struct KeyName :      Column<4, NScheme::NTypeIds::Utf8> {};
 
@@ -1032,23 +1020,22 @@ struct Schema : NIceDb::Schema {
     };
 
     struct TxInFlightV2 : Table<42> {
-        struct TxId :           Column<1, NScheme::NTypeIds::Uint64> { using Type = TTxId; };
-        struct TxPartId:        Column<2, NScheme::NTypeIds::Uint32> { using Type = TSubTxId; };
-
-        struct TxType :         Column<3, NScheme::NTypeIds::Byte>   {};
-        struct TargetPathId :   Column<4, NScheme::NTypeIds::Uint64> {};
-        struct State :          Column<5, NScheme::NTypeIds::Byte>   {};
-        struct MinStep :        Column<6, NScheme::NTypeIds::Uint64> { using Type = TStepId; };
-        struct ExtraBytes :     Column<7, NScheme::NTypeIds::String> {};
-        struct StartTime :      Column<8, NScheme::NTypeIds::Uint64> {};
-        struct DataTotalSize:   Column<9, NScheme::NTypeIds::Uint64> {};
-        struct CancelBackup:    Column<10, NScheme::NTypeIds::Bool>  {};
-        struct TargetOwnerPathId:    Column<11, NScheme::NTypeIds::Uint64> { using Type = TOwnerId; static constexpr Type Default = InvalidOwnerId;};
-        struct BuildIndexId:    Column<12, NScheme::NTypeIds::Uint64> { using Type = TTxId;};
-        struct SourceOwnerId:   Column<13, NScheme::NTypeIds::Uint64> { using Type = TOwnerId; static constexpr Type Default = InvalidOwnerId;};
-        struct SourceLocalPathId:    Column<14, NScheme::NTypeIds::Uint64> { using Type = TLocalPathId; static constexpr Type Default = InvalidLocalPathId;};
-        struct PlanStep:        Column<15, NScheme::NTypeIds::Uint64> { using Type = TStepId; };
-
+        struct TxId : Column<1, NScheme::NTypeIds::Uint64> { using Type = TTxId; };
+        struct TxPartId : Column<2, NScheme::NTypeIds::Uint32> { using Type = TSubTxId; };
+
+        struct TxType : Column<3, NScheme::NTypeIds::Byte>   {};
+        struct TargetPathId : Column<4, NScheme::NTypeIds::Uint64> {};
+        struct State : Column<5, NScheme::NTypeIds::Byte>   {};
+        struct MinStep : Column<6, NScheme::NTypeIds::Uint64> { using Type = TStepId; };
+        struct ExtraBytes : Column<7, NScheme::NTypeIds::String> {};
+        struct StartTime : Column<8, NScheme::NTypeIds::Uint64> {};
+        struct DataTotalSize : Column<9, NScheme::NTypeIds::Uint64> {};
+        struct CancelBackup : Column<10, NScheme::NTypeIds::Bool>  {};
+        struct TargetOwnerPathId : Column<11, NScheme::NTypeIds::Uint64> { using Type = TOwnerId; static constexpr Type Default = InvalidOwnerId; };
+        struct BuildIndexId : Column<12, NScheme::NTypeIds::Uint64> { using Type = TTxId; };
+        struct SourceOwnerId : Column<13, NScheme::NTypeIds::Uint64> { using Type = TOwnerId; static constexpr Type Default = InvalidOwnerId; };
+        struct SourceLocalPathId : Column<14, NScheme::NTypeIds::Uint64> { using Type = TLocalPathId; static constexpr Type Default = InvalidLocalPathId; };
+        struct PlanStep : Column<15, NScheme::NTypeIds::Uint64> { using Type = TStepId; };
 
         using TKey = TableKey<TxId, TxPartId>;
         using TColumns = TableColumns<
@@ -1067,7 +1054,7 @@ struct Schema : NIceDb::Schema {
             SourceOwnerId,
             SourceLocalPathId,
             PlanStep
-            >;
+        >;
     };
 
     struct TxDependenciesV2 : Table<43> { // has dieded before release
@@ -1104,21 +1091,20 @@ struct Schema : NIceDb::Schema {
     };
 
     struct Exports : Table<45> {
-        struct Id: Column<1, NScheme::NTypeIds::Uint64> {};
-        struct Uid: Column<2, NScheme::NTypeIds::Utf8> {};
-        struct Kind: Column<12, NScheme::NTypeIds::Byte> {};
-        struct Settings: Column<3, NScheme::NTypeIds::String> {};
-        struct DomainPathId: Column<4, NScheme::NTypeIds::Uint64> {};
+        struct Id : Column<1, NScheme::NTypeIds::Uint64> {};
+        struct Uid : Column<2, NScheme::NTypeIds::Utf8> {};
+        struct Kind : Column<12, NScheme::NTypeIds::Byte> {};
+        struct Settings : Column<3, NScheme::NTypeIds::String> {};
+        struct DomainPathId : Column<4, NScheme::NTypeIds::Uint64> {};
         struct UserSID : Column<13, NScheme::NTypeIds::Utf8> {};
-        struct Items: Column<5, NScheme::NTypeIds::Uint32> {};
-
-        struct ExportPathId: Column<6, NScheme::NTypeIds::Uint64> {using Type = TLocalPathId;};
-        struct State: Column<7, NScheme::NTypeIds::Byte> {};
-        struct WaitTxId: Column<8, NScheme::NTypeIds::Uint64> { using Type = TTxId; };
-        struct Issue: Column<9, NScheme::NTypeIds::Utf8> {};
-        struct ExportOwnerPathId: Column<10, NScheme::NTypeIds::Uint64> {using Type = TOwnerId;};
-        struct DomainPathOwnerId: Column<11, NScheme::NTypeIds::Uint64> {using Type = TOwnerId;};
+        struct Items : Column<5, NScheme::NTypeIds::Uint32> {};
 
+        struct ExportPathId : Column<6, NScheme::NTypeIds::Uint64> { using Type = TLocalPathId; };
+        struct State : Column<7, NScheme::NTypeIds::Byte> {};
+        struct WaitTxId : Column<8, NScheme::NTypeIds::Uint64> { using Type = TTxId; };
+        struct Issue : Column<9, NScheme::NTypeIds::Utf8> {};
+        struct ExportOwnerPathId : Column<10, NScheme::NTypeIds::Uint64> { using Type = TOwnerId; };
+        struct DomainPathOwnerId : Column<11, NScheme::NTypeIds::Uint64> { using Type = TOwnerId; };
 
         using TKey = TableKey<Id>;
         using TColumns = TableColumns<
@@ -1139,15 +1125,15 @@ struct Schema : NIceDb::Schema {
     };
 
     struct ExportItems : Table<46> {
-        struct ExportId: Column<1, NScheme::NTypeIds::Uint64> {};
-        struct Index: Column<2, NScheme::NTypeIds::Uint32> {};
-        struct SourcePathName: Column<3, NScheme::NTypeIds::Utf8> {};
-        struct SourcePathId: Column<4, NScheme::NTypeIds::Uint64> {using Type = TLocalPathId;};
+        struct ExportId : Column<1, NScheme::NTypeIds::Uint64> {};
+        struct Index : Column<2, NScheme::NTypeIds::Uint32> {};
+        struct SourcePathName : Column<3, NScheme::NTypeIds::Utf8> {};
+        struct SourcePathId : Column<4, NScheme::NTypeIds::Uint64> { using Type = TLocalPathId; };
 
-        struct State: Column<5, NScheme::NTypeIds::Byte> {};
-        struct BackupTxId: Column<6, NScheme::NTypeIds::Uint64> { using Type = TTxId; };
-        struct Issue: Column<7, NScheme::NTypeIds::Utf8> {};
-        struct SourceOwnerPathId: Column<8, NScheme::NTypeIds::Uint64> {using Type = TOwnerId;};
+        struct State : Column<5, NScheme::NTypeIds::Byte> {};
+        struct BackupTxId : Column<6, NScheme::NTypeIds::Uint64> { using Type = TTxId; };
+        struct Issue : Column<7, NScheme::NTypeIds::Utf8> {};
+        struct SourceOwnerPathId : Column<8, NScheme::NTypeIds::Uint64> { using Type = TOwnerId; };
 
         using TKey = TableKey<ExportId, Index>;
         using TColumns = TableColumns<
@@ -1169,19 +1155,21 @@ struct Schema : NIceDb::Schema {
         using TKey = TableKey<ShardIdx>;
         using TColumns = TableColumns<
             ShardIdx,
-            PartitionConfig>;
+            PartitionConfig
+        >;
     };
 
     struct MigratedTableShardPartitionConfigs : Table<57> {
-        struct OwnerShardIdx :   Column<1, NScheme::NTypeIds::Uint64> { using Type = TOwnerId; };
-        struct LocalShardIdx :   Column<2, NScheme::NTypeIds::Uint64> { using Type = TLocalShardIdx; };
-
+        struct OwnerShardIdx : Column<1, NScheme::NTypeIds::Uint64> { using Type = TOwnerId; };
+        struct LocalShardIdx : Column<2, NScheme::NTypeIds::Uint64> { using Type = TLocalShardIdx; };
         struct PartitionConfig : Column<3, NScheme::NTypeIds::String> {};
 
         using TKey = TableKey<OwnerShardIdx, LocalShardIdx>;
         using TColumns = TableColumns<
-            OwnerShardIdx, LocalShardIdx,
-            PartitionConfig>;
+            OwnerShardIdx,
+            LocalShardIdx,
+            PartitionConfig
+        >;
     };
 
     struct PublishingPaths : Table<48> {
@@ -1204,8 +1192,8 @@ struct Schema : NIceDb::Schema {
     };
 
     struct FillIndexDesc : Table<49> { // DEPRECATED, left only for forbidding reuse table Id 49
-        struct PathId: Column<1, NScheme::NTypeIds::Uint64> {};
-        struct Body: Column<2,  NScheme::NTypeIds::String> {};
+        struct PathId : Column<1, NScheme::NTypeIds::Uint64> {};
+        struct Body : Column<2,  NScheme::NTypeIds::String> {};
 
         using TKey = TableKey<PathId>;
         using TColumns = TableColumns<PathId, Body>;
@@ -1215,54 +1203,53 @@ struct Schema : NIceDb::Schema {
 
     struct RevertedMigrations : Table<58> {
         // it is only because we need to manage undo of upgrade subdomain, finally remove it
-        struct LocalPathId:    Column<1, NScheme::NTypeIds::Uint64> {};
-        struct SchemeShardId : Column<2, NScheme::NTypeIds::Uint64> { using Type = TTabletId;};
+        struct LocalPathId : Column<1, NScheme::NTypeIds::Uint64> {};
+        struct SchemeShardId : Column<2, NScheme::NTypeIds::Uint64> { using Type = TTabletId; };
 
         using TKey = TableKey<LocalPathId, SchemeShardId>;
         using TColumns = TableColumns<LocalPathId, SchemeShardId>;
     };
 
     struct IndexBuild : Table<69> {
-        struct Id:               Column<1, NScheme::NTypeIds::Uint64> {using Type = TIndexBuildId;};
-        struct Uid:              Column<2, NScheme::NTypeIds::Utf8> {};
-
-        struct DomainOwnerId:    Column<3, NScheme::NTypeIds::Uint64> {using Type = TOwnerId;};
-        struct DomainLocalId:    Column<4, NScheme::NTypeIds::Uint64> {using Type = TLocalPathId;};
-        struct TableOwnerId:     Column<5, NScheme::NTypeIds::Uint64> {using Type = TOwnerId;};
-        struct TableLocalId:     Column<6, NScheme::NTypeIds::Uint64> {using Type = TLocalPathId;};
-        struct IndexName:        Column<7, NScheme::NTypeIds::Utf8> {};
-        struct IndexType:        Column<8, NScheme::NTypeIds::Uint32> {using Type = NKikimrSchemeOp::EIndexType;};
+        struct Id : Column<1, NScheme::NTypeIds::Uint64> { using Type = TIndexBuildId; };
+        struct Uid : Column<2, NScheme::NTypeIds::Utf8> {};
 
-        struct State:            Column<9, NScheme::NTypeIds::Uint32> {};
-        struct Issue:            Column<10, NScheme::NTypeIds::Utf8> {};
+        struct DomainOwnerId : Column<3, NScheme::NTypeIds::Uint64> { using Type = TOwnerId; };
+        struct DomainLocalId : Column<4, NScheme::NTypeIds::Uint64> { using Type = TLocalPathId; };
+        struct TableOwnerId : Column<5, NScheme::NTypeIds::Uint64> { using Type = TOwnerId; };
+        struct TableLocalId : Column<6, NScheme::NTypeIds::Uint64> { using Type = TLocalPathId; };
+        struct IndexName : Column<7, NScheme::NTypeIds::Utf8> {};
+        struct IndexType : Column<8, NScheme::NTypeIds::Uint32> { using Type = NKikimrSchemeOp::EIndexType; };
 
-        struct InitiateTxId:     Column<11, NScheme::NTypeIds::Uint64> {using Type = TTxId;};
-        struct InitiateTxStatus: Column<12, NScheme::NTypeIds::Uint32> {using Type = NKikimrScheme::EStatus;};
-        struct InitiateTxDone:   Column<13, NScheme::NTypeIds::Bool> {};
+        struct State : Column<9, NScheme::NTypeIds::Uint32> {};
+        struct Issue : Column<10, NScheme::NTypeIds::Utf8> {};
 
-        struct LockTxId:         Column<14, NScheme::NTypeIds::Uint64> {using Type = TTxId;};
-        struct LockTxStatus:     Column<15, NScheme::NTypeIds::Uint32> {using Type = NKikimrScheme::EStatus;};
-        struct LockTxDone:       Column<16, NScheme::NTypeIds::Bool> {};
+        struct InitiateTxId : Column<11, NScheme::NTypeIds::Uint64> { using Type = TTxId; };
+        struct InitiateTxStatus : Column<12, NScheme::NTypeIds::Uint32> { using Type = NKikimrScheme::EStatus; };
+        struct InitiateTxDone : Column<13, NScheme::NTypeIds::Bool> {};
 
-        struct MaxBatchRows:     Column<17, NScheme::NTypeIds::Uint32> {};
-        struct MaxBatchBytes:    Column<18, NScheme::NTypeIds::Uint64> {};
-        struct MaxShards:        Column<19, NScheme::NTypeIds::Uint32> {};
+        struct LockTxId : Column<14, NScheme::NTypeIds::Uint64> { using Type = TTxId; };
+        struct LockTxStatus : Column<15, NScheme::NTypeIds::Uint32> { using Type = NKikimrScheme::EStatus; };
+        struct LockTxDone : Column<16, NScheme::NTypeIds::Bool> {};
 
-        struct ApplyTxId:        Column<20, NScheme::NTypeIds::Uint64> {using Type = TTxId;};
-        struct ApplyTxStatus:    Column<21, NScheme::NTypeIds::Uint32> {using Type = NKikimrScheme::EStatus;};
-        struct ApplyTxDone:      Column<22, NScheme::NTypeIds::Bool> {};
+        struct MaxBatchRows : Column<17, NScheme::NTypeIds::Uint32> {};
+        struct MaxBatchBytes : Column<18, NScheme::NTypeIds::Uint64> {};
+        struct MaxShards : Column<19, NScheme::NTypeIds::Uint32> {};
 
+        struct ApplyTxId : Column<20, NScheme::NTypeIds::Uint64> { using Type = TTxId; };
+        struct ApplyTxStatus : Column<21, NScheme::NTypeIds::Uint32> { using Type = NKikimrScheme::EStatus; };
+        struct ApplyTxDone : Column<22, NScheme::NTypeIds::Bool> {};
 
-        struct UnlockTxId:        Column<23, NScheme::NTypeIds::Uint64> {using Type = TTxId;};
-        struct UnlockTxStatus:    Column<24, NScheme::NTypeIds::Uint32> {using Type = NKikimrScheme::EStatus;};
-        struct UnlockTxDone:      Column<25, NScheme::NTypeIds::Bool> {};
+        struct UnlockTxId : Column<23, NScheme::NTypeIds::Uint64> { using Type = TTxId; };
+        struct UnlockTxStatus : Column<24, NScheme::NTypeIds::Uint32> { using Type = NKikimrScheme::EStatus; };
+        struct UnlockTxDone : Column<25, NScheme::NTypeIds::Bool> {};
 
-        struct CancelRequest:     Column<26, NScheme::NTypeIds::Bool> {};
+        struct CancelRequest : Column<26, NScheme::NTypeIds::Bool> {};
 
-        struct MaxRetries:        Column<27, NScheme::NTypeIds::Uint32> {};
+        struct MaxRetries : Column<27, NScheme::NTypeIds::Uint32> {};
 
-        struct RowsBilled:        Column<28, NScheme::NTypeIds::Uint64> {};
-        struct BytesBilled:       Column<29, NScheme::NTypeIds::Uint64> {};
+        struct RowsBilled : Column<28, NScheme::NTypeIds::Uint64> {};
+        struct BytesBilled : Column<29, NScheme::NTypeIds::Uint64> {};
 
         using TKey = TableKey<Id>;
         using TColumns = TableColumns<
@@ -1295,14 +1282,14 @@ struct Schema : NIceDb::Schema {
             MaxRetries,
             RowsBilled,
             BytesBilled
-            >;
+        >;
     };
 
     struct IndexBuildColumns : Table<70> {
-        struct Id:         Column<1, NScheme::NTypeIds::Uint64> {using Type = TIndexBuildId;};
-        struct ColumnNo:   Column<2, NScheme::NTypeIds::Uint32> {};
-        struct ColumnName: Column<3, NScheme::NTypeIds::Utf8> {};
-        struct ColumnKind: Column<4, NScheme::NTypeIds::Uint8> {using Type = EIndexColumnKind;};
+        struct Id : Column<1, NScheme::NTypeIds::Uint64> { using Type = TIndexBuildId; };
+        struct ColumnNo : Column<2, NScheme::NTypeIds::Uint32> {};
+        struct ColumnName : Column<3, NScheme::NTypeIds::Utf8> {};
+        struct ColumnKind : Column<4, NScheme::NTypeIds::Uint8> { using Type = EIndexColumnKind; };
 
         using TKey = TableKey<Id, ColumnNo>;
         using TColumns = TableColumns<
@@ -1310,62 +1297,60 @@ struct Schema : NIceDb::Schema {
             ColumnNo,
             ColumnName,
             ColumnKind
-            >;
+        >;
     };
 
     struct SnapshotTables : Table<71> {
-        struct Id:           Column<1, NScheme::NTypeIds::Uint64> {using Type = TTxId;};
-        struct TableOwnerId: Column<2, NScheme::NTypeIds::Uint64> {using Type = TOwnerId;};
-        struct TableLocalId: Column<3, NScheme::NTypeIds::Uint64> {using Type = TLocalPathId;};
-
+        struct Id : Column<1, NScheme::NTypeIds::Uint64> { using Type = TTxId; };
+        struct TableOwnerId : Column<2, NScheme::NTypeIds::Uint64> { using Type = TOwnerId; };
+        struct TableLocalId : Column<3, NScheme::NTypeIds::Uint64> { using Type = TLocalPathId; };
 
         using TKey = TableKey<Id, TableOwnerId, TableLocalId>;
         using TColumns = TableColumns<
             Id,
             TableOwnerId,
             TableLocalId
-            >;
+        >;
     };
 
     struct SnapshotSteps : Table<72> {
-        struct Id:     Column<1, NScheme::NTypeIds::Uint64> {using Type = TTxId;};
-        struct StepId: Column<2, NScheme::NTypeIds::Uint64> {using Type = TStepId;};
+        struct Id : Column<1, NScheme::NTypeIds::Uint64> { using Type = TTxId; };
+        struct StepId : Column<2, NScheme::NTypeIds::Uint64> { using Type = TStepId; };
 
         using TKey = TableKey<Id>;
         using TColumns = TableColumns<
             Id,
             StepId
-            >;
+        >;
     };
 
     struct LongLocks : Table<73> {
-        struct PathOwnerId: Column<1, NScheme::NTypeIds::Uint64> {using Type = TOwnerId;};
-        struct PathLocalId: Column<2, NScheme::NTypeIds::Uint64> {using Type = TLocalPathId;};
-        struct LockId:      Column<3, NScheme::NTypeIds::Uint64> {using Type = TTxId;};
-
+        struct PathOwnerId : Column<1, NScheme::NTypeIds::Uint64> { using Type = TOwnerId; };
+        struct PathLocalId : Column<2, NScheme::NTypeIds::Uint64> { using Type = TLocalPathId; };
+        struct LockId : Column<3, NScheme::NTypeIds::Uint64> { using Type = TTxId; };
 
         using TKey = TableKey<PathOwnerId, PathLocalId>;
         using TColumns = TableColumns<
             PathOwnerId,
             PathLocalId,
             LockId
-            >;
+        >;
     };
 
     struct IndexBuildShardStatus : Table<74> {
-        struct Id:            Column<1, NScheme::NTypeIds::Uint64> {using Type = TIndexBuildId;};
-        struct OwnerShardIdx: Column<2, NScheme::NTypeIds::Uint64> {using Type = TOwnerId;};
-        struct LocalShardIdx: Column<3, NScheme::NTypeIds::Uint64> {using Type = TLocalShardIdx;};
+        struct Id : Column<1, NScheme::NTypeIds::Uint64> { using Type = TIndexBuildId; };
+        struct OwnerShardIdx : Column<2, NScheme::NTypeIds::Uint64> { using Type = TOwnerId; };
+        struct LocalShardIdx : Column<3, NScheme::NTypeIds::Uint64> { using Type = TLocalShardIdx; };
 
-        struct Range :        Column<4, NScheme::NTypeIds::String> {using Type = NKikimrTx::TKeyRange;};
-        struct LastKeyAck :   Column<5, NScheme::NTypeIds::String> {using Type = TString;};
+        struct Range : Column<4, NScheme::NTypeIds::String> { using Type = NKikimrTx::TKeyRange; };
+        struct LastKeyAck : Column<5, NScheme::NTypeIds::String> { using Type = TString; };
 
-        struct Status:        Column<6, NScheme::NTypeIds::Uint32> {using Type = NKikimrTxDataShard::TEvBuildIndexProgressResponse::EStatus;};
-        struct Message:       Column<7, NScheme::NTypeIds::Utf8> {};
-        struct UploadStatus:  Column<8, NScheme::NTypeIds::Uint32> {using Type = Ydb::StatusIds::StatusCode;};
+        struct Status : Column<6, NScheme::NTypeIds::Uint32> { using Type = NKikimrTxDataShard::TEvBuildIndexProgressResponse::EStatus; };
+        struct Message : Column<7, NScheme::NTypeIds::Utf8> {};
+        struct UploadStatus : Column<8, NScheme::NTypeIds::Uint32> { using Type = Ydb::StatusIds::StatusCode; };
 
-        struct RowsProcessed:  Column<9, NScheme::NTypeIds::Uint64> {};
-        struct BytesProcessed:  Column<10, NScheme::NTypeIds::Uint64> {};
+        struct RowsProcessed : Column<9, NScheme::NTypeIds::Uint64> {};
+        struct BytesProcessed : Column<10, NScheme::NTypeIds::Uint64> {};
 
         using TKey = TableKey<Id, OwnerShardIdx, LocalShardIdx>;
         using TColumns = TableColumns<
@@ -1379,32 +1364,32 @@ struct Schema : NIceDb::Schema {
             UploadStatus,
             RowsProcessed,
             BytesProcessed
-            >;
+        >;
     };
 
     struct TableIndexDataColumns : Table<80> {
-        struct PathOwnerId:       Column<1, NScheme::NTypeIds::Uint64> {using Type = TOwnerId;};
-        struct PathLocalId:       Column<2, NScheme::NTypeIds::Uint64> {using Type = TLocalPathId;};
-        struct DataColumnId:      Column<3, NScheme::NTypeIds::Uint32> {};
-        struct DataColumnName:    Column<4, NScheme::NTypeIds::Utf8> {};
+        struct PathOwnerId : Column<1, NScheme::NTypeIds::Uint64> { using Type = TOwnerId; };
+        struct PathLocalId : Column<2, NScheme::NTypeIds::Uint64> { using Type = TLocalPathId; };
+        struct DataColumnId : Column<3, NScheme::NTypeIds::Uint32> {};
+        struct DataColumnName : Column<4, NScheme::NTypeIds::Utf8> {};
 
         using TKey = TableKey<PathOwnerId, PathLocalId, DataColumnId>;
         using TColumns = TableColumns<PathOwnerId, PathLocalId, DataColumnId, DataColumnName>;
     };
 
     struct TableIndexDataColumnsAlterData : Table<81> {
-        struct PathOwnerId:       Column<1, NScheme::NTypeIds::Uint64> {using Type = TOwnerId;};
-        struct PathLocalId:       Column<2, NScheme::NTypeIds::Uint64> {using Type = TLocalPathId;};
-        struct DataColumnId:      Column<3, NScheme::NTypeIds::Uint32> {};
-        struct DataColumnName:    Column<4, NScheme::NTypeIds::Utf8> {};
+        struct PathOwnerId : Column<1, NScheme::NTypeIds::Uint64> { using Type = TOwnerId; };
+        struct PathLocalId : Column<2, NScheme::NTypeIds::Uint64> { using Type = TLocalPathId; };
+        struct DataColumnId : Column<3, NScheme::NTypeIds::Uint32> {};
+        struct DataColumnName : Column<4, NScheme::NTypeIds::Utf8> {};
 
         using TKey = TableKey<PathOwnerId, PathLocalId, DataColumnId>;
         using TColumns = TableColumns<PathOwnerId, PathLocalId, DataColumnId, DataColumnName>;
     };
 
     struct RestoreTasks : Table<82> {
-        struct OwnerPathId : Column<1, NScheme::NTypeIds::Uint64> { using Type = TOwnerId;};
-        struct LocalPathId : Column<2, NScheme::NTypeIds::Uint64> { using Type = TLocalPathId;};
+        struct OwnerPathId : Column<1, NScheme::NTypeIds::Uint64> { using Type = TOwnerId; };
+        struct LocalPathId : Column<2, NScheme::NTypeIds::Uint64> { using Type = TLocalPathId; };
         struct Task : Column<3, NScheme::NTypeIds::String> {};
 
         using TKey = TableKey<OwnerPathId, LocalPathId>;
@@ -1736,4 +1721,3 @@ struct Schema : NIceDb::Schema {
 };
 
 }
-}