diff --git a/ydb/core/protos/tx_columnshard.proto b/ydb/core/protos/tx_columnshard.proto
index 0ffad0993f03..9b740474838e 100644
--- a/ydb/core/protos/tx_columnshard.proto
+++ b/ydb/core/protos/tx_columnshard.proto
@@ -348,4 +348,5 @@ message TInternalOperationData {
     optional uint32 ModificationType = 2;
     optional uint64 PathId = 3;
     optional bool WritePortions = 4;
+    //optional uint64 LocalPathId = 5;
 }
diff --git a/ydb/core/sys_view/common/schema.cpp b/ydb/core/sys_view/common/schema.cpp
index 1d449bbcad73..5315ce149bff 100644
--- a/ydb/core/sys_view/common/schema.cpp
+++ b/ydb/core/sys_view/common/schema.cpp
@@ -290,6 +290,7 @@ class TSystemViewResolver : public ISystemViewResolver {
         RegisterColumnTableSystemView<Schema::PrimaryIndexPortionStats>(TablePrimaryIndexPortionStatsName);
         RegisterColumnTableSystemView<Schema::PrimaryIndexGranuleStats>(TablePrimaryIndexGranuleStatsName);
         RegisterColumnTableSystemView<Schema::PrimaryIndexOptimizerStats>(TablePrimaryIndexOptimizerStatsName);
+        RegisterColumnTableSystemView<Schema::TablePathIdMapping>(TablePathIdMappingName);
 
         RegisterSystemView<Schema::TopPartitions>(TopPartitionsByCpu1MinuteName);
         RegisterSystemView<Schema::TopPartitions>(TopPartitionsByCpu1HourName);
diff --git a/ydb/core/sys_view/common/schema.h b/ydb/core/sys_view/common/schema.h
index e133fc5f1366..5af33f7ebd8a 100644
--- a/ydb/core/sys_view/common/schema.h
+++ b/ydb/core/sys_view/common/schema.h
@@ -42,6 +42,7 @@ constexpr TStringBuf TablePrimaryIndexStatsName = "primary_index_stats";
 constexpr TStringBuf TablePrimaryIndexPortionStatsName = "primary_index_portion_stats";
 constexpr TStringBuf TablePrimaryIndexGranuleStatsName = "primary_index_granule_stats";
 constexpr TStringBuf TablePrimaryIndexOptimizerStatsName = "primary_index_optimizer_stats";
+constexpr TStringBuf TablePathIdMappingName = "table_path_id_mapping";
 
 constexpr TStringBuf TopPartitionsByCpu1MinuteName = "top_partitions_one_minute";
 constexpr TStringBuf TopPartitionsByCpu1HourName = "top_partitions_one_hour";
@@ -797,6 +798,14 @@ struct Schema : NIceDb::Schema {
             IndexSize,
             FollowerId>;
     };
+    struct TablePathIdMapping: Table<23> {
+        struct InternalPathId: Column<1, NScheme::NTypeIds::Uint64> {};
+        struct TabletId: Column<2, NScheme::NTypeIds::Uint64> {};
+        struct LocalPathId: Column<3, NScheme::NTypeIds::Uint64> {};
+
+        using TKey = TableKey<InternalPathId, TabletId>;
+        using TColumns = TableColumns<InternalPathId, TabletId, LocalPathId>;
+    };
 };
 
 bool MaybeSystemViewPath(const TVector<TString>& path);
diff --git a/ydb/core/tx/columnshard/background_controller.cpp b/ydb/core/tx/columnshard/background_controller.cpp
index 1a26f8ed32f7..0e626e433f3e 100644
--- a/ydb/core/tx/columnshard/background_controller.cpp
+++ b/ydb/core/tx/columnshard/background_controller.cpp
@@ -4,9 +4,9 @@
 namespace NKikimr::NColumnShard {
 
 bool TBackgroundController::StartCompaction(const NOlap::TPlanCompactionInfo& info) {
-    auto it = ActiveCompactionInfo.find(info.GetPathId());
+    auto it = ActiveCompactionInfo.find(info.GetPathId().GetInternalPathId());
     if (it == ActiveCompactionInfo.end()) {
-        it = ActiveCompactionInfo.emplace(info.GetPathId(), info.GetPathId()).first;
+        it = ActiveCompactionInfo.emplace(info.GetPathId().GetInternalPathId(), info.GetPathId()).first;
     }
     it->second.Start();
     return true;
diff --git a/ydb/core/tx/columnshard/background_controller.h b/ydb/core/tx/columnshard/background_controller.h
index fad6527fb56f..cb38613ddc55 100644
--- a/ydb/core/tx/columnshard/background_controller.h
+++ b/ydb/core/tx/columnshard/background_controller.h
@@ -49,12 +49,12 @@ class TBackgroundController {
 
     bool StartCompaction(const NOlap::TPlanCompactionInfo& info);
     void FinishCompaction(const NOlap::TPlanCompactionInfo& info) {
-        auto it = ActiveCompactionInfo.find(info.GetPathId());
+        auto it = ActiveCompactionInfo.find(info.GetPathId().GetInternalPathId());
         AFL_VERIFY(it != ActiveCompactionInfo.end());
         if (it->second.Finish()) {
             ActiveCompactionInfo.erase(it);
         }
-        Counters->OnCompactionFinish(info.GetPathId());
+        Counters->OnCompactionFinish(info.GetPathId().GetLocalPathId());
     }
     ui32 GetCompactionsCount() const {
         return ActiveCompactionInfo.size();
diff --git a/ydb/core/tx/columnshard/blobs_action/transaction/tx_blobs_written.cpp b/ydb/core/tx/columnshard/blobs_action/transaction/tx_blobs_written.cpp
index cd7feae239d9..63e8f836b17c 100644
--- a/ydb/core/tx/columnshard/blobs_action/transaction/tx_blobs_written.cpp
+++ b/ydb/core/tx/columnshard/blobs_action/transaction/tx_blobs_written.cpp
@@ -57,7 +57,7 @@ bool TTxBlobsWritingFinished::DoExecute(TTransactionContext& txc, const TActorCo
         if (!operationIds.emplace(operation->GetWriteId()).second) {
             continue;
         }
-        AFL_VERIFY(Self->TablesManager.IsReadyForFinishWrite(writeMeta.GetTableId(), minReadSnapshot));
+        AFL_VERIFY(Self->TablesManager.IsReadyForFinishWrite(writeMeta.GetPathId(), minReadSnapshot));
         Y_ABORT_UNLESS(operation->GetStatus() == EOperationStatus::Started);
         if (operation->GetBehaviour() == EOperationBehaviour::NoTxWrite) {
             operation->OnWriteFinish(txc, {}, true);
@@ -75,7 +75,7 @@ bool TTxBlobsWritingFinished::DoExecute(TTransactionContext& txc, const TActorCo
             lock.SetDataShard(Self->TabletID());
             lock.SetGeneration(info.GetGeneration());
             lock.SetCounter(info.GetInternalGenerationCounter());
-            lock.SetPathId(writeMeta.GetTableId().GetRawValue());
+            lock.SetPathId(writeMeta.GetPathId().GetInternalPathId().GetRawValue());
             auto ev = NEvents::TDataEvents::TEvWriteResult::BuildCompleted(Self->TabletID(), operation->GetLockId(), lock);
             Results.emplace_back(std::move(ev), writeMeta.GetSource(), operation->GetCookie());
         }
@@ -103,11 +103,11 @@ void TTxBlobsWritingFinished::DoComplete(const TActorContext& ctx) {
             continue;
         }
         auto op = Self->GetOperationsManager().GetOperationVerified((TOperationWriteId)writeMeta.GetWriteId());
-        pathIds.emplace(op->GetPathId());
+        pathIds.emplace(op->GetPathId().GetInternalPathId());
         if (op->GetBehaviour() == EOperationBehaviour::WriteWithLock || op->GetBehaviour() == EOperationBehaviour::NoTxWrite) {
-            if (op->GetBehaviour() != EOperationBehaviour::NoTxWrite || Self->GetOperationsManager().HasReadLocks(writeMeta.GetTableId())) {
+            if (op->GetBehaviour() != EOperationBehaviour::NoTxWrite || Self->GetOperationsManager().HasReadLocks(writeMeta.GetPathId().GetInternalPathId())) {
                 auto evWrite = std::make_shared<NOlap::NTxInteractions::TEvWriteWriter>(
-                    writeMeta.GetTableId(), writeResult.GetPKBatchVerified(), Self->GetIndexOptional()->GetVersionedIndex().GetPrimaryKey());
+                    writeMeta.GetPathId().GetInternalPathId(), writeResult.GetPKBatchVerified(), Self->GetIndexOptional()->GetVersionedIndex().GetPrimaryKey());
                 Self->GetOperationsManager().AddEventForLock(*Self, op->GetLockId(), evWrite);
             }
         }
diff --git a/ydb/core/tx/columnshard/blobs_action/transaction/tx_write.cpp b/ydb/core/tx/columnshard/blobs_action/transaction/tx_write.cpp
index ceec2e1d6f79..e7bb97f92b86 100644
--- a/ydb/core/tx/columnshard/blobs_action/transaction/tx_write.cpp
+++ b/ydb/core/tx/columnshard/blobs_action/transaction/tx_write.cpp
@@ -43,7 +43,7 @@ bool TTxWrite::DoExecute(TTransactionContext& txc, const TActorContext&) {
     const auto minReadSnapshot = Self->GetMinReadSnapshot();
     for (auto&& aggr : buffer.GetAggregations()) {
         const auto& writeMeta = aggr->GetWriteMeta();
-        Y_ABORT_UNLESS(Self->TablesManager.IsReadyForFinishWrite(writeMeta.GetTableId(), minReadSnapshot));
+        Y_ABORT_UNLESS(Self->TablesManager.IsReadyForFinishWrite(writeMeta.GetPathId(), minReadSnapshot));
         txc.DB.NoMoreReadsForTx();
         TWriteOperation::TPtr operation;
         if (writeMeta.HasLongTxId()) {
@@ -105,14 +105,14 @@ bool TTxWrite::DoExecute(TTransactionContext& txc, const TActorContext&) {
                 lock.SetDataShard(Self->TabletID());
                 lock.SetGeneration(info.GetGeneration());
                 lock.SetCounter(info.GetInternalGenerationCounter());
-                lock.SetPathId(writeMeta.GetTableId().GetRawValue());
+                lock.SetPathId(writeMeta.GetPathId().GetInternalPathId().GetRawValue());
                 auto ev = NEvents::TDataEvents::TEvWriteResult::BuildCompleted(Self->TabletID(), operation->GetLockId(), lock);
                 Results.emplace_back(std::move(ev), writeMeta.GetSource(), operation->GetCookie());
             }
         } else {
             Y_ABORT_UNLESS(aggr->GetInsertWriteIds().size() == 1);
             auto ev = std::make_unique<TEvColumnShard::TEvWriteResult>(
-                Self->TabletID(), writeMeta, (ui64)aggr->GetInsertWriteIds().front(), NKikimrTxColumnShard::EResultStatus::SUCCESS);
+                Self->TabletID(), writeMeta.GetPathId().GetLocalPathId(), writeMeta.GetDedupId(), (ui64)aggr->GetInsertWriteIds().front(), NKikimrTxColumnShard::EResultStatus::SUCCESS);
             Results.emplace_back(std::move(ev), writeMeta.GetSource(), 0);
         }
     }
@@ -141,8 +141,8 @@ void TTxWrite::DoComplete(const TActorContext& ctx) {
         if (!writeMeta.HasLongTxId()) {
             auto op = Self->GetOperationsManager().GetOperationVerified((TOperationWriteId)writeMeta.GetWriteId());
             if (op->GetBehaviour() == EOperationBehaviour::WriteWithLock || op->GetBehaviour() == EOperationBehaviour::NoTxWrite) {
-                if (op->GetBehaviour() != EOperationBehaviour::NoTxWrite || Self->GetOperationsManager().HasReadLocks(writeMeta.GetTableId())) {
-                    auto evWrite = std::make_shared<NOlap::NTxInteractions::TEvWriteWriter>(writeMeta.GetTableId(),
+                if (op->GetBehaviour() != EOperationBehaviour::NoTxWrite || Self->GetOperationsManager().HasReadLocks(writeMeta.GetPathId().GetInternalPathId())) {
+                    auto evWrite = std::make_shared<NOlap::NTxInteractions::TEvWriteWriter>(writeMeta.GetPathId().GetInternalPathId(),
                         buffer.GetAggregations()[i]->GetRecordBatch(), Self->GetIndexOptional()->GetVersionedIndex().GetPrimaryKey());
                     Self->GetOperationsManager().AddEventForLock(*Self, op->GetLockId(), evWrite);
                 }
diff --git a/ydb/core/tx/columnshard/columnshard.cpp b/ydb/core/tx/columnshard/columnshard.cpp
index f3b3a37908a4..4556e4449a8f 100644
--- a/ydb/core/tx/columnshard/columnshard.cpp
+++ b/ydb/core/tx/columnshard/columnshard.cpp
@@ -406,29 +406,29 @@ void TColumnShard::FillOlapStats(const TActorContext& ctx, std::unique_ptr<TEvDa
 }
 
 void TColumnShard::FillColumnTableStats(const TActorContext& ctx, std::unique_ptr<TEvDataShard::TEvPeriodicTableStats>& ev) {
-    auto tables = TablesManager.GetTables();
     TTableStatsBuilder tableStatsBuilder(Counters, Executor());
-
-    LOG_S_DEBUG("There are stats for " << tables.size() << " tables");
-    for (const auto& [pathId, _] : tables) {
-        auto* periodicTableStats = ev->Record.AddTables();
-        periodicTableStats->SetDatashardId(TabletID());
-        periodicTableStats->SetTableLocalId(pathId.GetRawValue());
-
-        periodicTableStats->SetShardState(2);   // NKikimrTxDataShard.EDatashardState.Ready
-        periodicTableStats->SetGeneration(Executor()->Generation());
-        periodicTableStats->SetRound(StatsReportRound++);
-        periodicTableStats->SetNodeId(ctx.SelfID.NodeId());
-        periodicTableStats->SetStartTime(StartTime().MilliSeconds());
-
-        if (auto* resourceMetrics = Executor()->GetResourceMetrics()) {
-            resourceMetrics->Fill(*periodicTableStats->MutableTabletMetrics());
+    LOG_S_DEBUG("There are stats for " << TablesManager.GetTableCount() << " tables");
+    TablesManager.ForEachPathId(
+        [&](const TUnifiedPathId& pathId) {
+            auto* periodicTableStats = ev->Record.AddTables();
+            periodicTableStats->SetDatashardId(TabletID());
+            periodicTableStats->SetTableLocalId(pathId.GetLocalPathId().GetRawValue());
+
+            periodicTableStats->SetShardState(2);   // NKikimrTxDataShard.EDatashardState.Ready
+            periodicTableStats->SetGeneration(Executor()->Generation());
+            periodicTableStats->SetRound(StatsReportRound++);
+            periodicTableStats->SetNodeId(ctx.SelfID.NodeId());
+            periodicTableStats->SetStartTime(StartTime().MilliSeconds());
+
+            if (auto* resourceMetrics = Executor()->GetResourceMetrics()) {
+                resourceMetrics->Fill(*periodicTableStats->MutableTabletMetrics());
+            }
+
+            tableStatsBuilder.FillTableStats(pathId, *(periodicTableStats->MutableTableStats()));
+
+            LOG_S_TRACE("Add stats for table, tableLocalID=" << pathId.GetLocalPathId());
         }
-
-        tableStatsBuilder.FillTableStats(pathId, *(periodicTableStats->MutableTableStats()));
-
-        LOG_S_TRACE("Add stats for table, tableLocalID=" << pathId);
-    }
+    );
 }
 
 void TColumnShard::SendPeriodicStats() {
diff --git a/ydb/core/tx/columnshard/columnshard.h b/ydb/core/tx/columnshard/columnshard.h
index 283324fbb8d9..abcae525df3c 100644
--- a/ydb/core/tx/columnshard/columnshard.h
+++ b/ydb/core/tx/columnshard/columnshard.h
@@ -270,17 +270,12 @@ namespace TEvColumnShard {
     struct TEvWriteResult : public TEventPB<TEvWriteResult, NKikimrTxColumnShard::TEvWriteResult, TEvColumnShard::EvWriteResult> {
         TEvWriteResult() = default;
 
-        TEvWriteResult(ui64 origin, const NEvWrite::TWriteMeta& writeMeta, ui32 status)
-            : TEvWriteResult(origin, writeMeta, writeMeta.GetWriteId(), status)
-        {
-        }
-
-        TEvWriteResult(ui64 origin, const NEvWrite::TWriteMeta& writeMeta, const i64 writeId, ui32 status) {
+        TEvWriteResult(ui64 origin, const NColumnShard::TLocalPathId& localPathId, TString dedupId, const i64 writeId, ui32 status) {
             Record.SetOrigin(origin);
             Record.SetTxInitiator(0);
             Record.SetWriteId(writeId);
-            Record.SetTableId(writeMeta.GetTableId().GetRawValue());
-            Record.SetDedupId(writeMeta.GetDedupId());
+            Record.SetTableId(localPathId.GetRawValue());
+            Record.SetDedupId(dedupId);
             Record.SetStatus(status);
         }
 
diff --git a/ydb/core/tx/columnshard/columnshard__scan.cpp b/ydb/core/tx/columnshard/columnshard__scan.cpp
index 1f0830dad1b5..34682e4ac51e 100644
--- a/ydb/core/tx/columnshard/columnshard__scan.cpp
+++ b/ydb/core/tx/columnshard/columnshard__scan.cpp
@@ -3,6 +3,8 @@
 #include "columnshard_impl.h"
 #include "engines/reader/transaction/tx_scan.h"
 #include "engines/reader/transaction/tx_internal_scan.h"
+#include <ydb/core/tx/columnshard/engines/reader/sys_view/abstract/policy.h>
+#include "ydb/core/kqp/compute_actor/kqp_compute_events.h"
 
 #include <ydb/core/protos/kqp.pb.h>
 #include <ydb/core/base/appdata_fwd.h>
@@ -29,11 +31,32 @@ void TColumnShard::Handle(TEvDataShard::TEvKqpScan::TPtr& ev, const TActorContex
         WaitPlanStep(readVersion.GetPlanStep());
         return;
     }
+    const auto localPathId = TLocalPathId::FromRawValue(record.GetLocalPathId());
+    auto internalPathId = TablesManager.ResolveInternalPathId(localPathId);
+    if (!internalPathId && NOlap::NReader::NSysView::NAbstract::ISysViewPolicy::BuildByPath(record.GetTablePath())) {
+        internalPathId = TInternalPathId::FromRawValue(localPathId.GetRawValue());  //TODO register ColumnStore in tablesmanager
+    }
+    if (!internalPathId) {
+        //TODO FIXME
+        const auto& request = ev->Get()->Record;
+        const TString table = request.GetTablePath();
+        const ui32 scanGen = request.GetGeneration();
+        const auto scanComputeActor = ev->Sender;
+
+        auto ev = MakeHolder<NKqp::TEvKqpCompute::TEvScanError>(scanGen, TabletID());
+        ev->Record.SetStatus(Ydb::StatusIds::BAD_REQUEST);
+        auto issue = NYql::YqlIssue({}, NYql::TIssuesIds::KIKIMR_BAD_REQUEST,
+            TStringBuilder() << "table not found");
+        NYql::IssueToMessage(issue, ev->Record.MutableIssues()->Add());
+
+        ctx.Send(scanComputeActor, ev.Release());
+        return;
+    }
 
-    Counters.GetColumnTablesCounters()->GetPathIdCounter(TInternalPathId::FromRawValue(record.GetLocalPathId()))->OnReadEvent();
+    Counters.GetColumnTablesCounters()->GetPathIdCounter(localPathId)->OnReadEvent();
     ScanTxInFlight.insert({txId, TAppData::TimeProvider->Now()});
     Counters.GetTabletCounters()->SetCounter(COUNTER_SCAN_IN_FLY, ScanTxInFlight.size());
-    Execute(new NOlap::NReader::TTxScan(this, ev), ctx);
+    Execute(new NOlap::NReader::TTxScan(this, ev, *internalPathId), ctx);
 }
 
 void TColumnShard::Handle(TEvColumnShard::TEvInternalScan::TPtr& ev, const TActorContext& ctx) {
diff --git a/ydb/core/tx/columnshard/columnshard__statistics.cpp b/ydb/core/tx/columnshard/columnshard__statistics.cpp
index 61111ee13abf..28862c5e23ea 100644
--- a/ydb/core/tx/columnshard/columnshard__statistics.cpp
+++ b/ydb/core/tx/columnshard/columnshard__statistics.cpp
@@ -285,10 +285,18 @@ void TColumnShard::Handle(NStat::TEvStatistics::TEvStatisticsRequest::TPtr& ev,
         Send(ev->Sender, response.release(), 0, ev->Cookie);
         return;
     }
+    auto internalPathId = TablesManager.ResolveInternalPathId(TLocalPathId::FromRawValue(record.GetTable().GetPathId().GetLocalId()));
+    if (!internalPathId) {
+        AFL_WARN(NKikimrServices::TX_COLUMNSHARD)("error", "Statistic request for unknown GetLocalPathId()");
+        respRecord.SetStatus(NKikimrStat::TEvStatisticsResponse::STATUS_ERROR);
+    
+        Send(ev->Sender, response.release(), 0, ev->Cookie);
+        return;
+    }
 
     AFL_VERIFY(HasIndex());
     auto index = GetIndexAs<NOlap::TColumnEngineForLogs>();
-    auto spg = index.GetGranuleOptional(TInternalPathId::FromRawValue(record.GetTable().GetPathId().GetLocalId()));
+    auto spg = index.GetGranuleOptional(*internalPathId);
     AFL_VERIFY(spg);
 
     std::set<ui32> columnTagsRequested;
diff --git a/ydb/core/tx/columnshard/columnshard__write.cpp b/ydb/core/tx/columnshard/columnshard__write.cpp
index d82e11fd91dc..4e879c824653 100644
--- a/ydb/core/tx/columnshard/columnshard__write.cpp
+++ b/ydb/core/tx/columnshard/columnshard__write.cpp
@@ -50,7 +50,7 @@ void TColumnShard::OverloadWriteFail(const EOverloadStatus overloadReason, const
             Y_ABORT("invalid function usage");
     }
 
-    AFL_DEBUG(NKikimrServices::TX_COLUMNSHARD_WRITE)("event", "write_overload")("size", writeSize)("path_id", writeMeta.GetTableId())(
+    AFL_DEBUG(NKikimrServices::TX_COLUMNSHARD_WRITE)("event", "write_overload")("size", writeSize)("path_id", writeMeta.GetPathId())(
         "reason", overloadReason);
 
     ctx.Send(writeMeta.GetSource(), event.release(), 0, cookie);
@@ -161,7 +161,7 @@ void TColumnShard::Handle(TEvPrivate::TEvWriteBlobsResult::TPtr& ev, const TActo
             }
 
             if (writeMeta.HasLongTxId()) {
-                auto result = std::make_unique<TEvColumnShard::TEvWriteResult>(TabletID(), writeMeta, errCode);
+                auto result = std::make_unique<TEvColumnShard::TEvWriteResult>(TabletID(), writeMeta.GetPathId().GetLocalPathId(), writeMeta.GetDedupId(), writeMeta.GetWriteId(), errCode);
                 ctx.Send(writeMeta.GetSource(), result.release());
             } else {
                 auto operation = OperationsManager->GetOperationVerified((TOperationWriteId)writeMeta.GetWriteId());
@@ -174,7 +174,7 @@ void TColumnShard::Handle(TEvPrivate::TEvWriteBlobsResult::TPtr& ev, const TActo
         } else {
             const TMonotonic now = TMonotonic::Now();
             Counters.OnWritePutBlobsSuccess(now - writeMeta.GetWriteStartInstant(), aggr->GetRows());
-            LOG_S_DEBUG("Write (record) into pathId " << writeMeta.GetTableId()
+            LOG_S_DEBUG("Write (record) into pathId " << writeMeta.GetPathId()
                                                       << (writeMeta.GetWriteId() ? (" writeId " + ToString(writeMeta.GetWriteId())).c_str() : "")
                                                       << " at tablet " << TabletID());
         }
@@ -190,20 +190,35 @@ void TColumnShard::Handle(TEvColumnShard::TEvWrite::TPtr& ev, const TActorContex
     Counters.GetCSCounters().OnStartWriteRequest();
 
     const auto& record = Proto(ev->Get());
-    const auto pathId = TInternalPathId::FromRawValue(record.GetTableId());
+    const auto localPathId = TLocalPathId::FromRawValue(record.GetTableId());
     const ui64 writeId = record.GetWriteId();
     const ui64 cookie = ev->Cookie;
     const TString dedupId = record.GetDedupId();
     const auto source = ev->Sender;
 
-    Counters.GetColumnTablesCounters()->GetPathIdCounter(pathId)->OnWriteEvent();
+    const auto returnFail = [&](const NColumnShard::ECumulativeCounters signalIndex, const EWriteFailReason reason, NKikimrTxColumnShard::EResultStatus resultStatus) {
+        Counters.GetTabletCounters()->IncCounter(signalIndex);
+
+        ctx.Send(source, std::make_unique<TEvColumnShard::TEvWriteResult>(TabletID(), localPathId, dedupId, writeId, resultStatus));
+        Counters.GetCSCounters().OnFailedWriteResponse(reason);
+        return;
+    };
+
+    const auto pathId = TablesManager.ResolveInternalPathId(localPathId);
+    if (*pathId) {
+        LOG_S_NOTICE("Write (fail) into unknown localPathId:" << localPathId << " at tablet " << TabletID());
+        return returnFail(COUNTER_WRITE_FAIL, EWriteFailReason::NoTable, NKikimrTxColumnShard::EResultStatus::ERROR);
+    }
+
+
+    Counters.GetColumnTablesCounters()->GetPathIdCounter(localPathId)->OnWriteEvent();
 
     std::optional<ui32> granuleShardingVersion;
     if (record.HasGranuleShardingVersion()) {
         granuleShardingVersion = record.GetGranuleShardingVersion();
     }
 
-    auto writeMetaPtr = std::make_shared<NEvWrite::TWriteMeta>(writeId, pathId, source, granuleShardingVersion,
+    auto writeMetaPtr = std::make_shared<NEvWrite::TWriteMeta>(writeId, TUnifiedPathId{*pathId, localPathId}, source, granuleShardingVersion,
         TGUID::CreateTimebased().AsGuidString(), Counters.GetCSCounters().WritingCounters->GetWriteFlowCounters());
     auto& writeMeta = *writeMetaPtr;
     if (record.HasModificationType()) {
@@ -214,14 +229,6 @@ void TColumnShard::Handle(TEvColumnShard::TEvWrite::TPtr& ev, const TActorContex
     writeMeta.SetLongTxId(NLongTxService::TLongTxId::FromProto(record.GetLongTxId()));
     writeMeta.SetWritePartId(record.GetWritePartId());
 
-    const auto returnFail = [&](const NColumnShard::ECumulativeCounters signalIndex, const EWriteFailReason reason,
-                                NKikimrTxColumnShard::EResultStatus resultStatus) {
-        Counters.GetTabletCounters()->IncCounter(signalIndex);
-
-        ctx.Send(source, std::make_unique<TEvColumnShard::TEvWriteResult>(TabletID(), writeMeta, resultStatus));
-        Counters.GetCSCounters().OnFailedWriteResponse(reason);
-        return;
-    };
 
     if (SpaceWatcher->SubDomainOutOfSpace &&
         (!record.HasModificationType() || (record.GetModificationType() != NKikimrTxColumnShard::TEvWrite::OPERATION_DELETE))) {
@@ -235,8 +242,8 @@ void TColumnShard::Handle(TEvColumnShard::TEvWrite::TPtr& ev, const TActorContex
         return returnFail(COUNTER_WRITE_FAIL, EWriteFailReason::Disabled, NKikimrTxColumnShard::EResultStatus::ERROR);
     }
 
-    if (!TablesManager.IsReadyForStartWrite(pathId, false)) {
-        LOG_S_NOTICE("Write (fail) into pathId:" << writeMeta.GetTableId() << (TablesManager.HasPrimaryIndex() ? "" : " no index")
+    if (!TablesManager.IsReadyForStartWrite({*pathId, localPathId}, false)) {
+        LOG_S_NOTICE("Write (fail) into pathId:" << writeMeta.GetPathId() << (TablesManager.HasPrimaryIndex() ? "" : " no index")
                                                  << " at tablet " << TabletID());
 
         return returnFail(COUNTER_WRITE_FAIL, EWriteFailReason::NoTable, NKikimrTxColumnShard::EResultStatus::ERROR);
@@ -244,7 +251,7 @@ void TColumnShard::Handle(TEvColumnShard::TEvWrite::TPtr& ev, const TActorContex
 
     {
         auto status = TablesManager.GetPrimaryIndexAsVerified<NOlap::TColumnEngineForLogs>()
-                          .GetGranuleVerified(writeMeta.GetTableId())
+                          .GetGranuleVerified(writeMeta.GetPathId().GetInternalPathId())
                           .GetOptimizerPlanner()
                           .CheckWriteData();
         if (status.IsFail()) {
@@ -257,30 +264,31 @@ void TColumnShard::Handle(TEvColumnShard::TEvWrite::TPtr& ev, const TActorContex
     auto arrowData = std::make_shared<TProtoArrowData>(snapshotSchema);
     if (!arrowData->ParseFromProto(record)) {
         LOG_S_ERROR(
-            "Write (fail) " << record.GetData().size() << " bytes into pathId " << writeMeta.GetTableId() << " at tablet " << TabletID());
+            "Write (fail) " << record.GetData().size() << " bytes into pathId " << writeMeta.GetPathId() << " at tablet " << TabletID());
         return returnFail(COUNTER_WRITE_FAIL, EWriteFailReason::IncorrectSchema, NKikimrTxColumnShard::EResultStatus::ERROR);
     }
 
     NEvWrite::TWriteData writeData(writeMetaPtr, arrowData, snapshotSchema->GetIndexInfo().GetReplaceKey(),
         StoragesManager->GetInsertOperator()->StartWritingAction(NOlap::NBlobOperations::EConsumer::WRITING), false);
-    auto overloadStatus = CheckOverloadedImmediate(pathId);
+    auto overloadStatus = CheckOverloadedImmediate(*pathId);
     if (overloadStatus == EOverloadStatus::None) {
-        overloadStatus = CheckOverloadedWait(pathId);
+        overloadStatus = CheckOverloadedWait(*pathId);
     }
     if (overloadStatus != EOverloadStatus::None) {
+        const auto& writeMeta = writeData.GetWriteMeta();
         std::unique_ptr<NActors::IEventBase> result = std::make_unique<TEvColumnShard::TEvWriteResult>(
-            TabletID(), writeData.GetWriteMeta(), NKikimrTxColumnShard::EResultStatus::OVERLOADED);
+            TabletID(), writeMeta.GetPathId().GetLocalPathId(), writeMeta.GetDedupId(), writeMeta.GetWriteId(), NKikimrTxColumnShard::EResultStatus::OVERLOADED);
         OverloadWriteFail(overloadStatus, writeData.GetWriteMeta(), writeData.GetSize(), cookie, std::move(result), ctx);
         Counters.GetCSCounters().OnFailedWriteResponse(EWriteFailReason::Overload);
     } else {
         if (ui64 writeId = (ui64)HasLongTxWrite(writeMeta.GetLongTxIdUnsafe(), writeMeta.GetWritePartId())) {
-            LOG_S_DEBUG("Write (duplicate) into pathId " << writeMeta.GetTableId() << " longTx " << writeMeta.GetLongTxIdUnsafe().ToString()
+            LOG_S_DEBUG("Write (duplicate) into pathId " << writeMeta.GetPathId() << " longTx " << writeMeta.GetLongTxIdUnsafe().ToString()
                                                          << " at tablet " << TabletID());
 
             Counters.GetTabletCounters()->IncCounter(COUNTER_WRITE_DUPLICATE);
 
             auto result =
-                std::make_unique<TEvColumnShard::TEvWriteResult>(TabletID(), writeMeta, writeId, NKikimrTxColumnShard::EResultStatus::SUCCESS);
+                std::make_unique<TEvColumnShard::TEvWriteResult>(TabletID(), writeMeta.GetPathId().GetLocalPathId(), writeMeta.GetDedupId(), writeId, NKikimrTxColumnShard::EResultStatus::SUCCESS);
             ctx.Send(writeMeta.GetSource(), result.release());
             Counters.GetCSCounters().OnFailedWriteResponse(EWriteFailReason::LongTxDuplication);
             return;
@@ -288,7 +296,7 @@ void TColumnShard::Handle(TEvColumnShard::TEvWrite::TPtr& ev, const TActorContex
 
         Counters.GetWritesMonitor()->OnStartWrite(writeData.GetSize());
 
-        LOG_S_DEBUG("Write (blob) " << writeData.GetSize() << " bytes into pathId " << writeMeta.GetTableId()
+        LOG_S_DEBUG("Write (blob) " << writeData.GetSize() << " bytes into pathId " << writeMeta.GetPathId()
                                     << (writeMeta.GetWriteId() ? (" writeId " + ToString(writeMeta.GetWriteId())).c_str() : " ")
                                     << Counters.GetWritesMonitor()->DebugString() << " at tablet " << TabletID());
 
@@ -563,14 +571,19 @@ void TColumnShard::Handle(NEvents::TDataEvents::TEvWrite::TPtr& ev, const TActor
         return;
     }
 
-    const auto pathId = TInternalPathId::FromRawValue(operation.GetTableId().GetTableId());
+    const auto localPathId = TLocalPathId::FromRawValue(operation.GetTableId().GetTableId());
+    const auto pathId = TablesManager.ResolveInternalPathId(localPathId);
+    if (!pathId) {
+        sendError("table not found", NKikimrDataEvents::TEvWriteResult::STATUS_INTERNAL_ERROR);
+        return;
+    }
 
-    if (!TablesManager.IsReadyForStartWrite(pathId, false)) {
+    if (!TablesManager.IsReadyForStartWrite({*pathId, localPathId}, false)) {
         sendError("table not writable", NKikimrDataEvents::TEvWriteResult::STATUS_INTERNAL_ERROR);
         return;
     }
 
-    Counters.GetColumnTablesCounters()->GetPathIdCounter(pathId)->OnWriteEvent();
+    Counters.GetColumnTablesCounters()->GetPathIdCounter(localPathId)->OnWriteEvent();
 
     auto arrowData = std::make_shared<TArrowData>(schema);
     if (!arrowData->Parse(operation, NEvWrite::TPayloadReader<NEvents::TDataEvents::TEvWrite>(*ev->Get()))) {
@@ -587,12 +600,12 @@ void TColumnShard::Handle(NEvents::TDataEvents::TEvWrite::TPtr& ev, const TActor
     if (outOfSpace) {
         AFL_WARN(NKikimrServices::TX_COLUMNSHARD)("event", "skip_writing")("reason", "quota_exceeded")("source", "dataevent");
     }
-    auto overloadStatus = outOfSpace ? EOverloadStatus::Disk : CheckOverloadedImmediate(pathId);
+    auto overloadStatus = outOfSpace ? EOverloadStatus::Disk : CheckOverloadedImmediate(*pathId);
     if (overloadStatus != EOverloadStatus::None) {
         std::unique_ptr<NActors::IEventBase> result = NEvents::TDataEvents::TEvWriteResult::BuildError(
             TabletID(), 0, NKikimrDataEvents::TEvWriteResult::STATUS_OVERLOADED, "overload data error");
         OverloadWriteFail(overloadStatus,
-            NEvWrite::TWriteMeta(0, pathId, source, {}, TGUID::CreateTimebased().AsGuidString(),
+            NEvWrite::TWriteMeta(0, {*pathId, localPathId}, source, {}, TGUID::CreateTimebased().AsGuidString(),
                 Counters.GetCSCounters().WritingCounters->GetWriteFlowCounters()),
             arrowData->GetSize(), cookie, std::move(result), ctx);
         return;
@@ -611,7 +624,7 @@ void TColumnShard::Handle(NEvents::TDataEvents::TEvWrite::TPtr& ev, const TActor
     }
 
     Counters.GetWritesMonitor()->OnStartWrite(arrowData->GetSize());
-    WriteTasksQueue->Enqueue(TWriteTask(arrowData, schema, source, granuleShardingVersionId, pathId, cookie, lockId, *mType, behaviour));
+    WriteTasksQueue->Enqueue(TWriteTask(arrowData, schema, source, granuleShardingVersionId, {*pathId, localPathId}, cookie, lockId, *mType, behaviour));
     WriteTasksQueue->Drain(false, ctx);
 }
 
diff --git a/ydb/core/tx/columnshard/columnshard_impl.cpp b/ydb/core/tx/columnshard/columnshard_impl.cpp
index ebaf53c86a37..d8d5de02658f 100644
--- a/ydb/core/tx/columnshard/columnshard_impl.cpp
+++ b/ydb/core/tx/columnshard/columnshard_impl.cpp
@@ -378,18 +378,19 @@ void TColumnShard::RunEnsureTable(const NKikimrTxColumnShard::TCreateTable& tabl
     NTabletFlatExecutor::TTransactionContext& txc) {
     NIceDb::TNiceDb db(txc.DB);
 
-    const TInternalPathId pathId = TInternalPathId::FromRawValue(tableProto.GetPathId());
-    if (TablesManager.HasTable(pathId)) {
-        LOG_S_DEBUG("EnsureTable for existed pathId: " << pathId << " at tablet " << TabletID());
+    const TLocalPathId localPathId = TLocalPathId::FromRawValue(tableProto.GetPathId());
+    if (const auto internalPathId = TablesManager.ResolveInternalPathId(localPathId)) {
+        LOG_S_DEBUG("EnsureTable for existed GetLocalPathId(): " << localPathId << " at tablet " << TabletID());
         return;
     }
+    const auto internalPathId = TablesManager.CreateInternalPathId(localPathId);
 
-    LOG_S_DEBUG("EnsureTable for pathId: " << pathId
+    LOG_S_DEBUG("EnsureTable for GetLocalPathId(): " << localPathId
                                            << " ttl settings: " << tableProto.GetTtlSettings()
                                            << " at tablet " << TabletID());
 
     NKikimrTxColumnShard::TTableVersionInfo tableVerProto;
-    tableVerProto.SetPathId(pathId.GetRawValue());
+    tableVerProto.SetPathId(internalPathId.GetRawValue());
 
     // check schema changed
 
@@ -412,7 +413,7 @@ void TColumnShard::RunEnsureTable(const NKikimrTxColumnShard::TCreateTable& tabl
 
     {
         THashSet<NTiers::TExternalStorageId> usedTiers;
-        TTableInfo table(pathId);
+        TTableInfo table(internalPathId, localPathId); 
         if (tableProto.HasTtlSettings()) {
             const auto& ttlSettings = tableProto.GetTtlSettings();
             *tableVerProto.MutableTtlSettings() = ttlSettings;
@@ -422,16 +423,16 @@ void TColumnShard::RunEnsureTable(const NKikimrTxColumnShard::TCreateTable& tabl
         }
         TablesManager.RegisterTable(std::move(table), db);
         if (!usedTiers.empty()) {
-            ActivateTiering(pathId, usedTiers);
+            ActivateTiering(internalPathId, usedTiers);
         }
     }
 
     tableVerProto.SetSchemaPresetVersionAdj(tableProto.GetSchemaPresetVersionAdj());
 
-    TablesManager.AddTableVersion(pathId, version, tableVerProto, schema, db);
-    InsertTable->RegisterPathInfo(pathId);
+    TablesManager.AddTableVersion(internalPathId, version, tableVerProto, schema, db);
+    InsertTable->RegisterPathInfo(internalPathId);
 
-    Counters.GetTabletCounters()->SetCounter(COUNTER_TABLES, TablesManager.GetTables().size());
+    Counters.GetTabletCounters()->SetCounter(COUNTER_TABLES, TablesManager.GetTableCount());
     Counters.GetTabletCounters()->SetCounter(COUNTER_TABLE_PRESETS, TablesManager.GetSchemaPresets().size());
     Counters.GetTabletCounters()->SetCounter(COUNTER_TABLE_TTLS, TablesManager.GetTtl().size());
 }
@@ -440,10 +441,11 @@ void TColumnShard::RunAlterTable(const NKikimrTxColumnShard::TAlterTable& alterP
     NTabletFlatExecutor::TTransactionContext& txc) {
     NIceDb::TNiceDb db(txc.DB);
 
-    const auto pathId = TInternalPathId::FromRawValue(alterProto.GetPathId());
-    Y_ABORT_UNLESS(TablesManager.HasTable(pathId), "AlterTable on a dropped or non-existent table");
+    const auto localPathId = NColumnShard::TLocalPathId::FromRawValue(alterProto.GetPathId());
+    const auto internalPathId = TablesManager.ResolveInternalPathId(localPathId);
+    Y_ABORT_UNLESS(internalPathId, "AlterTable on a dropped or non-existent table");
 
-    LOG_S_DEBUG("AlterTable for pathId: " << pathId
+    LOG_S_DEBUG("AlterTable for GetLocalPathId(): " << localPathId
                                           << " schema: " << alterProto.GetSchema()
                                           << " ttl settings: " << alterProto.GetTtlSettings()
                                           << " at tablet " << TabletID());
@@ -465,25 +467,26 @@ void TColumnShard::RunAlterTable(const NKikimrTxColumnShard::TAlterTable& alterP
         if (ttlSettings.HasEnabled()) {
             usedTiers = NOlap::TTiering::GetUsedTiers(ttlSettings.GetEnabled());
         }
-        ActivateTiering(pathId, usedTiers);
+        ActivateTiering(*internalPathId, usedTiers);
     }
 
     tableVerProto.SetSchemaPresetVersionAdj(alterProto.GetSchemaPresetVersionAdj());
-    TablesManager.AddTableVersion(pathId, version, tableVerProto, schema, db);
+    TablesManager.AddTableVersion(*internalPathId, version, tableVerProto, schema, db);
 }
 
 void TColumnShard::RunDropTable(const NKikimrTxColumnShard::TDropTable& dropProto, const NOlap::TSnapshot& version,
     NTabletFlatExecutor::TTransactionContext& txc) {
     NIceDb::TNiceDb db(txc.DB);
 
-    const auto pathId = TInternalPathId::FromRawValue(dropProto.GetPathId());
-    if (!TablesManager.HasTable(pathId)) {
-        LOG_S_DEBUG("DropTable for unknown or deleted pathId: " << pathId << " at tablet " << TabletID());
+    const auto localPathId =  TLocalPathId::FromRawValue(dropProto.GetPathId());
+    const auto pathId = TablesManager.ResolveInternalPathId(localPathId);
+    if (!pathId || !TablesManager.HasTable(*pathId)) {
+        LOG_S_DEBUG("DropTable for unknown or deleted table with LocalPathId" << localPathId << " at tablet " << TabletID());
         return;
     }
 
-    LOG_S_DEBUG("DropTable for pathId: " << pathId << " at tablet " << TabletID());
-    TablesManager.DropTable(pathId, version, db);
+    LOG_S_DEBUG("DropTable for LocalPathId:" << localPathId << ", InternalPathId:" << *pathId << " at tablet " << TabletID());
+    TablesManager.DropTable(*pathId, version, db);
 }
 
 void TColumnShard::RunAlterStore(const NKikimrTxColumnShard::TAlterStore& proto, const NOlap::TSnapshot& version,
@@ -831,7 +834,6 @@ void TColumnShard::SetupCompaction(const std::set<TInternalPathId>& pathIds) {
         AFL_WARN(NKikimrServices::TX_COLUMNSHARD)("event", "skip_compaction")("reason", "disabled");
         return;
     }
-
     BackgroundController.CheckDeadlines();
     if (BackgroundController.GetCompactionsCount()) {
         return;
@@ -1054,7 +1056,7 @@ void TColumnShard::SetupCleanupPortions() {
     }
 
     const NOlap::TSnapshot minReadSnapshot = GetMinReadSnapshot();
-    const auto& pathsToDrop = TablesManager.GetPathsToDrop(minReadSnapshot);
+    auto pathsToDrop = TablesManager.GetPathsToDrop(minReadSnapshot);
 
     auto changes = TablesManager.MutablePrimaryIndex().StartCleanupPortions(minReadSnapshot, pathsToDrop, DataLocksManager);
     if (!changes) {
diff --git a/ydb/core/tx/columnshard/columnshard_schema.h b/ydb/core/tx/columnshard/columnshard_schema.h
index bc0d7eaf3567..d278855a2726 100644
--- a/ydb/core/tx/columnshard/columnshard_schema.h
+++ b/ydb/core/tx/columnshard/columnshard_schema.h
@@ -1,4 +1,5 @@
 #pragma once
+#include <ydb/core/tx/columnshard/common/path_id.h>
 #include "defs.h"
 
 #include <ydb/core/tablet_flat/flat_cxx_database.h>
@@ -116,6 +117,10 @@ struct Schema : NIceDb::Schema {
         TxEvents = 18
     };
 
+    static constexpr auto InternalPathIdTypeId = NScheme::NTypeIds::Uint64; //Columnshard internal PathId value 
+    static constexpr auto LocalPathIdTypeId = NScheme::NTypeIds::Uint64; //PathId the table is known as at SchemeShard
+
+
     // Tablet tables
 
     struct Value : Table<(ui32)ECommonTables::Value> {
@@ -182,17 +187,18 @@ struct Schema : NIceDb::Schema {
     };
 
     struct TableInfo : Table<(ui32)ECommonTables::TableInfo> {
-        struct PathId : Column<1, NScheme::NTypeIds::Uint64> {};
+        struct PathId : Column<1, InternalPathIdTypeId> {}; 
         struct DropStep : Column<2, NScheme::NTypeIds::Uint64> {};
         struct DropTxId : Column<3, NScheme::NTypeIds::Uint64> {};
         struct TieringUsage: Column<4, NScheme::NTypeIds::String> {};
+        struct LocalPathId : Column<5, LocalPathIdTypeId> {};
 
         using TKey = TableKey<PathId>;
-        using TColumns = TableColumns<PathId, DropStep, DropTxId, TieringUsage>;
+        using TColumns = TableColumns<PathId, DropStep, DropTxId, TieringUsage, LocalPathId>;
     };
 
     struct TableVersionInfo : Table<(ui32)ECommonTables::TableVersionInfo> {
-        struct PathId : Column<1, NScheme::NTypeIds::Uint64> {};
+        struct PathId : Column<1, InternalPathIdTypeId> {}; //Internal columnshard PathId 
         struct SinceStep : Column<2, NScheme::NTypeIds::Uint64> {};
         struct SinceTxId : Column<3, NScheme::NTypeIds::Uint64> {};
         struct InfoProto : Column<4, NScheme::NTypeIds::String> {}; // TTableVersionInfo
@@ -296,7 +302,7 @@ struct Schema : NIceDb::Schema {
         struct Committed : Column<1, NScheme::NTypeIds::Byte> {};
         struct PlanStep : Column<2, NScheme::NTypeIds::Uint64> {};
         struct WriteTxId : Column<3, NScheme::NTypeIds::Uint64> {};
-        struct PathId : Column<4, NScheme::NTypeIds::Uint64> {};
+        struct PathId : Column<4, InternalPathIdTypeId> {};
         struct DedupId : Column<5, NScheme::NTypeIds::String> {};
         struct BlobId: Column<6, NScheme::NTypeIds::String> {};
         struct Meta : Column<7, NScheme::NTypeIds::String> {};
@@ -314,7 +320,7 @@ struct Schema : NIceDb::Schema {
 
     struct IndexGranules : NIceDb::Schema::Table<GranulesTableId> {
         struct Index : Column<1, NScheme::NTypeIds::Uint32> {};
-        struct PathId : Column<2, NScheme::NTypeIds::Uint64> {};    // Logical table (if many)
+        struct PathId : Column<2, InternalPathIdTypeId> {};    // Logical table (if many)
         struct IndexKey : Column<3, NScheme::NTypeIds::String> {};  // Effective part of PK (serialized)
         struct Granule : Column<4, NScheme::NTypeIds::Uint64> {};   // FK: {Index, Granule} -> TIndexColumns
         struct PlanStep : Column<5, NScheme::NTypeIds::Uint64> {};
@@ -339,7 +345,7 @@ struct Schema : NIceDb::Schema {
         struct Metadata : Column<11, NScheme::NTypeIds::String> {}; // NKikimrTxColumnShard.TIndexColumnMeta
         struct Offset : Column<12, NScheme::NTypeIds::Uint32> {};
         struct Size : Column<13, NScheme::NTypeIds::Uint32> {};
-        struct PathId : Column<14, NScheme::NTypeIds::Uint64> {};
+        struct PathId : Column<14, InternalPathIdTypeId> {};
 
         using TKey = TableKey<Index, Granule, ColumnIdx, PlanStep, TxId, Portion, Chunk>;
         using TColumns = TableColumns<Index, Granule, ColumnIdx, PlanStep, TxId, Portion, Chunk,
@@ -403,7 +409,7 @@ struct Schema : NIceDb::Schema {
     };
 
     struct IndexIndexes: NIceDb::Schema::Table<IndexesTableId> {
-        struct PathId: Column<1, NScheme::NTypeIds::Uint64> {};
+        struct PathId: Column<1, InternalPathIdTypeId> {};
         struct PortionId: Column<2, NScheme::NTypeIds::Uint64> {};
         struct IndexId: Column<3, NScheme::NTypeIds::Uint32> {};
         struct ChunkIdx: Column<4, NScheme::NTypeIds::Uint32> {};
@@ -471,7 +477,7 @@ struct Schema : NIceDb::Schema {
         struct LockId : Column<1, NScheme::NTypeIds::Uint64> {};
         struct RangeId : Column<2, NScheme::NTypeIds::Uint64> {};
         struct PathOwnerId : Column<3, NScheme::NTypeIds::Uint64> {};
-        struct LocalPathId : Column<4, NScheme::NTypeIds::Uint64> {};
+        struct LocalPathId : Column<4, InternalPathIdTypeId> {};
         struct Flags : Column<5, NScheme::NTypeIds::Uint64> {};
         struct Data : Column<6, NScheme::NTypeIds::String> {};
 
@@ -496,7 +502,7 @@ struct Schema : NIceDb::Schema {
     };
 
     struct IndexPortions: NIceDb::Schema::Table<PortionsTableId> {
-        struct PathId: Column<1, NScheme::NTypeIds::Uint64> {};
+        struct PathId: Column<1, InternalPathIdTypeId> {};
         struct PortionId: Column<2, NScheme::NTypeIds::Uint64> {};
         struct SchemaVersion: Column<3, NScheme::NTypeIds::Uint64> {};
         struct XPlanStep: Column<4, NScheme::NTypeIds::Uint64> {};
@@ -527,7 +533,7 @@ struct Schema : NIceDb::Schema {
     };
 
     struct ShardingInfo : Table<ShardingInfoTableId> {
-        struct PathId : Column<1, NScheme::NTypeIds::Uint64> {};
+        struct PathId : Column<1, InternalPathIdTypeId> {};
         struct VersionId : Column<2, NScheme::NTypeIds::Uint64> {};
         struct Snapshot : Column<3, NScheme::NTypeIds::String> {};
         struct Logic : Column<4, NScheme::NTypeIds::String> {};
@@ -559,7 +565,7 @@ struct Schema : NIceDb::Schema {
     };
 
     struct IndexColumnsV1: Table<ColumnsV1TableId> {
-        struct PathId: Column<1, NScheme::NTypeIds::Uint64> {};
+        struct PathId: Column<1, InternalPathIdTypeId> {};
         struct PortionId: Column<2, NScheme::NTypeIds::Uint64> {};
         struct SSColumnId: Column<3, NScheme::NTypeIds::Uint32> {};
         struct ChunkIdx: Column<4, NScheme::NTypeIds::Uint32> {};
@@ -573,7 +579,7 @@ struct Schema : NIceDb::Schema {
     };
 
     struct IndexColumnsV2: Table<ColumnsV2TableId> {
-        struct PathId: Column<1, NScheme::NTypeIds::Uint64> {};
+        struct PathId: Column<1, InternalPathIdTypeId> {};
         struct PortionId: Column<2, NScheme::NTypeIds::Uint64> {};
         struct Metadata: Column<3, NScheme::NTypeIds::String> {};
 
@@ -806,6 +812,11 @@ struct Schema : NIceDb::Schema {
             NIceDb::TUpdate<TableInfo::DropStep>(dropStep),
             NIceDb::TUpdate<TableInfo::DropTxId>(dropTxId));
     }
+    static void UpdateTableLocalPathId(NIceDb::TNiceDb& db, const TInternalPathId pathId, const TLocalPathId localPathId) {
+        db.Table<TableInfo>().Key(pathId.GetRawValue()).Update(
+            NIceDb::TUpdate<TableInfo::LocalPathId>(localPathId.GetRawValue())
+        );
+    }
 
     static void EraseTableVersionInfo(NIceDb::TNiceDb& db, TInternalPathId pathId, const NOlap::TSnapshot& version) {
         db.Table<TableVersionInfo>().Key(pathId.GetRawValue(), version.GetPlanStep(), version.GetTxId()).Delete();
@@ -926,7 +937,7 @@ struct Schema : NIceDb::Schema {
 namespace NKikimr::NOlap {
 class TPortionLoadContext {
 private:
-    YDB_READONLY_DEF(TInternalPathId, PathId);
+    YDB_READONLY(TInternalPathId, PathId, TInternalPathId{});
     YDB_READONLY(ui64, PortionId, 0);
     YDB_READONLY_DEF(NKikimrTxColumnShard::TIndexPortionMeta, MetaProto);
     YDB_READONLY_DEF(std::optional<NOlap::TSnapshot>, DeprecatedMinSnapshot);
@@ -950,7 +961,7 @@ class TColumnChunkLoadContext {
 private:
     YDB_READONLY_DEF(TBlobRange, BlobRange);
     TChunkAddress Address;
-    YDB_READONLY_DEF(TInternalPathId, PathId);
+    YDB_READONLY(TInternalPathId, PathId, TInternalPathId{});
     YDB_READONLY(ui64, PortionId, 0);
     YDB_READONLY_DEF(NKikimrTxColumnShard::TIndexColumnMeta, MetaProto);
     YDB_READONLY(TSnapshot, RemoveSnapshot, TSnapshot::Zero());
@@ -1007,7 +1018,7 @@ class TColumnChunkLoadContextV1 {
 private:
     TChunkAddress Address;
     YDB_READONLY_DEF(TBlobRangeLink16, BlobRange);
-    YDB_READONLY_DEF(TInternalPathId, PathId);
+    YDB_READONLY(TInternalPathId, PathId, TInternalPathId{});
     YDB_READONLY(ui64, PortionId, 0);
     YDB_READONLY_DEF(NKikimrTxColumnShard::TIndexColumnMeta, MetaProto);
 
@@ -1060,8 +1071,8 @@ class TColumnChunkLoadContextV1 {
 
 class TColumnChunkLoadContextV2 {
 private:
-    YDB_READONLY_DEF(TInternalPathId, PathId);
-    YDB_READONLY(ui64, PortionId, 0);
+YDB_READONLY(TInternalPathId, PathId, TInternalPathId{});
+YDB_READONLY(ui64, PortionId, 0);
     YDB_READONLY_DEF(TString, MetadataProto);
 
 public:
@@ -1095,7 +1106,7 @@ class TIndexChunkLoadContext {
 private:
     YDB_READONLY_DEF(std::optional<TBlobRange>, BlobRange);
     YDB_READONLY_DEF(std::optional<TString>, BlobData);
-    YDB_READONLY_DEF(TInternalPathId, PathId);
+    YDB_READONLY(TInternalPathId, PathId, TInternalPathId{});
     YDB_READONLY(ui64, PortionId, 0);
     TChunkAddress Address;
     const ui32 RecordsCount;
diff --git a/ydb/core/tx/columnshard/common/path_id.cpp b/ydb/core/tx/columnshard/common/path_id.cpp
index 9ab28e86ab1b..fff99ce46150 100644
--- a/ydb/core/tx/columnshard/common/path_id.cpp
+++ b/ydb/core/tx/columnshard/common/path_id.cpp
@@ -1,6 +1,16 @@
 #include "path_id.h"
 
 template<>
-void Out<NKikimr::NColumnShard::TInternalPathId>(IOutputStream& s, TTypeTraits<NKikimr::NColumnShard::TInternalPathId>::TFuncParam v) {
-     s << v.GetRawValue();
+void Out<NKikimr::NColumnShard::TInternalPathId>(IOutputStream& s, const NKikimr::NColumnShard::TInternalPathId& v) {
+    s << v.GetRawValue();
+}
+
+template<>
+void Out<NKikimr::NColumnShard::TLocalPathId>(IOutputStream& s, const NKikimr::NColumnShard::TLocalPathId& v) {
+    s << v.GetRawValue();
+}
+
+template<>
+void Out<NKikimr::NColumnShard::TUnifiedPathId>(IOutputStream& s, const NKikimr::NColumnShard::TUnifiedPathId& v) {
+    s << "{" << v.GetInternalPathId() << ", " << v.GetLocalPathId() << "}";
 }
diff --git a/ydb/core/tx/columnshard/common/path_id.h b/ydb/core/tx/columnshard/common/path_id.h
index b5c18912de10..828adb320aed 100644
--- a/ydb/core/tx/columnshard/common/path_id.h
+++ b/ydb/core/tx/columnshard/common/path_id.h
@@ -37,17 +37,83 @@ class TInternalPathId {
 
 static_assert(sizeof(TInternalPathId)==sizeof(ui64));
 
+class TLocalPathId {
+    ui64 PathId;
+private:
+    explicit TLocalPathId(const ui64 pathId)
+        : PathId(pathId) {
+    }
+public:
+    TLocalPathId()
+        : PathId(0) {
+    }
+    explicit operator bool() const {
+        return PathId != 0;
+    }
+
+    static TLocalPathId FromRawValue(ui64 pathId) {
+        return TLocalPathId(pathId);
+    }
+
+    ui64 GetRawValue() const {
+        return PathId;
+    }
+
+    auto operator<=>(const TLocalPathId&) const = default;
+};
+
+class TUnifiedPathId {
+private:    
+    TInternalPathId InternalPathId;
+    TLocalPathId LocalPathId;
+public:
+    TUnifiedPathId() = default;
+    TUnifiedPathId(TInternalPathId internalPathId, TLocalPathId localPathId)
+        : InternalPathId(internalPathId)
+        , LocalPathId(localPathId) {
+        Y_ABORT_UNLESS(!!GetLocalPathId() == !!GetInternalPathId());
+    }
+    TUnifiedPathId(const TUnifiedPathId&) = default;
+    TUnifiedPathId(TUnifiedPathId&&) = default;
+    TUnifiedPathId& operator=(const TUnifiedPathId&) = default;
+    TUnifiedPathId& operator=(TUnifiedPathId&&) = default;
+
+    TInternalPathId GetInternalPathId() const {
+        return InternalPathId;
+    }
+
+    TLocalPathId GetLocalPathId() const {
+        return LocalPathId;
+    }
+
+    explicit operator bool() const {
+        return !!GetInternalPathId();
+    }
+
+    auto operator<=>(const TUnifiedPathId&) const = default;
+};
+
+
 } //namespace NKikimr::NColumnShard
 
 namespace NKikimr::NOlap {
 
 using TInternalPathId = NColumnShard::TInternalPathId;
-
+using TLocalPathId = NColumnShard::TLocalPathId;
+using TUnifiedPathId = NColumnShard::TUnifiedPathId;
+    
 } //namespace NKikimr::NOlap
 
 template <>
 struct THash<NKikimr::NColumnShard::TInternalPathId> {
     size_t operator()(const NKikimr::NColumnShard::TInternalPathId& p) const {
-        return THash<ui64>()(p.GetRawValue());
+        return p.GetRawValue();
+    }
+};
+
+template <>
+struct THash<NKikimr::NColumnShard::TLocalPathId> {
+    size_t operator()(const NKikimr::NColumnShard::TLocalPathId& p) const {
+        return p.GetRawValue();
     }
 };
diff --git a/ydb/core/tx/columnshard/counters/aggregation/table_stats.h b/ydb/core/tx/columnshard/counters/aggregation/table_stats.h
index e038bfbfa696..6328117826de 100644
--- a/ydb/core/tx/columnshard/counters/aggregation/table_stats.h
+++ b/ydb/core/tx/columnshard/counters/aggregation/table_stats.h
@@ -29,10 +29,10 @@ class TTableStatsBuilder {
         , Executor(*executor) {
     }
 
-    void FillTableStats(TInternalPathId pathId, ::NKikimrTableStats::TTableStats& tableStats) {
-        Counters.FillTableStats(pathId, tableStats);
+    void FillTableStats(TUnifiedPathId pathId, ::NKikimrTableStats::TTableStats& tableStats) {
+        Counters.FillTableStats(pathId.GetLocalPathId(), tableStats);
 
-        auto activeStats = Counters.GetPortionIndexCounters()->GetTableStats(pathId, TPortionIndexStats::TActivePortions());
+        auto activeStats = Counters.GetPortionIndexCounters()->GetTableStats(pathId.GetInternalPathId(), TPortionIndexStats::TActivePortions());
         FillPortionStats(tableStats, activeStats);
     }
 
diff --git a/ydb/core/tx/columnshard/counters/background_controller.cpp b/ydb/core/tx/columnshard/counters/background_controller.cpp
index 39472c53158a..e1fdf9cffaa3 100644
--- a/ydb/core/tx/columnshard/counters/background_controller.cpp
+++ b/ydb/core/tx/columnshard/counters/background_controller.cpp
@@ -5,7 +5,7 @@
 
 namespace NKikimr::NColumnShard {
 
-void TBackgroundControllerCounters::OnCompactionFinish(TInternalPathId pathId) {
+void TBackgroundControllerCounters::OnCompactionFinish(TLocalPathId pathId) {
     TInstant now = TAppData::TimeProvider->Now();
     TInstant& lastFinish = LastCompactionFinishByPathId[pathId];
     lastFinish = std::max(lastFinish, now);
diff --git a/ydb/core/tx/columnshard/counters/background_controller.h b/ydb/core/tx/columnshard/counters/background_controller.h
index 4b4b98a4ba5f..8823a027269c 100644
--- a/ydb/core/tx/columnshard/counters/background_controller.h
+++ b/ydb/core/tx/columnshard/counters/background_controller.h
@@ -9,13 +9,13 @@ namespace NKikimr::NColumnShard {
 
 class TBackgroundControllerCounters {
 private:
-    THashMap<TInternalPathId, TInstant> LastCompactionFinishByPathId;
+    THashMap<TLocalPathId, TInstant> LastCompactionFinishByPathId;
     TInstant LastCompactionFinish;
 
 public:
-    void OnCompactionFinish(TInternalPathId pathId);
+    void OnCompactionFinish(TLocalPathId pathId);
 
-    void FillStats(TInternalPathId pathId, ::NKikimrTableStats::TTableStats& output) const {
+    void FillStats(TLocalPathId pathId, ::NKikimrTableStats::TTableStats& output) const {
         output.SetLastFullCompactionTs(GetLastCompactionFinishInstant(pathId).value_or(TInstant::Zero()).Seconds());
     }
 
@@ -24,7 +24,7 @@ class TBackgroundControllerCounters {
     }
 
 private:
-    std::optional<TInstant> GetLastCompactionFinishInstant(const TInternalPathId pathId) const {
+    std::optional<TInstant> GetLastCompactionFinishInstant(const TLocalPathId pathId) const {
         auto findInstant = LastCompactionFinishByPathId.FindPtr(pathId);
         if (!findInstant) {
             return std::nullopt;
diff --git a/ydb/core/tx/columnshard/counters/column_tables.cpp b/ydb/core/tx/columnshard/counters/column_tables.cpp
index bbf68cf8836f..12c61ad1f8d9 100644
--- a/ydb/core/tx/columnshard/counters/column_tables.cpp
+++ b/ydb/core/tx/columnshard/counters/column_tables.cpp
@@ -3,7 +3,7 @@
 
 namespace NKikimr::NColumnShard {
 
-std::shared_ptr<TSingleColumnTableCounters> TColumnTablesCounters::GetPathIdCounter(TInternalPathId pathId) {
+std::shared_ptr<TSingleColumnTableCounters> TColumnTablesCounters::GetPathIdCounter(TLocalPathId pathId) {
     auto findCounter = PathIdCounters.FindPtr(pathId);
     if (findCounter) {
         return *findCounter;
diff --git a/ydb/core/tx/columnshard/counters/column_tables.h b/ydb/core/tx/columnshard/counters/column_tables.h
index 29cfcb4b860a..beceb9a98272 100644
--- a/ydb/core/tx/columnshard/counters/column_tables.h
+++ b/ydb/core/tx/columnshard/counters/column_tables.h
@@ -16,7 +16,7 @@ class TColumnTablesCounters {
     YDB_READONLY_CONST(std::shared_ptr<TInstant>, LastAccessTime);
     YDB_READONLY_CONST(std::shared_ptr<TInstant>, LastUpdateTime);
 
-    THashMap<TInternalPathId, std::shared_ptr<TSingleColumnTableCounters>> PathIdCounters;
+    THashMap<TLocalPathId, std::shared_ptr<TSingleColumnTableCounters>> PathIdCounters;
 
     friend class TSingleColumnTableCounters;
 
@@ -31,7 +31,7 @@ class TColumnTablesCounters {
         output.SetLastUpdateTime(LastUpdateTime->MilliSeconds());
     }
 
-    std::shared_ptr<TSingleColumnTableCounters> GetPathIdCounter(TInternalPathId pathId);
+    std::shared_ptr<TSingleColumnTableCounters> GetPathIdCounter(TLocalPathId pathId);
 };
 
 class TSingleColumnTableCounters {
diff --git a/ydb/core/tx/columnshard/counters/counters_manager.h b/ydb/core/tx/columnshard/counters/counters_manager.h
index 2f6b2c4ad86a..16e223f588c1 100644
--- a/ydb/core/tx/columnshard/counters/counters_manager.h
+++ b/ydb/core/tx/columnshard/counters/counters_manager.h
@@ -84,7 +84,7 @@ class TCountersManager {
         CSCounters.OnWriteOverloadShardWritesSize(size);
     }
 
-    void FillTableStats(TInternalPathId pathId, ::NKikimrTableStats::TTableStats& tableStats) {
+    void FillTableStats(TLocalPathId pathId, ::NKikimrTableStats::TTableStats& tableStats) {
         ColumnTablesCounters->GetPathIdCounter(pathId)->FillStats(tableStats);
         BackgroundControllerCounters->FillStats(pathId, tableStats);
     }
diff --git a/ydb/core/tx/columnshard/data_accessor/request.h b/ydb/core/tx/columnshard/data_accessor/request.h
index 70d1a16eaba0..eef07c33fcec 100644
--- a/ydb/core/tx/columnshard/data_accessor/request.h
+++ b/ydb/core/tx/columnshard/data_accessor/request.h
@@ -127,7 +127,7 @@ class TPathFetchingState {
         return sb;
     }
 
-    TPathFetchingState(const TInternalPathId pathId)
+    explicit TPathFetchingState(const TInternalPathId pathId)
         : PathId(pathId) {
     }
 
@@ -290,7 +290,7 @@ class TDataAccessorsRequest: public NColumnShard::TMonitoringObjectsCounter<TDat
         auto it = PathIdStatus.find(portion->GetPathId());
         if (it == PathIdStatus.end()) {
             PreparingCount.Inc();
-            it = PathIdStatus.emplace(portion->GetPathId(), portion->GetPathId()).first;
+            it = PathIdStatus.emplace(portion->GetPathId(), TPathFetchingState{portion->GetPathId()}).first;
         }
         it->second.AddPortion(portion);
     }
diff --git a/ydb/core/tx/columnshard/data_sharing/destination/events/transfer.h b/ydb/core/tx/columnshard/data_sharing/destination/events/transfer.h
index a172e135bcff..4bf877c0e5de 100644
--- a/ydb/core/tx/columnshard/data_sharing/destination/events/transfer.h
+++ b/ydb/core/tx/columnshard/data_sharing/destination/events/transfer.h
@@ -18,7 +18,7 @@ namespace NKikimr::NOlap::NDataSharing::NEvents {
 
 class TPathIdData {
 private:
-    YDB_READONLY_DEF(TInternalPathId, PathId);
+    YDB_READONLY_DEF(TInternalPathId, PathId); //TODO LocalPathId?
     YDB_ACCESSOR_DEF(std::vector<TPortionDataAccessor>, Portions);
 
     TPathIdData() = default;
diff --git a/ydb/core/tx/columnshard/engines/changes/abstract/compaction_info.h b/ydb/core/tx/columnshard/engines/changes/abstract/compaction_info.h
index b1f51d9d74ad..d50222833cfd 100644
--- a/ydb/core/tx/columnshard/engines/changes/abstract/compaction_info.h
+++ b/ydb/core/tx/columnshard/engines/changes/abstract/compaction_info.h
@@ -14,7 +14,7 @@ class TGranuleMeta;
 
 class TPlanCompactionInfo {
 private:
-    TInternalPathId PathId;
+    TUnifiedPathId PathId;
     TMonotonic StartTime = TMonotonic::Now();
     TPositiveControlInteger Count;
 
@@ -30,11 +30,11 @@ class TPlanCompactionInfo {
         return StartTime;
     }
 
-    TPlanCompactionInfo(const TInternalPathId pathId)
+    TPlanCompactionInfo(const TUnifiedPathId& pathId)
         : PathId(pathId) {
     }
 
-    TInternalPathId GetPathId() const {
+    TUnifiedPathId GetPathId() const {
         return PathId;
     }
 };
diff --git a/ydb/core/tx/columnshard/engines/changes/compaction.cpp b/ydb/core/tx/columnshard/engines/changes/compaction.cpp
index 40f08e502b8b..22f0094e4e49 100644
--- a/ydb/core/tx/columnshard/engines/changes/compaction.cpp
+++ b/ydb/core/tx/columnshard/engines/changes/compaction.cpp
@@ -32,7 +32,7 @@ void TCompactColumnEngineChanges::DoCompile(TFinalizationContext& context) {
 void TCompactColumnEngineChanges::DoStart(NColumnShard::TColumnShard& self) {
     TBase::DoStart(self);
 
-    self.BackgroundController.StartCompaction(NKikimr::NOlap::TPlanCompactionInfo(GranuleMeta->GetPathId()));
+    self.BackgroundController.StartCompaction(NKikimr::NOlap::TPlanCompactionInfo({GranuleMeta->GetPathId(), GranuleMeta->GetLocalPathId()}));
     NeedGranuleStatusProvide = true;
     GranuleMeta->OnCompactionStarted();
 }
@@ -45,7 +45,7 @@ void TCompactColumnEngineChanges::DoWriteIndexOnComplete(NColumnShard::TColumnSh
 }
 
 void TCompactColumnEngineChanges::DoOnFinish(NColumnShard::TColumnShard& self, TChangesFinishContext& context) {
-    self.BackgroundController.FinishCompaction(TPlanCompactionInfo(GranuleMeta->GetPathId()));
+    self.BackgroundController.FinishCompaction(TPlanCompactionInfo({GranuleMeta->GetPathId(), GranuleMeta->GetLocalPathId()}));
     Y_ABORT_UNLESS(NeedGranuleStatusProvide);
     if (context.FinishedSuccessfully) {
         GranuleMeta->OnCompactionFinished();
diff --git a/ydb/core/tx/columnshard/engines/column_engine.h b/ydb/core/tx/columnshard/engines/column_engine.h
index b7ef4f5f4edb..64ebc1a28336 100644
--- a/ydb/core/tx/columnshard/engines/column_engine.h
+++ b/ydb/core/tx/columnshard/engines/column_engine.h
@@ -85,7 +85,7 @@ class TCSMetadataRequest {
 
 class IColumnEngine {
 protected:
-    virtual void DoRegisterTable(const TInternalPathId pathId) = 0;
+    virtual void DoRegisterTable(const TUnifiedPathId& pathId) = 0;
     virtual void DoFetchDataAccessors(const std::shared_ptr<TDataAccessorsRequest>& request) const = 0;
 
 public:
@@ -140,7 +140,7 @@ class IColumnEngine {
     virtual bool HasDataInPathId(const TInternalPathId pathId) const = 0;
     virtual bool ErasePathId(const TInternalPathId pathId) = 0;
     virtual std::shared_ptr<ITxReader> BuildLoader(const std::shared_ptr<IBlobGroupSelector>& dsGroupSelector) = 0;
-    void RegisterTable(const TInternalPathId pathId) {
+    void RegisterTable(const TUnifiedPathId& pathId) {
         AFL_DEBUG(NKikimrServices::TX_COLUMNSHARD)("event", "RegisterTable")("path_id", pathId);
         return DoRegisterTable(pathId);
     }
diff --git a/ydb/core/tx/columnshard/engines/column_engine_logs.cpp b/ydb/core/tx/columnshard/engines/column_engine_logs.cpp
index 2a9dd4be6677..717aed5b90e1 100644
--- a/ydb/core/tx/columnshard/engines/column_engine_logs.cpp
+++ b/ydb/core/tx/columnshard/engines/column_engine_logs.cpp
@@ -506,7 +506,7 @@ void TColumnEngineForLogs::OnTieringModified(const THashMap<TInternalPathId, NOl
     }
 }
 
-void TColumnEngineForLogs::DoRegisterTable(const TInternalPathId pathId) {
+void TColumnEngineForLogs::DoRegisterTable(const TUnifiedPathId& pathId) {
     std::shared_ptr<TGranuleMeta> g = GranulesStorage->RegisterTable(pathId, SignalCounters.RegisterGranuleDataCounters(), VersionedIndex);
     if (ActualizationStarted) {
         g->StartActualizationIndex();
diff --git a/ydb/core/tx/columnshard/engines/column_engine_logs.h b/ydb/core/tx/columnshard/engines/column_engine_logs.h
index 89a1838a3015..5d17acf7d415 100644
--- a/ydb/core/tx/columnshard/engines/column_engine_logs.h
+++ b/ydb/core/tx/columnshard/engines/column_engine_logs.h
@@ -125,7 +125,7 @@ class TColumnEngineForLogs: public IColumnEngine {
         return LastSnapshot;
     }
 
-    virtual void DoRegisterTable(const TInternalPathId pathId) override;
+    virtual void DoRegisterTable(const TUnifiedPathId& pathId) override;
     void DoFetchDataAccessors(const std::shared_ptr<TDataAccessorsRequest>& request) const override {
         GranulesStorage->FetchDataAccessors(request);
     }
@@ -207,7 +207,7 @@ class TColumnEngineForLogs: public IColumnEngine {
         return GranulesStorage->GetGranuleOptional(pathId);
     }
 
-    std::vector<std::shared_ptr<TGranuleMeta>> GetTables(const std::optional<TInternalPathId> pathIdFrom, const std::optional<TInternalPathId> pathIdTo) const {
+    std::vector<std::shared_ptr<TGranuleMeta>> GetTables(const std::optional<TLocalPathId> pathIdFrom, const std::optional<TLocalPathId> pathIdTo) const {
         return GranulesStorage->GetTables(pathIdFrom, pathIdTo);
     }
 
diff --git a/ydb/core/tx/columnshard/engines/db_wrapper.h b/ydb/core/tx/columnshard/engines/db_wrapper.h
index 457d89589ae4..14d355a18d0d 100644
--- a/ydb/core/tx/columnshard/engines/db_wrapper.h
+++ b/ydb/core/tx/columnshard/engines/db_wrapper.h
@@ -89,6 +89,7 @@ class TDbWrapper : public IDbWrapper {
 
     void WriteColumn(const NOlap::TPortionInfo& portion, const TColumnRecord& row, const ui32 firstPKColumnId) override;
     void WriteColumns(const NOlap::TPortionInfo& portion, const NKikimrTxColumnShard::TIndexPortionAccessor& proto) override;
+
     void EraseColumn(const NOlap::TPortionInfo& portion, const TColumnRecord& row) override;
     bool LoadColumns(const std::optional<TInternalPathId> pathId, const std::function<void(TColumnChunkLoadContextV2&&)>& callback) override;
 
diff --git a/ydb/core/tx/columnshard/engines/reader/sys_view/abstract/filler.cpp b/ydb/core/tx/columnshard/engines/reader/sys_view/abstract/filler.cpp
index e0c8e955afab..7b72af921ba7 100644
--- a/ydb/core/tx/columnshard/engines/reader/sys_view/abstract/filler.cpp
+++ b/ydb/core/tx/columnshard/engines/reader/sys_view/abstract/filler.cpp
@@ -15,11 +15,11 @@ NKikimr::TConclusionStatus TMetadataFromStore::DoFillMetadata(const NColumnShard
         return TConclusionStatus::Success();
     }
 
-    THashSet<TInternalPathId> pathIds;
+    THashSet< TInternalPathId> pathIds;
     AFL_VERIFY(read.PKRangesFilter);
     for (auto&& filter : *read.PKRangesFilter) {
-        const auto fromPathId = TInternalPathId::FromRawValue(*filter.GetPredicateFrom().Get<arrow::UInt64Array>(0, 0, 1));
-        const auto toPathId = TInternalPathId::FromRawValue(*filter.GetPredicateTo().Get<arrow::UInt64Array>(0, 0, Max<ui64>()));
+        const auto fromPathId = TLocalPathId::FromRawValue(*filter.GetPredicateFrom().Get<arrow::UInt64Array>(0, 0, 1));
+        const auto toPathId = TLocalPathId::FromRawValue(*filter.GetPredicateTo().Get<arrow::UInt64Array>(0, 0, Max<ui64>()));
         auto pathInfos = logsIndex->GetTables(fromPathId, toPathId);
         for (auto&& pathInfo : pathInfos) {
             if (pathIds.emplace(pathInfo->GetPathId()).second) {
diff --git a/ydb/core/tx/columnshard/engines/reader/sys_view/abstract/granule_view.h b/ydb/core/tx/columnshard/engines/reader/sys_view/abstract/granule_view.h
index cb3e2b370ac7..efe8d0d345f2 100644
--- a/ydb/core/tx/columnshard/engines/reader/sys_view/abstract/granule_view.h
+++ b/ydb/core/tx/columnshard/engines/reader/sys_view/abstract/granule_view.h
@@ -8,12 +8,12 @@ namespace NKikimr::NOlap::NReader::NSysView::NAbstract {
 class TGranuleMetaView {
 private:
     using TPortions = std::deque<std::shared_ptr<TPortionInfo>>;
-    YDB_READONLY_DEF(TInternalPathId, PathId);
+    YDB_READONLY_DEF(TUnifiedPathId, PathId);
     YDB_READONLY_DEF(TPortions, Portions);
     YDB_READONLY_DEF(std::vector<NStorageOptimizer::TTaskDescription>, OptimizerTasks);
 public:
     TGranuleMetaView(const TGranuleMeta& granule, const bool reverse, const TSnapshot& reqSnapshot)
-        : PathId(granule.GetPathId())
+        : PathId({granule.GetPathId(), granule.GetLocalPathId()})
     {
         for (auto&& i : granule.GetPortions()) {
             if (i.second->IsRemovedFor(reqSnapshot)) {
diff --git a/ydb/core/tx/columnshard/engines/reader/sys_view/chunks/chunks.cpp b/ydb/core/tx/columnshard/engines/reader/sys_view/chunks/chunks.cpp
index 1d834877ba1c..3bb123e87ac4 100644
--- a/ydb/core/tx/columnshard/engines/reader/sys_view/chunks/chunks.cpp
+++ b/ydb/core/tx/columnshard/engines/reader/sys_view/chunks/chunks.cpp
@@ -6,8 +6,10 @@
 namespace NKikimr::NOlap::NReader::NSysView::NChunks {
 
 void TStatsIterator::AppendStats(
+    const TUnifiedPathId& pathId,
     const std::vector<std::unique_ptr<arrow::ArrayBuilder>>& builders, const TPortionDataAccessor& portionPtr) const {
     const TPortionInfo& portion = portionPtr.GetPortionInfo();
+    AFL_VERIFY(pathId.GetInternalPathId() == portion.GetPathId());
     auto portionSchema = ReadMetadata->GetLoadSchemaVerified(portion);
     auto it = PortionType.find(portion.GetMeta().Produced);
     if (it == PortionType.end()) {
@@ -35,7 +37,7 @@ void TStatsIterator::AppendStats(
         arrow::util::string_view lastColumnName;
         arrow::util::string_view lastTierName;
         for (auto&& r : records) {
-            NArrow::Append<arrow::UInt64Type>(*builders[0], portion.GetPathId().GetRawValue());
+            NArrow::Append<arrow::UInt64Type>(*builders[0], pathId.GetLocalPathId().GetRawValue());
             NArrow::Append<arrow::StringType>(*builders[1], prodView);
             NArrow::Append<arrow::UInt64Type>(*builders[2], ReadMetadata->TabletId);
             NArrow::Append<arrow::UInt64Type>(*builders[3], r->GetMeta().GetRecordsCount());
@@ -92,7 +94,7 @@ void TStatsIterator::AppendStats(
             std::reverse(indexes.begin(), indexes.end());
         }
         for (auto&& r : indexes) {
-            NArrow::Append<arrow::UInt64Type>(*builders[0], portion.GetPathId().GetRawValue());
+            NArrow::Append<arrow::UInt64Type>(*builders[0], pathId.GetLocalPathId().GetRawValue());
             NArrow::Append<arrow::StringType>(*builders[1], prodView);
             NArrow::Append<arrow::UInt64Type>(*builders[2], ReadMetadata->TabletId);
             NArrow::Append<arrow::UInt64Type>(*builders[3], r->GetRecordsCount());
@@ -143,7 +145,7 @@ bool TStatsIterator::AppendStats(const std::vector<std::unique_ptr<arrow::ArrayB
             break;
         }
         recordsCount += it->second.GetRecordsVerified().size() + it->second.GetIndexesVerified().size();
-        AppendStats(builders, it->second);
+        AppendStats(granule.GetPathId(), builders, it->second);
         granule.PopFrontPortion();
         FetchedAccessors.erase(it);
         if (recordsCount > 10000) {
diff --git a/ydb/core/tx/columnshard/engines/reader/sys_view/chunks/chunks.h b/ydb/core/tx/columnshard/engines/reader/sys_view/chunks/chunks.h
index c09a4f6d448b..b538a4fcce85 100644
--- a/ydb/core/tx/columnshard/engines/reader/sys_view/chunks/chunks.h
+++ b/ydb/core/tx/columnshard/engines/reader/sys_view/chunks/chunks.h
@@ -68,7 +68,7 @@ class TStatsIterator: public NAbstract::TStatsIterator<NKikimr::NSysView::Schema
     virtual bool AppendStats(
         const std::vector<std::unique_ptr<arrow::ArrayBuilder>>& builders, NAbstract::TGranuleMetaView& granule) const override;
     virtual ui32 PredictRecordsCount(const NAbstract::TGranuleMetaView& granule) const override;
-    void AppendStats(const std::vector<std::unique_ptr<arrow::ArrayBuilder>>& builders, const TPortionDataAccessor& portion) const;
+    void AppendStats(const TUnifiedPathId& pathId, const std::vector<std::unique_ptr<arrow::ArrayBuilder>>& builders, const TPortionDataAccessor& portion) const;
 
     class TApplyResult: public IDataTasksProcessor::ITask {
     private:
diff --git a/ydb/core/tx/columnshard/engines/reader/sys_view/granules/granules.cpp b/ydb/core/tx/columnshard/engines/reader/sys_view/granules/granules.cpp
index 0144236ed3f8..3f6928c57f86 100644
--- a/ydb/core/tx/columnshard/engines/reader/sys_view/granules/granules.cpp
+++ b/ydb/core/tx/columnshard/engines/reader/sys_view/granules/granules.cpp
@@ -9,7 +9,7 @@
 namespace NKikimr::NOlap::NReader::NSysView::NGranules {
 
 bool TStatsIterator::AppendStats(const std::vector<std::unique_ptr<arrow::ArrayBuilder>>& builders, NAbstract::TGranuleMetaView& granule) const {
-    NArrow::Append<arrow::UInt64Type>(*builders[0], granule.GetPathId().GetRawValue());
+    NArrow::Append<arrow::UInt64Type>(*builders[0], granule.GetPathId().GetLocalPathId().GetRawValue());
     NArrow::Append<arrow::UInt64Type>(*builders[1], ReadMetadata->TabletId);
     NArrow::Append<arrow::UInt64Type>(*builders[2], granule.GetPortions().size());
     NArrow::Append<arrow::StringType>(*builders[3], HostNameField);
diff --git a/ydb/core/tx/columnshard/engines/reader/sys_view/optimizer/optimizer.cpp b/ydb/core/tx/columnshard/engines/reader/sys_view/optimizer/optimizer.cpp
index 30ddcb83dc3d..648692fa050b 100644
--- a/ydb/core/tx/columnshard/engines/reader/sys_view/optimizer/optimizer.cpp
+++ b/ydb/core/tx/columnshard/engines/reader/sys_view/optimizer/optimizer.cpp
@@ -10,7 +10,7 @@ namespace NKikimr::NOlap::NReader::NSysView::NOptimizer {
 
 bool TStatsIterator::AppendStats(const std::vector<std::unique_ptr<arrow::ArrayBuilder>>& builders, NAbstract::TGranuleMetaView& granule) const {
     for (auto&& i : granule.GetOptimizerTasks()) {
-        NArrow::Append<arrow::UInt64Type>(*builders[0], granule.GetPathId().GetRawValue());
+        NArrow::Append<arrow::UInt64Type>(*builders[0], granule.GetPathId().GetLocalPathId().GetRawValue());
         NArrow::Append<arrow::UInt64Type>(*builders[1], ReadMetadata->TabletId);
         NArrow::Append<arrow::UInt64Type>(*builders[2], i.GetTaskId());
         NArrow::Append<arrow::StringType>(*builders[3], HostNameField);
diff --git a/ydb/core/tx/columnshard/engines/reader/sys_view/portions/portions.cpp b/ydb/core/tx/columnshard/engines/reader/sys_view/portions/portions.cpp
index 267b0cfbbd58..cecc07992b3b 100644
--- a/ydb/core/tx/columnshard/engines/reader/sys_view/portions/portions.cpp
+++ b/ydb/core/tx/columnshard/engines/reader/sys_view/portions/portions.cpp
@@ -6,8 +6,9 @@
 
 namespace NKikimr::NOlap::NReader::NSysView::NPortions {
 
-void TStatsIterator::AppendStats(const std::vector<std::unique_ptr<arrow::ArrayBuilder>>& builders, const TPortionInfo& portion) const {
-    NArrow::Append<arrow::UInt64Type>(*builders[0], portion.GetPathId().GetRawValue());
+void TStatsIterator::AppendStats(const TUnifiedPathId& pathId, const std::vector<std::unique_ptr<arrow::ArrayBuilder>>& builders, const TPortionInfo& portion) const {
+    AFL_VERIFY(pathId.GetInternalPathId() == portion.GetPathId());
+    NArrow::Append<arrow::UInt64Type>(*builders[0], pathId.GetLocalPathId().GetRawValue());
     const std::string prod = ::ToString(portion.GetMeta().Produced);
     NArrow::Append<arrow::StringType>(*builders[1], prod);
     NArrow::Append<arrow::UInt64Type>(*builders[2], ReadMetadata->TabletId);
@@ -45,7 +46,7 @@ bool TStatsIterator::AppendStats(const std::vector<std::unique_ptr<arrow::ArrayB
     ui64 recordsCount = 0;
     while (auto portion = granule.PopFrontPortion()) {
         recordsCount += 1;
-        AppendStats(builders, *portion);
+        AppendStats(granule.GetPathId(), builders, *portion);
         if (recordsCount >= 10000) {
             break;
         }
diff --git a/ydb/core/tx/columnshard/engines/reader/sys_view/portions/portions.h b/ydb/core/tx/columnshard/engines/reader/sys_view/portions/portions.h
index 9f5fd67fb8c9..180e33eef990 100644
--- a/ydb/core/tx/columnshard/engines/reader/sys_view/portions/portions.h
+++ b/ydb/core/tx/columnshard/engines/reader/sys_view/portions/portions.h
@@ -31,7 +31,7 @@ class TStatsIterator : public NAbstract::TStatsIterator<NKikimr::NSysView::Schem
     using TBase = NAbstract::TStatsIterator<NKikimr::NSysView::Schema::PrimaryIndexPortionStats>;
     virtual bool AppendStats(const std::vector<std::unique_ptr<arrow::ArrayBuilder>>& builders, NAbstract::TGranuleMetaView& granule) const override;
     virtual ui32 PredictRecordsCount(const NAbstract::TGranuleMetaView& granule) const override;
-    void AppendStats(const std::vector<std::unique_ptr<arrow::ArrayBuilder>>& builders, const TPortionInfo& portion) const;
+    void AppendStats(const TUnifiedPathId& pathId, const std::vector<std::unique_ptr<arrow::ArrayBuilder>>& builders, const TPortionInfo& portion) const;
 public:
     using TBase::TBase;
 };
diff --git a/ydb/core/tx/columnshard/engines/reader/sys_view/tables/tables.cpp b/ydb/core/tx/columnshard/engines/reader/sys_view/tables/tables.cpp
new file mode 100644
index 000000000000..3653715a969e
--- /dev/null
+++ b/ydb/core/tx/columnshard/engines/reader/sys_view/tables/tables.cpp
@@ -0,0 +1,33 @@
+#include "tables.h"
+#include <ydb/core/formats/arrow/switch/switch_type.h>
+#include <ydb/core/tx/columnshard/blobs_action/common/const.h>
+#include <ydb/core/tx/columnshard/engines/reader/abstract/read_context.h>
+
+namespace NKikimr::NOlap::NReader::NSysView::NTables {
+
+ui32 TStatsIterator::PredictRecordsCount(const NAbstract::TGranuleMetaView& /* granule */) const {
+    return 100;
+}
+
+bool TStatsIterator::AppendStats(const std::vector<std::unique_ptr<arrow::ArrayBuilder>>& builders, NAbstract::TGranuleMetaView& granule) const {
+    NArrow::Append<arrow::UInt64Type>(*builders[0], granule.GetPathId().GetInternalPathId().GetRawValue());
+    NArrow::Append<arrow::UInt64Type>(*builders[1], ReadMetadata->TabletId);
+    NArrow::Append<arrow::UInt64Type>(*builders[2], granule.GetPathId().GetLocalPathId().GetRawValue());
+    return false;
+}
+
+std::unique_ptr<TScanIteratorBase> TReadStatsMetadata::StartScan(const std::shared_ptr<TReadContext>& readContext) const {
+    return std::make_unique<TStatsIterator>(readContext);
+}
+
+std::vector<std::pair<TString, NKikimr::NScheme::TTypeInfo>> TReadStatsMetadata::GetKeyYqlSchema() const {
+    return GetColumns(TStatsIterator::StatsSchema, TStatsIterator::StatsSchema.KeyColumns);
+}
+
+std::shared_ptr<NAbstract::TReadStatsMetadata> TConstructor::BuildMetadata(const NColumnShard::TColumnShard* self, const TReadDescription& read) const {
+    auto* index = self->GetIndexOptional();
+    return std::make_shared<TReadStatsMetadata>(index ? index->CopyVersionedIndexPtr() : nullptr, self->TabletID(), Sorting, read.GetProgram(),
+        index ? index->GetVersionedIndex().GetLastSchema() : nullptr, read.GetSnapshot());
+}
+
+}
diff --git a/ydb/core/tx/columnshard/engines/reader/sys_view/tables/tables.h b/ydb/core/tx/columnshard/engines/reader/sys_view/tables/tables.h
new file mode 100644
index 000000000000..5bfc18ece8f8
--- /dev/null
+++ b/ydb/core/tx/columnshard/engines/reader/sys_view/tables/tables.h
@@ -0,0 +1,53 @@
+#pragma once
+#include <ydb/core/sys_view/common/schema.h>
+#include <ydb/core/tx/columnshard/engines/reader/sys_view/abstract/iterator.h>
+#include <ydb/core/tx/columnshard/engines/reader/sys_view/constructor/constructor.h>
+
+namespace NKikimr::NOlap::NReader::NSysView::NTables {
+
+class TConstructor: public TStatScannerConstructor<NKikimr::NSysView::Schema::TablePathIdMapping> {
+private:
+    using TBase = TStatScannerConstructor<NKikimr::NSysView::Schema::TablePathIdMapping>;
+protected:
+    virtual std::shared_ptr<NAbstract::TReadStatsMetadata> BuildMetadata(const NColumnShard::TColumnShard* self, const TReadDescription& read) const override;
+
+public:
+    using TBase::TBase;
+};
+
+struct TReadStatsMetadata: public NAbstract::TReadStatsMetadata {
+private:
+    using TBase = NAbstract::TReadStatsMetadata;
+    using TSysViewSchema = NKikimr::NSysView::Schema::TablePathIdMapping;
+public:
+    using TBase::TBase;
+
+    virtual std::unique_ptr<TScanIteratorBase> StartScan(const std::shared_ptr<TReadContext>& readContext) const override;
+    virtual std::vector<std::pair<TString, NScheme::TTypeInfo>> GetKeyYqlSchema() const override;
+};
+
+class TStatsIterator : public NAbstract::TStatsIterator<NKikimr::NSysView::Schema::TablePathIdMapping> {
+private:
+    using TBase = NAbstract::TStatsIterator<NKikimr::NSysView::Schema::TablePathIdMapping>;
+    virtual bool AppendStats(const std::vector<std::unique_ptr<arrow::ArrayBuilder>>& builders, NAbstract::TGranuleMetaView& granule) const override;
+    virtual ui32 PredictRecordsCount(const NAbstract::TGranuleMetaView& granule) const override;
+    void AppendStats(const std::vector<std::unique_ptr<arrow::ArrayBuilder>>& builders, const TPortionInfo& portion) const;
+public:
+    using TBase::TBase;
+};
+
+
+class TTableSysViewPolicy: public NAbstract::ISysViewPolicy {
+protected:
+    virtual std::unique_ptr<IScannerConstructor> DoCreateConstructor(const TScannerConstructorContext& request) const override {
+        return std::make_unique<TConstructor>(request);
+    }
+    virtual std::shared_ptr<NAbstract::IMetadataFiller> DoCreateMetadataFiller() const override {
+        return std::make_shared<NAbstract::TMetadataFromTable>();
+    }
+public:
+    static const inline TFactory::TRegistrator<TTableSysViewPolicy> Registrator = TFactory::TRegistrator<TTableSysViewPolicy>(TString(::NKikimr::NSysView::TablePathIdMappingName));
+
+};
+
+}
diff --git a/ydb/core/tx/columnshard/engines/reader/sys_view/tables/ya.make b/ydb/core/tx/columnshard/engines/reader/sys_view/tables/ya.make
new file mode 100644
index 000000000000..3d3dc5e82c21
--- /dev/null
+++ b/ydb/core/tx/columnshard/engines/reader/sys_view/tables/ya.make
@@ -0,0 +1,12 @@
+LIBRARY()
+
+PEERDIR(
+    ydb/core/tx/columnshard/engines/reader/sys_view/abstract
+)
+
+SRCS(
+    GLOBAL tables.cpp
+)
+
+END()
+
diff --git a/ydb/core/tx/columnshard/engines/reader/sys_view/ya.make b/ydb/core/tx/columnshard/engines/reader/sys_view/ya.make
index 89d9623dd8a0..fc852c506efe 100644
--- a/ydb/core/tx/columnshard/engines/reader/sys_view/ya.make
+++ b/ydb/core/tx/columnshard/engines/reader/sys_view/ya.make
@@ -7,6 +7,7 @@ PEERDIR(
     ydb/core/tx/columnshard/engines/reader/sys_view/constructor
     ydb/core/tx/columnshard/engines/reader/sys_view/granules
     ydb/core/tx/columnshard/engines/reader/sys_view/optimizer
+    ydb/core/tx/columnshard/engines/reader/sys_view/tables
 )
 
 SRCS(
diff --git a/ydb/core/tx/columnshard/engines/reader/transaction/tx_scan.cpp b/ydb/core/tx/columnshard/engines/reader/transaction/tx_scan.cpp
index 0982f11e1a92..27b59466046c 100644
--- a/ydb/core/tx/columnshard/engines/reader/transaction/tx_scan.cpp
+++ b/ydb/core/tx/columnshard/engines/reader/transaction/tx_scan.cpp
@@ -69,7 +69,7 @@ void TTxScan::Complete(const TActorContext& ctx) {
         if (request.HasLockTxId()) {
             read.LockId = request.GetLockTxId();
         }
-        read.PathId = TInternalPathId::FromRawValue(request.GetLocalPathId());
+        read.PathId = InternalPathId;
         read.ReadNothing = !Self->TablesManager.HasTable(read.PathId);
         read.TableName = table;
 
diff --git a/ydb/core/tx/columnshard/engines/reader/transaction/tx_scan.h b/ydb/core/tx/columnshard/engines/reader/transaction/tx_scan.h
index 41700df3dee1..591d8a1012f9 100644
--- a/ydb/core/tx/columnshard/engines/reader/transaction/tx_scan.h
+++ b/ydb/core/tx/columnshard/engines/reader/transaction/tx_scan.h
@@ -12,9 +12,10 @@ class TTxScan: public NTabletFlatExecutor::TTransactionBase<NColumnShard::TColum
 public:
     using TReadMetadataPtr = TReadMetadataBase::TConstPtr;
 
-    TTxScan(NColumnShard::TColumnShard* self, TEvDataShard::TEvKqpScan::TPtr& ev)
+    TTxScan(NColumnShard::TColumnShard* self, TEvDataShard::TEvKqpScan::TPtr& ev, const TInternalPathId internalPathId)
         : TBase(self)
-        , Ev(ev) {
+        , Ev(ev)
+        , InternalPathId(internalPathId) {
     }
 
     bool Execute(TTransactionContext& txc, const TActorContext& ctx) override;
@@ -25,6 +26,7 @@ class TTxScan: public NTabletFlatExecutor::TTransactionBase<NColumnShard::TColum
 
 private:
     TEvDataShard::TEvKqpScan::TPtr Ev;
+    const TInternalPathId InternalPathId;
 };
 
 }   // namespace NKikimr::NOlap::NReader
diff --git a/ydb/core/tx/columnshard/engines/storage/granule/granule.cpp b/ydb/core/tx/columnshard/engines/storage/granule/granule.cpp
index 651b83e8c7ff..05c784ddf1b1 100644
--- a/ydb/core/tx/columnshard/engines/storage/granule/granule.cpp
+++ b/ydb/core/tx/columnshard/engines/storage/granule/granule.cpp
@@ -134,7 +134,7 @@ const NKikimr::NOlap::TGranuleAdditiveSummary& TGranuleMeta::GetAdditiveSummary(
 }
 
 TGranuleMeta::TGranuleMeta(
-    const TInternalPathId pathId, const TGranulesStorage& owner, const NColumnShard::TGranuleDataCounters& counters, const TVersionedIndex& versionedIndex)
+    const TUnifiedPathId pathId, const TGranulesStorage& owner, const NColumnShard::TGranuleDataCounters& counters, const TVersionedIndex& versionedIndex)
     : PathId(pathId)
     , DataAccessorsManager(owner.GetDataAccessorsManager())
     , Counters(counters)
@@ -143,12 +143,12 @@ TGranuleMeta::TGranuleMeta(
     , StoragesManager(owner.GetStoragesManager())
     , PortionsIndex(*this, Counters.GetPortionsIndexCounters()) {
     NStorageOptimizer::IOptimizerPlannerConstructor::TBuildContext context(
-        PathId, owner.GetStoragesManager(), versionedIndex.GetLastSchema()->GetIndexInfo().GetPrimaryKey());
+        PathId.GetInternalPathId(), owner.GetStoragesManager(), versionedIndex.GetLastSchema()->GetIndexInfo().GetPrimaryKey());
     OptimizerPlanner = versionedIndex.GetLastSchema()->GetIndexInfo().GetCompactionPlannerConstructor()->BuildPlanner(context).DetachResult();
     NDataAccessorControl::TManagerConstructionContext mmContext(DataAccessorsManager->GetTabletActorId(), false);
     ResetAccessorsManager(versionedIndex.GetLastSchema()->GetIndexInfo().GetMetadataManagerConstructor(), mmContext);
     AFL_VERIFY(!!OptimizerPlanner);
-    ActualizationIndex = std::make_unique<NActualizer::TGranuleActualizationIndex>(PathId, versionedIndex, StoragesManager);
+    ActualizationIndex = std::make_unique<NActualizer::TGranuleActualizationIndex>(PathId.GetInternalPathId(), versionedIndex, StoragesManager);
 }
 
 void TGranuleMeta::UpsertPortionOnLoad(const std::shared_ptr<TPortionInfo>& portion) {
@@ -175,7 +175,7 @@ void TGranuleMeta::BuildActualizationTasks(NActualizer::TTieringProcessContext&
 void TGranuleMeta::ResetAccessorsManager(const std::shared_ptr<NDataAccessorControl::IManagerConstructor>& constructor,
     const NDataAccessorControl::TManagerConstructionContext& context) {
     MetadataMemoryManager = constructor->Build(context).DetachResult();
-    DataAccessorsManager->RegisterController(MetadataMemoryManager->BuildCollector(PathId), context.IsUpdate());
+    DataAccessorsManager->RegisterController(MetadataMemoryManager->BuildCollector(PathId.GetInternalPathId()), context.IsUpdate());
 }
 
 void TGranuleMeta::ResetOptimizer(const std::shared_ptr<NStorageOptimizer::IOptimizerPlannerConstructor>& constructor,
@@ -183,7 +183,7 @@ void TGranuleMeta::ResetOptimizer(const std::shared_ptr<NStorageOptimizer::IOpti
     if (constructor->ApplyToCurrentObject(OptimizerPlanner)) {
         return;
     }
-    NStorageOptimizer::IOptimizerPlannerConstructor::TBuildContext context(PathId, storages, pkSchema);
+    NStorageOptimizer::IOptimizerPlannerConstructor::TBuildContext context(PathId.GetInternalPathId(), storages, pkSchema);
     OptimizerPlanner = constructor->BuildPlanner(context).DetachResult();
     AFL_VERIFY(!!OptimizerPlanner);
     THashMap<ui64, std::shared_ptr<TPortionInfo>> portions;
@@ -234,7 +234,7 @@ std::shared_ptr<NKikimr::ITxReader> TGranuleMeta::BuildLoader(
 bool TGranuleMeta::TestingLoad(IDbWrapper& db, const TVersionedIndex& versionedIndex) {
     TInGranuleConstructors constructors;
     {
-        if (!db.LoadPortions(PathId, [&](TPortionInfoConstructor&& portion, const NKikimrTxColumnShard::TIndexPortionMeta& metaProto) {
+        if (!db.LoadPortions(PathId.GetInternalPathId(), [&](TPortionInfoConstructor&& portion, const NKikimrTxColumnShard::TIndexPortionMeta& metaProto) {
                 const TIndexInfo& indexInfo = portion.GetSchema(versionedIndex)->GetIndexInfo();
                 AFL_VERIFY(portion.MutableMeta().LoadMetadata(metaProto, indexInfo, db.GetDsGroupSelectorVerified()));
                 AFL_VERIFY(constructors.AddConstructorVerified(std::move(portion)));
@@ -245,7 +245,7 @@ bool TGranuleMeta::TestingLoad(IDbWrapper& db, const TVersionedIndex& versionedI
 
     {
         TPortionInfo::TSchemaCursor schema(versionedIndex);
-        if (!db.LoadColumns(PathId, [&](TColumnChunkLoadContextV2&& loadContext) {
+        if (!db.LoadColumns(PathId.GetInternalPathId(), [&](TColumnChunkLoadContextV2&& loadContext) {
                 auto* constructor = constructors.GetConstructorVerified(loadContext.GetPortionId());
                 for (auto&& i : loadContext.BuildRecordsV1()) {
                     constructor->LoadRecord(std::move(i));
@@ -256,7 +256,7 @@ bool TGranuleMeta::TestingLoad(IDbWrapper& db, const TVersionedIndex& versionedI
     }
 
     {
-        if (!db.LoadIndexes(PathId, [&](const TInternalPathId /*pathId*/, const ui64 portionId, TIndexChunkLoadContext&& loadContext) {
+        if (!db.LoadIndexes(PathId.GetInternalPathId(), [&](const TInternalPathId /*pathId*/, const ui64 portionId, TIndexChunkLoadContext&& loadContext) {
                 auto* constructor = constructors.GetConstructorVerified(portionId);
                 constructor->LoadIndex(std::move(loadContext));
             })) {
diff --git a/ydb/core/tx/columnshard/engines/storage/granule/granule.h b/ydb/core/tx/columnshard/engines/storage/granule/granule.h
index 0f2a02c135a3..b0bb48410fe0 100644
--- a/ydb/core/tx/columnshard/engines/storage/granule/granule.h
+++ b/ydb/core/tx/columnshard/engines/storage/granule/granule.h
@@ -126,7 +126,7 @@ class TGranuleMeta: TNonCopyable {
     void RebuildAdditiveMetrics() const;
 
     mutable bool AllowInsertionFlag = false;
-    const TInternalPathId PathId;
+    const TUnifiedPathId PathId;
     std::shared_ptr<NDataAccessorControl::IDataAccessorsManager> DataAccessorsManager;
     const NColumnShard::TGranuleDataCounters Counters;
     NColumnShard::TEngineLogsCounters::TPortionsInfoGuard PortionInfoGuard;
@@ -179,7 +179,7 @@ class TGranuleMeta: TNonCopyable {
     std::unique_ptr<NDataAccessorControl::IGranuleDataAccessor> BuildDataAccessor() {
         AFL_VERIFY(!DataAccessorConstructed);
         DataAccessorConstructed = true;
-        return MetadataMemoryManager->BuildCollector(PathId);
+        return MetadataMemoryManager->BuildCollector(PathId.GetInternalPathId());
     }
 
     void RefreshTiering(const std::optional<TTiering>& tiering) {
@@ -366,7 +366,11 @@ class TGranuleMeta: TNonCopyable {
     }
 
     TInternalPathId GetPathId() const {
-        return PathId;
+        return PathId.GetInternalPathId();
+    }
+
+    TLocalPathId GetLocalPathId() const {
+        return PathId.GetLocalPathId();
     }
 
     const TPortionInfo& GetPortionVerified(const ui64 portion) const {
@@ -385,7 +389,7 @@ class TGranuleMeta: TNonCopyable {
 
     bool ErasePortion(const ui64 portion);
 
-    explicit TGranuleMeta(const TInternalPathId pathId, const TGranulesStorage& owner, const NColumnShard::TGranuleDataCounters& counters,
+    explicit TGranuleMeta(const TUnifiedPathId pathId, const TGranulesStorage& owner, const NColumnShard::TGranuleDataCounters& counters,
         const TVersionedIndex& versionedIndex);
 
     bool Empty() const noexcept {
diff --git a/ydb/core/tx/columnshard/engines/storage/granule/storage.h b/ydb/core/tx/columnshard/engines/storage/granule/storage.h
index b22f9f0c089e..0afd23e4ca98 100644
--- a/ydb/core/tx/columnshard/engines/storage/granule/storage.h
+++ b/ydb/core/tx/columnshard/engines/storage/granule/storage.h
@@ -139,8 +139,8 @@ class TGranulesStorage {
     }
 
     std::shared_ptr<TGranuleMeta> RegisterTable(
-        const TInternalPathId pathId, const NColumnShard::TGranuleDataCounters& counters, const TVersionedIndex& versionedIndex) {
-        auto infoEmplace = Tables.emplace(pathId, std::make_shared<TGranuleMeta>(pathId, *this, counters, versionedIndex));
+        const TUnifiedPathId pathId, const NColumnShard::TGranuleDataCounters& counters, const TVersionedIndex& versionedIndex) {
+        auto infoEmplace = Tables.emplace(pathId.GetInternalPathId(), std::make_shared<TGranuleMeta>(pathId, *this, counters, versionedIndex));
         AFL_VERIFY(infoEmplace.second);
         return infoEmplace.first->second;
     }
@@ -170,16 +170,16 @@ class TGranulesStorage {
         }
     }
 
-    std::vector<std::shared_ptr<TGranuleMeta>> GetTables(const std::optional<TInternalPathId> pathIdFrom, const std::optional<TInternalPathId> pathIdTo) const {
+    std::vector<std::shared_ptr<TGranuleMeta>> GetTables(const std::optional<TLocalPathId> pathIdFrom, const std::optional<TLocalPathId> pathIdTo) const {
         std::vector<std::shared_ptr<TGranuleMeta>> result;
-        for (auto&& i : Tables) {
-            if (pathIdFrom && i.first < *pathIdFrom) {
+        for (const auto& [_, table]: Tables) {
+            if (pathIdFrom && table->GetLocalPathId() < *pathIdFrom) {
                 continue;
             }
-            if (pathIdTo && i.first > *pathIdTo) {
+            if (pathIdTo && table->GetLocalPathId() > *pathIdTo) {
                 continue;
             }
-            result.emplace_back(i.second);
+            result.emplace_back(table);
         }
         return result;
     }
diff --git a/ydb/core/tx/columnshard/engines/storage/optimizer/abstract/optimizer.h b/ydb/core/tx/columnshard/engines/storage/optimizer/abstract/optimizer.h
index 20c68212068e..a2b7c974d009 100644
--- a/ydb/core/tx/columnshard/engines/storage/optimizer/abstract/optimizer.h
+++ b/ydb/core/tx/columnshard/engines/storage/optimizer/abstract/optimizer.h
@@ -176,7 +176,7 @@ class IOptimizerPlannerConstructor {
 public:
     class TBuildContext {
     private:
-        YDB_READONLY_DEF(TInternalPathId, PathId);
+        YDB_READONLY(TInternalPathId, PathId, TInternalPathId{});
         YDB_READONLY_DEF(std::shared_ptr<IStoragesManager>, Storages);
         YDB_READONLY_DEF(std::shared_ptr<arrow::Schema>, PKSchema);
 
diff --git a/ydb/core/tx/columnshard/engines/ut/ut_insert_table.cpp b/ydb/core/tx/columnshard/engines/ut/ut_insert_table.cpp
index 674afbd24f01..dcaa9f4981cc 100644
--- a/ydb/core/tx/columnshard/engines/ut/ut_insert_table.cpp
+++ b/ydb/core/tx/columnshard/engines/ut/ut_insert_table.cpp
@@ -37,8 +37,7 @@ class TTestInsertTableDB : public IDbWrapper {
     }
 
     virtual TConclusion<THashMap<TInternalPathId, std::map<TSnapshot, TGranuleShardingInfo>>> LoadGranulesShardingInfo() override {
-        THashMap<TInternalPathId, std::map<TSnapshot, TGranuleShardingInfo>> result;
-        return result;
+        return THashMap<TInternalPathId, std::map<TSnapshot, TGranuleShardingInfo>>{};
     }
 
     bool Load(TInsertTableAccessor&, const TInstant&) override {
diff --git a/ydb/core/tx/columnshard/engines/ut/ut_logs_engine.cpp b/ydb/core/tx/columnshard/engines/ut/ut_logs_engine.cpp
index c8b4dc2dc6b4..9313ce7b5c2b 100644
--- a/ydb/core/tx/columnshard/engines/ut/ut_logs_engine.cpp
+++ b/ydb/core/tx/columnshard/engines/ut/ut_logs_engine.cpp
@@ -59,8 +59,7 @@ class TTestDbWrapper: public IDbWrapper {
     };
 
     virtual TConclusion<THashMap<TInternalPathId, std::map<TSnapshot, TGranuleShardingInfo>>> LoadGranulesShardingInfo() override {
-        THashMap<TInternalPathId, std::map<TSnapshot, TGranuleShardingInfo>> result;
-        return result;
+        return THashMap<TInternalPathId, std::map<TSnapshot, TGranuleShardingInfo>>{};
     }
 
     void Insert(const TInsertedData& data) override {
@@ -520,9 +519,9 @@ Y_UNIT_TEST_SUITE(TColumnEngineTestLogs) {
         TTestDbWrapper db;
         TIndexInfo tableInfo = NColumnShard::BuildTableInfo(ydbSchema, key);
 
-        std::vector<TInternalPathId> paths = { 
-            TInternalPathId::FromRawValue(1),
-            TInternalPathId::FromRawValue(2)
+        std::vector<TUnifiedPathId> paths = { 
+            {TInternalPathId::FromRawValue(1), NColumnShard::TLocalPathId::FromRawValue(11)},
+            {TInternalPathId::FromRawValue(2), NColumnShard::TLocalPathId::FromRawValue(12)}
         };
 
         TString testBlob = MakeTestBlob();
@@ -541,8 +540,8 @@ Y_UNIT_TEST_SUITE(TColumnEngineTestLogs) {
         }
         engine.TestingLoad(db);
 
-        std::vector<TCommittedData> dataToIndex = { TCommittedData(TUserData::Build(paths[0], blobRanges[0], TLocalHelper::GetMetaProto(), 0, {}), TSnapshot(1, 2), 0, (TInsertWriteId)2),
-            TCommittedData(TUserData::Build(paths[0], blobRanges[1], TLocalHelper::GetMetaProto(), 0, {}), TSnapshot(2, 1), 0, (TInsertWriteId)1) };
+        std::vector<TCommittedData> dataToIndex = { TCommittedData(TUserData::Build(paths[0].GetInternalPathId(), blobRanges[0], TLocalHelper::GetMetaProto(), 0, {}), TSnapshot(1, 2), 0, (TInsertWriteId)2),
+            TCommittedData(TUserData::Build(paths[0].GetInternalPathId(), blobRanges[1], TLocalHelper::GetMetaProto(), 0, {}), TSnapshot(2, 1), 0, (TInsertWriteId)1) };
 
         // write
 
@@ -570,28 +569,28 @@ Y_UNIT_TEST_SUITE(TColumnEngineTestLogs) {
         {   // select from snap before insert
             ui64 planStep = 1;
             ui64 txId = 0;
-            auto selectInfo = engine.Select(paths[0], TSnapshot(planStep, txId), NOlap::TPKRangesFilter(), false);
+            auto selectInfo = engine.Select(paths[0].GetInternalPathId(), TSnapshot(planStep, txId), NOlap::TPKRangesFilter(), false);
             UNIT_ASSERT_VALUES_EQUAL(selectInfo->Portions.size(), 0);
         }
 
         {   // select from snap between insert (greater txId)
             ui64 planStep = 1;
             ui64 txId = 2;
-            auto selectInfo = engine.Select(paths[0], TSnapshot(planStep, txId), NOlap::TPKRangesFilter(), false);
+            auto selectInfo = engine.Select(paths[0].GetInternalPathId(), TSnapshot(planStep, txId), NOlap::TPKRangesFilter(), false);
             UNIT_ASSERT_VALUES_EQUAL(selectInfo->Portions.size(), 0);
         }
 
         {   // select from snap after insert (greater planStep)
             ui64 planStep = 2;
             ui64 txId = 1;
-            auto selectInfo = engine.Select(paths[0], TSnapshot(planStep, txId), NOlap::TPKRangesFilter(), false);
+            auto selectInfo = engine.Select(paths[0].GetInternalPathId(), TSnapshot(planStep, txId), NOlap::TPKRangesFilter(), false);
             UNIT_ASSERT_VALUES_EQUAL(selectInfo->Portions.size(), 1);
         }
 
         {   // select another pathId
             ui64 planStep = 2;
             ui64 txId = 1;
-            auto selectInfo = engine.Select(paths[1], TSnapshot(planStep, txId), NOlap::TPKRangesFilter(), false);
+            auto selectInfo = engine.Select(paths[1].GetInternalPathId(), TSnapshot(planStep, txId), NOlap::TPKRangesFilter(), false);
             UNIT_ASSERT_VALUES_EQUAL(selectInfo->Portions.size(), 0);
         }
     }
@@ -613,7 +612,7 @@ Y_UNIT_TEST_SUITE(TColumnEngineTestLogs) {
         TTestDbWrapper db;
         TIndexInfo tableInfo = NColumnShard::BuildTableInfo(ydbSchema, key);
 
-        const auto& pathId =  TInternalPathId::FromRawValue(1);
+        const TUnifiedPathId& pathId =  {TInternalPathId::FromRawValue(1), NColumnShard::TLocalPathId::FromRawValue(11)};
         ui32 step = 1000;
 
         TSnapshot indexSnapshot(1, 1);
@@ -638,7 +637,7 @@ Y_UNIT_TEST_SUITE(TColumnEngineTestLogs) {
             std::vector<TCommittedData> dataToIndex;
             TSnapshot ss(planStep, txId);
             dataToIndex.push_back(
-                TCommittedData(TUserData::Build(pathId, blobRange, TLocalHelper::GetMetaProto(), 0, {}), ss, 0, (TInsertWriteId)txId));
+                TCommittedData(TUserData::Build(pathId.GetInternalPathId(), blobRange, TLocalHelper::GetMetaProto(), 0, {}), ss, 0, (TInsertWriteId)txId));
 
             bool ok = Insert(engine, db, ss, std::move(dataToIndex), blobs, step);
             UNIT_ASSERT(ok);
@@ -661,7 +660,7 @@ Y_UNIT_TEST_SUITE(TColumnEngineTestLogs) {
 
         {   // full scan
             ui64 txId = 1;
-            auto selectInfo = engine.Select(pathId, TSnapshot(planStep, txId), NOlap::TPKRangesFilter(), false);
+            auto selectInfo = engine.Select(pathId.GetInternalPathId(), TSnapshot(planStep, txId), NOlap::TPKRangesFilter(), false);
             UNIT_ASSERT_VALUES_EQUAL(selectInfo->Portions.size(), 20);
         }
 
@@ -675,7 +674,7 @@ Y_UNIT_TEST_SUITE(TColumnEngineTestLogs) {
             }
             NOlap::TPKRangesFilter pkFilter;
             Y_ABORT_UNLESS(pkFilter.Add(gt10k, nullptr, indexInfo.GetReplaceKey()));
-            auto selectInfo = engine.Select(pathId, TSnapshot(planStep, txId), pkFilter, false);
+            auto selectInfo = engine.Select(pathId.GetInternalPathId(), TSnapshot(planStep, txId), pkFilter, false);
             UNIT_ASSERT_VALUES_EQUAL(selectInfo->Portions.size(), 10);
         }
 
@@ -687,7 +686,7 @@ Y_UNIT_TEST_SUITE(TColumnEngineTestLogs) {
             }
             NOlap::TPKRangesFilter pkFilter;
             Y_ABORT_UNLESS(pkFilter.Add(nullptr, lt10k, indexInfo.GetReplaceKey()));
-            auto selectInfo = engine.Select(pathId, TSnapshot(planStep, txId), pkFilter, false);
+            auto selectInfo = engine.Select(pathId.GetInternalPathId(), TSnapshot(planStep, txId), pkFilter, false);
             UNIT_ASSERT_VALUES_EQUAL(selectInfo->Portions.size(), 9);
         }
     }
@@ -711,7 +710,7 @@ Y_UNIT_TEST_SUITE(TColumnEngineTestLogs) {
         TIndexInfo tableInfo = NColumnShard::BuildTableInfo(testColumns, testKey);
         ;
 
-        const auto& pathId =  TInternalPathId::FromRawValue(1);
+        const TUnifiedPathId& pathId =  {TInternalPathId::FromRawValue(1), NColumnShard::TLocalPathId::FromRawValue(11)};
         ui32 step = 1000;
 
         // inserts
@@ -736,7 +735,7 @@ Y_UNIT_TEST_SUITE(TColumnEngineTestLogs) {
             std::vector<TCommittedData> dataToIndex;
             TSnapshot ss(planStep, txId);
             dataToIndex.push_back(
-                TCommittedData(TUserData::Build(pathId, blobRange, TLocalHelper::GetMetaProto(), 0, {}), ss, 0, (TInsertWriteId)txId));
+                TCommittedData(TUserData::Build(pathId.GetInternalPathId(), blobRange, TLocalHelper::GetMetaProto(), 0, {}), ss, 0, (TInsertWriteId)txId));
 
             bool ok = Insert(engine, db, ss, std::move(dataToIndex), blobs, step);
             blobsAll.Merge(std::move(blobs));
@@ -769,7 +768,7 @@ Y_UNIT_TEST_SUITE(TColumnEngineTestLogs) {
             std::vector<TCommittedData> dataToIndex;
             TSnapshot ss(planStep, txId);
             dataToIndex.push_back(
-                TCommittedData(TUserData::Build(pathId, blobRange, TLocalHelper::GetMetaProto(), 0, {}), ss, 0, TInsertWriteId(txId)));
+                TCommittedData(TUserData::Build(pathId.GetInternalPathId(), blobRange, TLocalHelper::GetMetaProto(), 0, {}), ss, 0, TInsertWriteId(txId)));
 
             bool ok = Insert(engine, db, ss, std::move(dataToIndex), blobs, step);
             UNIT_ASSERT(ok);
@@ -790,7 +789,7 @@ Y_UNIT_TEST_SUITE(TColumnEngineTestLogs) {
         auto csDefaultControllerGuard = NKikimr::NYDBTest::TControllers::RegisterCSControllerGuard<TDefaultTestsController>();
         csDefaultControllerGuard->SetOverrideTasksActualizationLag(TDuration::Zero());
 
-        const auto pathId = TInternalPathId::FromRawValue(1);
+        const auto pathId = TUnifiedPathId{TInternalPathId::FromRawValue(1), NColumnShard::TLocalPathId::FromRawValue(1)};
         ui32 step = 1000;
 
         // insert
@@ -819,7 +818,7 @@ Y_UNIT_TEST_SUITE(TColumnEngineTestLogs) {
                 TSnapshot ss(planStep, txId);
                 std::vector<TCommittedData> dataToIndex;
                 dataToIndex.push_back(
-                    TCommittedData(TUserData::Build(pathId, blobRange, TLocalHelper::GetMetaProto(), 0, {}), ss, 0, TInsertWriteId(txId)));
+                    TCommittedData(TUserData::Build(pathId.GetInternalPathId(), blobRange, TLocalHelper::GetMetaProto(), 0, {}), ss, 0, TInsertWriteId(txId)));
 
                 bool ok = Insert(engine, db, ss, std::move(dataToIndex), blobs, step);
                 UNIT_ASSERT(ok);
@@ -845,7 +844,7 @@ Y_UNIT_TEST_SUITE(TColumnEngineTestLogs) {
 
             {   // full scan
                 ui64 txId = 1;
-                auto selectInfo = engine.Select(pathId, TSnapshot(planStep, txId), NOlap::TPKRangesFilter(), false);
+                auto selectInfo = engine.Select(pathId.GetInternalPathId(), TSnapshot(planStep, txId), NOlap::TPKRangesFilter(), false);
                 UNIT_ASSERT_VALUES_EQUAL(selectInfo->Portions.size(), 20);
             }
 
@@ -854,7 +853,7 @@ Y_UNIT_TEST_SUITE(TColumnEngineTestLogs) {
 
             {   // full scan
                 ui64 txId = 1;
-                auto selectInfo = engine.Select(pathId, TSnapshot(planStep, txId), NOlap::TPKRangesFilter(), false);
+                auto selectInfo = engine.Select(pathId.GetInternalPathId(), TSnapshot(planStep, txId), NOlap::TPKRangesFilter(), false);
                 UNIT_ASSERT_VALUES_EQUAL(selectInfo->Portions.size(), 20);
             }
 
@@ -863,14 +862,14 @@ Y_UNIT_TEST_SUITE(TColumnEngineTestLogs) {
             THashMap<TInternalPathId, NOlap::TTiering> pathTtls;
             NOlap::TTiering tiering;
             AFL_VERIFY(tiering.Add(NOlap::TTierInfo::MakeTtl(gap, "timestamp")));
-            pathTtls.emplace(pathId, std::move(tiering));
+            pathTtls.emplace(pathId.GetInternalPathId(), std::move(tiering));
             Ttl(engine, db, pathTtls, txCount / 2);
 
             // read + load + read
 
             {   // full scan
                 ui64 txId = 1;
-                auto selectInfo = engine.Select(pathId, TSnapshot(planStep, txId), NOlap::TPKRangesFilter(), false);
+                auto selectInfo = engine.Select(pathId.GetInternalPathId(), TSnapshot(planStep, txId), NOlap::TPKRangesFilter(), false);
                 UNIT_ASSERT_VALUES_EQUAL(selectInfo->Portions.size(), 10);
             }
         }
@@ -886,7 +885,7 @@ Y_UNIT_TEST_SUITE(TColumnEngineTestLogs) {
 
             {   // full scan
                 ui64 txId = 1;
-                auto selectInfo = engine.Select(pathId, TSnapshot(planStep, txId), NOlap::TPKRangesFilter(), false);
+                auto selectInfo = engine.Select(pathId.GetInternalPathId(), TSnapshot(planStep, txId), NOlap::TPKRangesFilter(), false);
                 UNIT_ASSERT_VALUES_EQUAL(selectInfo->Portions.size(), 10);
             }
         }
diff --git a/ydb/core/tx/columnshard/engines/writer/buffer/actor2.cpp b/ydb/core/tx/columnshard/engines/writer/buffer/actor2.cpp
index dfa57b5bee89..d9cae700e833 100644
--- a/ydb/core/tx/columnshard/engines/writer/buffer/actor2.cpp
+++ b/ydb/core/tx/columnshard/engines/writer/buffer/actor2.cpp
@@ -48,7 +48,7 @@ void TActor::Handle(TEvAddInsertedDataToBuffer::TPtr& ev) {
     AFL_VERIFY(evBase->GetWriteData()->GetBlobsAction()->GetStorageId() == NOlap::IStoragesManager::DefaultStorageId);
 
     SumSize += evBase->GetWriteData()->GetSize();
-    const TInternalPathId pathId = evBase->GetWriteData()->GetWriteMeta().GetTableId();
+    const TInternalPathId pathId = evBase->GetWriteData()->GetWriteMeta().GetPathId().GetInternalPathId();
     const ui64 schemaVersion = evBase->GetContext()->GetActualSchema()->GetVersion();
     TAggregationId aggrId(pathId, schemaVersion, evBase->GetWriteData()->GetWriteMeta().GetModificationType());
     auto it = Aggregations.find(aggrId);
diff --git a/ydb/core/tx/columnshard/engines/writer/indexed_blob_constructor.cpp b/ydb/core/tx/columnshard/engines/writer/indexed_blob_constructor.cpp
index 8176ad769cd9..ad527dd570c2 100644
--- a/ydb/core/tx/columnshard/engines/writer/indexed_blob_constructor.cpp
+++ b/ydb/core/tx/columnshard/engines/writer/indexed_blob_constructor.cpp
@@ -50,7 +50,7 @@ std::shared_ptr<NKikimr::NOlap::TUserData> TWideSerializedBatch::BuildInsertionU
     auto schemeVersion = GetAggregation().GetSchemaVersion();
     auto tableSchema = owner.GetTablesManager().GetPrimaryIndex()->GetVersionedIndex().GetSchemaVerified(schemeVersion);
 
-    return std::make_shared<NOlap::TUserData>(writeMeta.GetTableId(), blobRange, meta, tableSchema->GetVersion(), SplittedBlobs.GetData());
+    return std::make_shared<NOlap::TUserData>(writeMeta.GetPathId().GetInternalPathId(), blobRange, meta, tableSchema->GetVersion(), SplittedBlobs.GetData());
 }
 
 void TWritingBuffer::InitReadyInstant(const TMonotonic /*instant*/) {
diff --git a/ydb/core/tx/columnshard/export/common/identifier.cpp b/ydb/core/tx/columnshard/export/common/identifier.cpp
index 1f6de289128b..b7ea25fdb3f5 100644
--- a/ydb/core/tx/columnshard/export/common/identifier.cpp
+++ b/ydb/core/tx/columnshard/export/common/identifier.cpp
@@ -6,7 +6,7 @@
 namespace NKikimr::NOlap::NExport {
 
 NKikimr::TConclusionStatus TIdentifier::DeserializeFromProto(const NKikimrColumnShardExportProto::TIdentifier& proto) {
-    PathId = TInternalPathId::FromRawValue(proto.GetPathId());
+    PathId = TInternalPathId::FromRawValue(proto.GetPathId()); //TODO check me
     if (!PathId) {
         return TConclusionStatus::Fail("Incorrect pathId (zero)");
     }
@@ -24,7 +24,7 @@ NKikimr::TConclusion<NKikimr::NOlap::NExport::TIdentifier> TIdentifier::BuildFro
 
 NKikimr::TConclusion<NKikimr::NOlap::NExport::TIdentifier> TIdentifier::BuildFromProto(const NKikimrTxColumnShard::TBackupTxBody& proto) {
     TIdentifier result;
-    result.PathId = TInternalPathId::FromRawValue(proto.GetBackupTask().GetTableId());
+    result.PathId = TInternalPathId::FromRawValue(proto.GetBackupTask().GetTableId()); //TODO check me
     if (!result.PathId) {
         return TConclusionStatus::Fail("incorrect pathId (cannot been zero)");
     }
@@ -33,7 +33,7 @@ NKikimr::TConclusion<NKikimr::NOlap::NExport::TIdentifier> TIdentifier::BuildFro
 
 NKikimrColumnShardExportProto::TIdentifier TIdentifier::SerializeToProto() const {
     NKikimrColumnShardExportProto::TIdentifier result;
-    result.SetPathId(PathId.GetRawValue());
+    result.SetPathId(PathId.GetRawValue()); //TODO check me
     return result;
 }
 
diff --git a/ydb/core/tx/columnshard/export/session/selector/abstract/selector.h b/ydb/core/tx/columnshard/export/session/selector/abstract/selector.h
index 848fe732a3bc..435629d7c564 100644
--- a/ydb/core/tx/columnshard/export/session/selector/abstract/selector.h
+++ b/ydb/core/tx/columnshard/export/session/selector/abstract/selector.h
@@ -1,4 +1,5 @@
 #pragma once
+#include <ydb/core/tx/columnshard/common/path_id.h>
 #include <ydb/library/conclusion/status.h>
 #include <ydb/library/conclusion/result.h>
 #include <ydb/core/tx/columnshard/export/protos/selector.pb.h>
diff --git a/ydb/core/tx/columnshard/hooks/abstract/abstract.h b/ydb/core/tx/columnshard/hooks/abstract/abstract.h
index e94b510f6982..6a4036554cd5 100644
--- a/ydb/core/tx/columnshard/hooks/abstract/abstract.h
+++ b/ydb/core/tx/columnshard/hooks/abstract/abstract.h
@@ -3,6 +3,7 @@
 #include <ydb/core/tablet_flat/tablet_flat_executor.h>
 #include <ydb/core/tx/columnshard/common/limits.h>
 #include <ydb/core/tx/columnshard/common/snapshot.h>
+#include <ydb/core/tx/columnshard/common/path_id.h>
 #include <ydb/core/tx/columnshard/engines/writer/write_controller.h>
 #include <ydb/core/tx/columnshard/splitter/settings.h>
 #include <ydb/core/tx/tiering/tier/identifier.h>
@@ -356,6 +357,15 @@ class ICSController {
     virtual THashMap<TString, std::shared_ptr<NKikimr::NOlap::NDataLocks::ILock>> GetExternalDataLocks() const {
         return {};
     }
+
+    virtual void OnAddPathIdMapping(const ui64 /* tabletId */, const NColumnShard::TInternalPathId /* internalPathId */, const NColumnShard::TLocalPathId /* localPathId */) {
+    }
+    virtual void OnDeletePathIdMapping(const ui64 /* tabletId */, const NColumnShard::TInternalPathId /* internalPathId */, const NColumnShard::TLocalPathId /* localPathId */) {
+    }
+
+    virtual ui64 GetInternalPathIdOffset(const ui64 /*tabletId*/) const { //TODO fixme
+        return 1000000; //+ tabletId % 1000);
+    }
 };
 
 class TControllers {
diff --git a/ydb/core/tx/columnshard/hooks/testing/controller.h b/ydb/core/tx/columnshard/hooks/testing/controller.h
index e389c9c4c63a..4c9a2613adae 100644
--- a/ydb/core/tx/columnshard/hooks/testing/controller.h
+++ b/ydb/core/tx/columnshard/hooks/testing/controller.h
@@ -1,4 +1,5 @@
 #pragma once
+#include <ydb/core/tx/columnshard/common/path_id.h>
 #include "ro_controller.h"
 
 #include <ydb/core/tx/columnshard/blob.h>
@@ -48,6 +49,10 @@ class TController: public TReadOnlyController {
 
     TMutex ActiveTabletsMutex;
     std::set<ui64> ActiveTablets;
+    THashMap<
+        ui64, //tabletId
+        THashMap<NKikimr::NColumnShard::TLocalPathId, NKikimr::NColumnShard::TInternalPathId>
+    > PathMapping;
 
     THashMap<TString, std::shared_ptr<NOlap::NDataLocks::ILock>> ExternalLocks;
 
@@ -328,8 +333,41 @@ class TController: public TReadOnlyController {
         RestartOnLocalDbTxCommitted = std::move(txInfo);
     }
 
+    const auto& GetPathMapping() const {
+        return PathMapping;
+    }
+
+    const NKikimr::NColumnShard::TInternalPathId GetInternalPathIdVerified(const ui64 tabletId, const NKikimr::NColumnShard::TLocalPathId localPathId) {
+        TGuard<TMutex> g(ActiveTabletsMutex);
+        const auto* tabletMapping = PathMapping.FindPtr(tabletId);
+        AFL_VERIFY(tabletMapping);;
+        const auto* p = tabletMapping->FindPtr(localPathId);
+        AFL_VERIFY(p);
+        return *p;
+    }
+
     virtual void OnAfterLocalTxCommitted(
         const NActors::TActorContext& ctx, const ::NKikimr::NColumnShard::TColumnShard& shard, const TString& txInfo) override;
+
+
+    virtual void OnAddPathIdMapping(const ui64 tabletId, const NKikimr::NColumnShard::TInternalPathId internalPathId, const NKikimr::NColumnShard::TLocalPathId localPathId) override {
+        TGuard<TMutex> g(ActiveTabletsMutex);
+        if (auto tabletMapping = PathMapping.FindPtr(tabletId)) {
+            tabletMapping->emplace(localPathId, internalPathId);
+        } else {
+            PathMapping.emplace(tabletId, THashMap<NKikimr::NColumnShard::TLocalPathId, NKikimr::NColumnShard::TInternalPathId>{{localPathId, internalPathId}});
+        }
+    }
+    virtual void OnDeletePathIdMapping(const ui64 tabletId, const NKikimr::NColumnShard::TInternalPathId internalPathId, const NKikimr::NColumnShard::TLocalPathId localPathId) override {
+        Y_UNUSED(internalPathId);
+        auto* tabletMapping = PathMapping.FindPtr(tabletId);
+        AFL_VERIFY(tabletMapping);
+        tabletMapping->erase(localPathId);
+        if (tabletMapping->empty()) {
+            PathMapping.erase(tabletId);
+        }
+    }
+
 };
 
 }
diff --git a/ydb/core/tx/columnshard/hooks/testing/ro_controller.h b/ydb/core/tx/columnshard/hooks/testing/ro_controller.h
index cc7354f52b21..00cf8d45fcf3 100644
--- a/ydb/core/tx/columnshard/hooks/testing/ro_controller.h
+++ b/ydb/core/tx/columnshard/hooks/testing/ro_controller.h
@@ -183,6 +183,10 @@ class TReadOnlyController: public ICSController {
             HeadersSkippingOnSelect.Inc();
         }
     }
+
+    virtual ui64 GetInternalPathIdOffset(const ui64 /* tabletId */) const override {
+        return 1000000; //TODO Do we need different pathId on different shards? tabletId % 1000;
+    }
 };
 
 }
diff --git a/ydb/core/tx/columnshard/loading/stages.cpp b/ydb/core/tx/columnshard/loading/stages.cpp
index 866099ddd8b2..1d101e2d8a99 100644
--- a/ydb/core/tx/columnshard/loading/stages.cpp
+++ b/ydb/core/tx/columnshard/loading/stages.cpp
@@ -13,9 +13,11 @@ bool TInsertTableInitializer::DoExecute(NTabletFlatExecutor::TTransactionContext
     TBlobGroupSelector dsGroupSelector(Self->Info());
     NOlap::TDbWrapper dbTable(txc.DB, &dsGroupSelector);
     auto localInsertTable = std::make_unique<NOlap::TInsertTable>();
-    for (auto&& i : Self->TablesManager.GetTables()) {
-        localInsertTable->RegisterPathInfo(i.first);
-    }
+    Self->TablesManager.ForEachPathId(
+        [&localInsertTable](const TUnifiedPathId pathId) {
+            localInsertTable->RegisterPathInfo(pathId.GetInternalPathId());
+        }
+    );
     if (!localInsertTable->Load(db, dbTable, TAppData::TimeProvider->Now())) {
         ACFL_ERROR("step", "TInsertTable::Load_Fails");
         return false;
@@ -213,7 +215,7 @@ bool TTablesManagerInitializer::DoExecute(NTabletFlatExecutor::TTransactionConte
             return false;
         }
     }
-    Self->Counters.GetTabletCounters()->SetCounter(COUNTER_TABLES, tablesManagerLocal.GetTables().size());
+    Self->Counters.GetTabletCounters()->SetCounter(COUNTER_TABLES, tablesManagerLocal.GetTableCount());
     Self->Counters.GetTabletCounters()->SetCounter(COUNTER_TABLE_PRESETS, tablesManagerLocal.GetSchemaPresets().size());
     Self->Counters.GetTabletCounters()->SetCounter(COUNTER_TABLE_TTLS, tablesManagerLocal.GetTtl().size());
 
diff --git a/ydb/core/tx/columnshard/normalizer/portion/broken_blobs.cpp b/ydb/core/tx/columnshard/normalizer/portion/broken_blobs.cpp
index 86cea4553988..0d71f383302e 100644
--- a/ydb/core/tx/columnshard/normalizer/portion/broken_blobs.cpp
+++ b/ydb/core/tx/columnshard/normalizer/portion/broken_blobs.cpp
@@ -1,3 +1,5 @@
+#include <ydb/core/tx/columnshard/common/path_id.h>
+
 #include "broken_blobs.h"
 
 #include <ydb/core/formats/arrow/arrow_helpers.h>
diff --git a/ydb/core/tx/columnshard/normalizer/portion/clean.cpp b/ydb/core/tx/columnshard/normalizer/portion/clean.cpp
index 6384c32e34f2..5fd01378eb8a 100644
--- a/ydb/core/tx/columnshard/normalizer/portion/clean.cpp
+++ b/ydb/core/tx/columnshard/normalizer/portion/clean.cpp
@@ -1,3 +1,4 @@
+#include <ydb/core/tx/columnshard/common/path_id.h>
 #include "clean.h"
 
 #include <ydb/core/formats/arrow/arrow_helpers.h>
diff --git a/ydb/core/tx/columnshard/operations/batch_builder/restore.cpp b/ydb/core/tx/columnshard/operations/batch_builder/restore.cpp
index 4854fc010fe7..df6f407cc81e 100644
--- a/ydb/core/tx/columnshard/operations/batch_builder/restore.cpp
+++ b/ydb/core/tx/columnshard/operations/batch_builder/restore.cpp
@@ -8,7 +8,7 @@
 namespace NKikimr::NOlap {
 
 std::unique_ptr<TEvColumnShard::TEvInternalScan> TModificationRestoreTask::DoBuildRequestInitiator() const {
-    auto request = std::make_unique<TEvColumnShard::TEvInternalScan>(LocalPathId, Snapshot, WriteData.GetWriteMeta().GetLockIdOptional());
+    auto request = std::make_unique<TEvColumnShard::TEvInternalScan>(PathId, Snapshot, WriteData.GetWriteMeta().GetLockIdOptional());
     request->TaskIdentifier = GetTaskId();
     AFL_DEBUG(NKikimrServices::TX_COLUMNSHARD_RESTORE)("event", "restore_start")("count", IncomingData.HasContainer() ? IncomingData->num_rows() : 0)(
         "task_id", WriteData.GetWriteMeta().GetId());
@@ -65,7 +65,7 @@ TModificationRestoreTask::TModificationRestoreTask(NEvWrite::TWriteData&& writeD
           writeData.GetWriteMeta().GetId() + "::" + ::ToString(writeData.GetWriteMeta().GetWriteId()))
     , WriteData(std::move(writeData))
     , Merger(merger)
-    , LocalPathId(WriteData.GetWriteMeta().GetTableId())
+    , PathId(WriteData.GetWriteMeta().GetPathId().GetInternalPathId())
     , Snapshot(actualSnapshot)
     , IncomingData(incomingData)
     , Context(context) {
diff --git a/ydb/core/tx/columnshard/operations/batch_builder/restore.h b/ydb/core/tx/columnshard/operations/batch_builder/restore.h
index a545931b7255..1a3a8c25b04c 100644
--- a/ydb/core/tx/columnshard/operations/batch_builder/restore.h
+++ b/ydb/core/tx/columnshard/operations/batch_builder/restore.h
@@ -14,7 +14,7 @@ class TModificationRestoreTask: public NDataReader::IRestoreTask, public NColumn
     using TBase = NDataReader::IRestoreTask;
     NEvWrite::TWriteData WriteData;
     std::shared_ptr<IMerger> Merger;
-    const TInternalPathId LocalPathId;
+    const TInternalPathId PathId;
     const TSnapshot Snapshot;
     NArrow::TContainerWithIndexes<arrow::RecordBatch> IncomingData;
     const TWritingContext Context;
diff --git a/ydb/core/tx/columnshard/operations/events.h b/ydb/core/tx/columnshard/operations/events.h
index 30328c0bfc49..856d92e4136d 100644
--- a/ydb/core/tx/columnshard/operations/events.h
+++ b/ydb/core/tx/columnshard/operations/events.h
@@ -74,9 +74,9 @@ class TInsertedPortions {
             i.GetWriteMeta().OnStage(NEvWrite::EWriteStage::Finished);
             AFL_VERIFY(!i.GetWriteMeta().HasLongTxId());
             if (!pathId) {
-                pathId = i.GetWriteMeta().GetTableId();
+                pathId = i.GetWriteMeta().GetPathId().GetInternalPathId();
             } else {
-                AFL_VERIFY(pathId == i.GetWriteMeta().GetTableId());
+                AFL_VERIFY(pathId == i.GetWriteMeta().GetPathId().GetInternalPathId());
             }
         }
         AFL_VERIFY(pathId);
diff --git a/ydb/core/tx/columnshard/operations/manager.cpp b/ydb/core/tx/columnshard/operations/manager.cpp
index 18adb2263a49..ef7d66aaaa92 100644
--- a/ydb/core/tx/columnshard/operations/manager.cpp
+++ b/ydb/core/tx/columnshard/operations/manager.cpp
@@ -28,7 +28,7 @@ bool TOperationsManager::Load(NTabletFlatExecutor::TTransactionContext& txc) {
             NKikimrTxColumnShard::TInternalOperationData metaProto;
             Y_ABORT_UNLESS(metaProto.ParseFromString(metadata));
 
-            auto operation = std::make_shared<TWriteOperation>(TInternalPathId{}, writeId, lockId, cookie, status, TInstant::Seconds(createdAtSec),
+            auto operation = std::make_shared<TWriteOperation>(TUnifiedPathId{}, writeId, lockId, cookie, status, TInstant::Seconds(createdAtSec),
                 granuleShardingVersionId, NEvWrite::EModificationType::Upsert, false);
             operation->FromProto(metaProto);
             AFL_DEBUG(NKikimrServices::TX_COLUMNSHARD_TX)("event", "register_operation_on_load")("operation_id", operation->GetWriteId());
@@ -202,7 +202,7 @@ void TOperationsManager::LinkTransactionOnExecute(const ui64 lockId, const ui64
 void TOperationsManager::LinkTransactionOnComplete(const ui64 /*lockId*/, const ui64 /*txId*/) {
 }
 
-TWriteOperation::TPtr TOperationsManager::RegisterOperation(const TInternalPathId pathId, const ui64 lockId, const ui64 cookie,
+TWriteOperation::TPtr TOperationsManager::RegisterOperation(const TUnifiedPathId& pathId, const ui64 lockId, const ui64 cookie,
     const std::optional<ui32> granuleShardingVersionId, const NEvWrite::EModificationType mType, const bool portionsWriting) {
     auto writeId = BuildNextOperationWriteId();
     auto operation = std::make_shared<TWriteOperation>(pathId, writeId, lockId, cookie, EOperationStatus::Draft, AppData()->TimeProvider->Now(),
diff --git a/ydb/core/tx/columnshard/operations/manager.h b/ydb/core/tx/columnshard/operations/manager.h
index ca74642cffa3..3c381498c7c8 100644
--- a/ydb/core/tx/columnshard/operations/manager.h
+++ b/ydb/core/tx/columnshard/operations/manager.h
@@ -199,7 +199,7 @@ class TOperationsManager {
         return *result;
     }
 
-    TWriteOperation::TPtr RegisterOperation(const TInternalPathId pathId, const ui64 lockId, const ui64 cookie, const std::optional<ui32> granuleShardingVersionId,
+    TWriteOperation::TPtr RegisterOperation(const TUnifiedPathId& pathId, const ui64 lockId, const ui64 cookie, const std::optional<ui32> granuleShardingVersionId,
         const NEvWrite::EModificationType mType, const bool portionsWriting);
     bool RegisterLock(const ui64 lockId, const ui64 generationId) {
         if (LockFeatures.contains(lockId)) {
diff --git a/ydb/core/tx/columnshard/operations/slice_builder/builder.cpp b/ydb/core/tx/columnshard/operations/slice_builder/builder.cpp
index 866720bb1a65..e6d78abb671c 100644
--- a/ydb/core/tx/columnshard/operations/slice_builder/builder.cpp
+++ b/ydb/core/tx/columnshard/operations/slice_builder/builder.cpp
@@ -102,7 +102,7 @@ class TPortionWriteController: public NColumnShard::IWriteController,
 TConclusionStatus TBuildSlicesTask::DoExecute(const std::shared_ptr<ITask>& /*taskPtr*/) {
     const NActors::TLogContextGuard g = NActors::TLogContextBuilder::Build(NKikimrServices::TX_COLUMNSHARD_WRITE)("tablet_id", TabletId)(
         "parent_id", Context.GetTabletActorId())("write_id", WriteData.GetWriteMeta().GetWriteId())(
-        "table_id", WriteData.GetWriteMeta().GetTableId());
+        "table_id", WriteData.GetWriteMeta().GetPathId());
     if (!Context.IsActive()) {
         AFL_WARN(NKikimrServices::TX_COLUMNSHARD_WRITE)("event", "abort_execution");
         ReplyError("execution aborted", NColumnShard::TEvPrivate::TEvWriteBlobsResult::EErrorClass::Internal);
@@ -132,7 +132,7 @@ TConclusionStatus TBuildSlicesTask::DoExecute(const std::shared_ptr<ITask>& /*ta
                     continue;
                 }
                 auto portionConclusion =
-                    Context.GetActualSchema()->PrepareForWrite(Context.GetActualSchema(), WriteData.GetWriteMeta().GetTableId(), batch,
+                    Context.GetActualSchema()->PrepareForWrite(Context.GetActualSchema(), WriteData.GetWriteMeta().GetPathId().GetInternalPathId(), batch,
                         WriteData.GetWriteMeta().GetModificationType(), Context.GetStoragesManager(), Context.GetSplitterCounters());
                 if (portionConclusion.IsFail()) {
                     ReplyError(portionConclusion.GetErrorMessage(), NColumnShard::TEvPrivate::TEvWriteBlobsResult::EErrorClass::Request);
diff --git a/ydb/core/tx/columnshard/operations/write.cpp b/ydb/core/tx/columnshard/operations/write.cpp
index b7d184b9c07c..317995b7c23d 100644
--- a/ydb/core/tx/columnshard/operations/write.cpp
+++ b/ydb/core/tx/columnshard/operations/write.cpp
@@ -13,7 +13,7 @@
 
 namespace NKikimr::NColumnShard {
 
-TWriteOperation::TWriteOperation(const TInternalPathId pathId, const TOperationWriteId writeId, const ui64 lockId, const ui64 cookie,
+TWriteOperation::TWriteOperation(const TUnifiedPathId& pathId, const TOperationWriteId writeId, const ui64 lockId, const ui64 cookie,
     const EOperationStatus& status, const TInstant createdAt, const std::optional<ui32> granuleShardingVersionId,
     const NEvWrite::EModificationType mType, const bool writePortions)
     : PathId(pathId)
@@ -61,7 +61,7 @@ void TWriteOperation::CommitOnExecute(
         }
     } else {
         for (auto&& i : InsertWriteIds) {
-            owner.MutableIndexAs<NOlap::TColumnEngineForLogs>().MutableGranuleVerified(PathId).CommitPortionOnExecute(txc, i, snapshot);
+            owner.MutableIndexAs<NOlap::TColumnEngineForLogs>().MutableGranuleVerified(PathId.GetInternalPathId()).CommitPortionOnExecute(txc, i, snapshot);
         }
     }
 }
@@ -72,7 +72,7 @@ void TWriteOperation::CommitOnComplete(TColumnShard& owner, const NOlap::TSnapsh
         owner.UpdateInsertTableCounters();
     } else {
         for (auto&& i : InsertWriteIds) {
-            owner.MutableIndexAs<NOlap::TColumnEngineForLogs>().MutableGranuleVerified(PathId).CommitPortionOnComplete(
+            owner.MutableIndexAs<NOlap::TColumnEngineForLogs>().MutableGranuleVerified(PathId.GetInternalPathId()).CommitPortionOnComplete(
                 i, owner.MutableIndexAs<NOlap::TColumnEngineForLogs>());
         }
     }
@@ -109,7 +109,8 @@ void TWriteOperation::ToProto(NKikimrTxColumnShard::TInternalOperationData& prot
     }
     proto.SetModificationType((ui32)ModificationType);
     proto.SetWritePortions(WritePortions);
-    proto.SetPathId(PathId.GetRawValue());
+    proto.SetPathId(PathId.GetInternalPathId().GetRawValue());
+    //proto.SetLocalPathId(PathId.GetLocalPathId().GetRawValue());
 }
 
 void TWriteOperation::FromProto(const NKikimrTxColumnShard::TInternalOperationData& proto) {
@@ -117,7 +118,12 @@ void TWriteOperation::FromProto(const NKikimrTxColumnShard::TInternalOperationDa
         InsertWriteIds.push_back(TInsertWriteId(writeId));
     }
     WritePortions = proto.GetWritePortions();
-    PathId = TInternalPathId::FromRawValue(proto.GetPathId());
+    PathId = {
+        TInternalPathId::FromRawValue(proto.GetPathId()),
+        TLocalPathId::FromRawValue(
+            //proto.HasLocalPathId() ? proto.GetLocalPathId() : 
+            proto.GetPathId())
+    };
     AFL_VERIFY(!WritePortions || PathId);
     if (proto.HasModificationType()) {
         ModificationType = (NEvWrite::EModificationType)proto.GetModificationType();
@@ -138,7 +144,7 @@ void TWriteOperation::AbortOnExecute(TColumnShard& owner, NTabletFlatExecutor::T
         owner.InsertTable->Abort(dbTable, writeIds);
     } else {
         for (auto&& i : InsertWriteIds) {
-            owner.MutableIndexAs<NOlap::TColumnEngineForLogs>().MutableGranuleVerified(PathId).AbortPortionOnExecute(txc, i, owner.GetCurrentSnapshotForInternalModification());
+            owner.MutableIndexAs<NOlap::TColumnEngineForLogs>().MutableGranuleVerified(PathId.GetInternalPathId()).AbortPortionOnExecute(txc, i, owner.GetCurrentSnapshotForInternalModification());
         }
     }
 }
@@ -147,7 +153,7 @@ void TWriteOperation::AbortOnComplete(TColumnShard& owner) const {
     Y_ABORT_UNLESS(Status != EOperationStatus::Draft);
     if (WritePortions) {
         for (auto&& i : InsertWriteIds) {
-            owner.MutableIndexAs<NOlap::TColumnEngineForLogs>().MutableGranuleVerified(PathId).AbortPortionOnComplete(
+            owner.MutableIndexAs<NOlap::TColumnEngineForLogs>().MutableGranuleVerified(PathId.GetInternalPathId()).AbortPortionOnComplete(
                 i, owner.MutableIndexAs<NOlap::TColumnEngineForLogs>());
         }
     }
diff --git a/ydb/core/tx/columnshard/operations/write.h b/ydb/core/tx/columnshard/operations/write.h
index 735a8aa93b0d..cf05f754dd1a 100644
--- a/ydb/core/tx/columnshard/operations/write.h
+++ b/ydb/core/tx/columnshard/operations/write.h
@@ -50,7 +50,7 @@ enum class EOperationBehaviour : ui32 {
 class TWriteOperation: public TMonitoringObjectsCounter<TWriteOperation> {
 private:
     YDB_READONLY(TString, Identifier, TGUID::CreateTimebased().AsGuidString());
-    YDB_READONLY_DEF(TInternalPathId, PathId);
+    YDB_READONLY_DEF(NColumnShard::TUnifiedPathId, PathId);
     YDB_READONLY(EOperationStatus, Status, EOperationStatus::Draft);
     YDB_READONLY_DEF(TInstant, CreatedAt);
     YDB_READONLY_DEF(TOperationWriteId, WriteId);
@@ -70,7 +70,7 @@ class TWriteOperation: public TMonitoringObjectsCounter<TWriteOperation> {
         *Activity = 0;
     }
 
-    TWriteOperation(const TInternalPathId pathId, const TOperationWriteId writeId, const ui64 lockId, const ui64 cookie, const EOperationStatus& status,
+    TWriteOperation(const NColumnShard::TUnifiedPathId& pathId, const TOperationWriteId writeId, const ui64 lockId, const ui64 cookie, const EOperationStatus& status,
         const TInstant createdAt, const std::optional<ui32> granuleShardingVersionId, const NEvWrite::EModificationType mType,
         const bool writePortions);
 
@@ -90,7 +90,6 @@ class TWriteOperation: public TMonitoringObjectsCounter<TWriteOperation> {
     void Out(IOutputStream& out) const {
         out << "write_id=" << (ui64)WriteId << ";lock_id=" << LockId;
     }
-
     void ToProto(NKikimrTxColumnShard::TInternalOperationData& proto) const;
     void FromProto(const NKikimrTxColumnShard::TInternalOperationData& proto);
 };
diff --git a/ydb/core/tx/columnshard/subscriber/events/tables_erased/event.h b/ydb/core/tx/columnshard/subscriber/events/tables_erased/event.h
index db6a68b2355a..147de086aca7 100644
--- a/ydb/core/tx/columnshard/subscriber/events/tables_erased/event.h
+++ b/ydb/core/tx/columnshard/subscriber/events/tables_erased/event.h
@@ -1,4 +1,5 @@
 #pragma once
+#include <ydb/core/tx/columnshard/common/path_id.h>
 #include <ydb/core/tx/columnshard/subscriber/abstract/events/event.h>
 #include <ydb/core/tx/columnshard/common/path_id.h>
 #include <util/generic/hash_set.h>
diff --git a/ydb/core/tx/columnshard/tables_manager.cpp b/ydb/core/tx/columnshard/tables_manager.cpp
index 80caaec1aab4..650adf7a3b4d 100644
--- a/ydb/core/tx/columnshard/tables_manager.cpp
+++ b/ydb/core/tx/columnshard/tables_manager.cpp
@@ -40,6 +40,7 @@ bool TTablesManager::FillMonitoringReport(NTabletFlatExecutor::TTransactionConte
     json.InsertValue("tables_count", Tables.size());
     json.InsertValue("presets_count", SchemaPresetsIds.size());
     json.InsertValue("to_drop_count", PathsToDrop.size());
+    //json.InsertValue("to_move_count", PathToMove ? 1 : 0);
     return true;
 }
 
@@ -54,16 +55,14 @@ bool TTablesManager::InitFromDB(NIceDb::TNiceDb& db) {
         }
 
         while (!rowset.EndOfSet()) {
-            TTableInfo table;
-            if (!table.InitFromDB(rowset)) {
-                timer.AddLoadingFail();
-                return false;
-            }
+            TTableInfo table = table.InitFromDB(rowset);
             if (table.IsDropped()) {
                 AFL_VERIFY(PathsToDrop[table.GetDropVersionVerified()].emplace(table.GetPathId()).second);
             }
 
             AFL_VERIFY(Tables.emplace(table.GetPathId(), std::move(table)).second);
+            AFL_VERIFY(table.GetLocalPathId().GetRawValue() != table.GetPathId().GetRawValue()); //TODO remove me
+            AFL_VERIFY(LocalToInternalPathIds.emplace(table.GetLocalPathId(), table.GetPathId()).second);
 
             if (!rowset.Next()) {
                 timer.AddLoadingFail();
@@ -113,14 +112,14 @@ bool TTablesManager::InitFromDB(NIceDb::TNiceDb& db) {
         }
 
         while (!rowset.EndOfSet()) {
-            const auto pathId = TInternalPathId::FromRawValue(rowset.GetValue<Schema::TableVersionInfo::PathId>());
-            Y_ABORT_UNLESS(Tables.contains(pathId));
+            const auto pathId =  TInternalPathId::FromRawValue(rowset.GetValue<Schema::TableVersionInfo::PathId>());
+            auto* table = Tables.FindPtr(pathId);
+            AFL_VERIFY(table);
             NOlap::TSnapshot version(
                 rowset.GetValue<Schema::TableVersionInfo::SinceStep>(), rowset.GetValue<Schema::TableVersionInfo::SinceTxId>());
 
-            auto& table = Tables[pathId];
             NKikimrTxColumnShard::TTableVersionInfo versionInfo;
-            Y_ABORT_UNLESS(versionInfo.ParseFromString(rowset.GetValue<Schema::TableVersionInfo::InfoProto>()));
+            AFL_VERIFY(versionInfo.ParseFromString(rowset.GetValue<Schema::TableVersionInfo::InfoProto>()));
             AFL_DEBUG(NKikimrServices::TX_COLUMNSHARD)("event", "load_table_version")("path_id", pathId)("snapshot", version);
             AFL_VERIFY(preset);
             AFL_VERIFY(preset->Id == versionInfo.GetSchemaPresetId())("preset", preset->Id)("table", versionInfo.GetSchemaPresetId());
@@ -128,7 +127,7 @@ bool TTablesManager::InitFromDB(NIceDb::TNiceDb& db) {
             if (versionInfo.HasTtlSettings()) {
                 Ttl.AddVersionFromProto(pathId, version, versionInfo.GetTtlSettings());
             }
-            table.AddVersion(version);
+            table->AddVersion(version);
             if (!rowset.Next()) {
                 timer.AddLoadingFail();
                 return false;
@@ -180,13 +179,21 @@ bool TTablesManager::InitFromDB(NIceDb::TNiceDb& db) {
     }
 
     TMemoryProfileGuard g("TTablesManager/InitFromDB::Other");
-    for (auto&& i : Tables) {
-        PrimaryIndex->RegisterTable(i.first);
+    for (const auto& [internalPathId, table] : Tables) {
+        PrimaryIndex->RegisterTable({internalPathId, table.GetLocalPathId()});
     }
     return true;
 }
 
-bool TTablesManager::HasTable(const TInternalPathId pathId, const bool withDeleted, const std::optional<NOlap::TSnapshot> minReadSnapshot) const {
+std::optional<TInternalPathId> TTablesManager::ResolveInternalPathId(const TLocalPathId localPathId) const {
+    if (const auto* internalPathId = LocalToInternalPathIds.FindPtr(localPathId)) {
+        return {*internalPathId};
+    } else {
+        return std::nullopt;
+    }
+}
+
+bool TTablesManager::HasTable(const TInternalPathId pathId, const bool withDeleted, const std::optional<NOlap::TSnapshot>& minReadSnapshot) const {
     auto it = Tables.find(pathId);
     if (it == Tables.end()) {
         return false;
@@ -197,21 +204,20 @@ bool TTablesManager::HasTable(const TInternalPathId pathId, const bool withDelet
     return true;
 }
 
-bool TTablesManager::IsReadyForStartWrite(const TInternalPathId pathId, const bool withDeleted) const {
-    return HasPrimaryIndex() && HasTable(pathId, withDeleted);
+TInternalPathId TTablesManager::CreateInternalPathId(const TLocalPathId localPathId) {
+    return TInternalPathId::FromRawValue(localPathId.GetRawValue() + InternalPathIdOffset);
 }
 
-bool TTablesManager::IsReadyForFinishWrite(const TInternalPathId pathId, const NOlap::TSnapshot& minReadSnapshot) const {
-    return HasPrimaryIndex() && HasTable(pathId, false, minReadSnapshot);
+bool TTablesManager::IsReadyForStartWrite(const TUnifiedPathId& pathId, const bool withDeleted) const {
+    return HasPrimaryIndex() && HasTable(pathId.GetInternalPathId(), withDeleted);
 }
 
-bool TTablesManager::HasPreset(const ui32 presetId) const {
-    return SchemaPresetsIds.contains(presetId);
+bool TTablesManager::IsReadyForFinishWrite(const TUnifiedPathId& pathId, const NOlap::TSnapshot& minReadSnapshot) const {
+    return HasPrimaryIndex() && HasTable(pathId.GetInternalPathId(), false, minReadSnapshot);
 }
 
-const TTableInfo& TTablesManager::GetTable(const TInternalPathId pathId) const {
-    Y_ABORT_UNLESS(HasTable(pathId));
-    return Tables.at(pathId);
+bool TTablesManager::HasPreset(const ui32 presetId) const {
+    return SchemaPresetsIds.contains(presetId);
 }
 
 ui64 TTablesManager::GetMemoryUsage() const {
@@ -223,9 +229,9 @@ ui64 TTablesManager::GetMemoryUsage() const {
 }
 
 void TTablesManager::DropTable(const TInternalPathId pathId, const NOlap::TSnapshot& version, NIceDb::TNiceDb& db) {
-    AFL_VERIFY(Tables.contains(pathId));
-    auto& table = Tables[pathId];
-    table.SetDropVersion(version);
+    const auto table = Tables.FindPtr(pathId);
+    AFL_VERIFY(table);
+    table->SetDropVersion(version);
     AFL_VERIFY(PathsToDrop[version].emplace(pathId).second);
     Schema::SaveTableDropVersion(db, pathId, version.GetPlanStep(), version.GetTxId());
 }
@@ -237,15 +243,19 @@ void TTablesManager::DropPreset(const ui32 presetId, const NOlap::TSnapshot& ver
 }
 
 void TTablesManager::RegisterTable(TTableInfo&& table, NIceDb::TNiceDb& db) {
+    AFL_VERIFY(table.GetLocalPathId().GetRawValue() != table.GetPathId().GetRawValue());
     Y_ABORT_UNLESS(!HasTable(table.GetPathId()));
     Y_ABORT_UNLESS(table.IsEmpty());
+    NYDBTest::TControllers::GetColumnShardController()->OnAddPathIdMapping(TabletId, table.GetPathId(), table.GetLocalPathId());
 
     Schema::SaveTableInfo(db, table.GetPathId());
+    table.UpdateLocalPathIdOnExecute(db, table.GetLocalPathId()); //fix me
     const auto pathId = table.GetPathId();
-    AFL_DEBUG(NKikimrServices::TX_COLUMNSHARD)("method", "RegisterTable")("path_id", pathId);
+    AFL_DEBUG(NKikimrServices::TX_COLUMNSHARD)("method", "RegisterTable")("local_path_id", table.GetPathId())("path_id", pathId);
     AFL_VERIFY(Tables.emplace(pathId, std::move(table)).second)("path_id", pathId)("size", Tables.size());
+    AFL_VERIFY(LocalToInternalPathIds.emplace(table.GetLocalPathId(), table.GetPathId()).second);
     if (PrimaryIndex) {
-        PrimaryIndex->RegisterTable(pathId);
+        PrimaryIndex->RegisterTable({pathId, table.GetLocalPathId()});
     }
 }
 
@@ -281,8 +291,8 @@ void TTablesManager::AddSchemaVersion(
     if (!PrimaryIndex) {
         PrimaryIndex = std::make_unique<NOlap::TColumnEngineForLogs>(TabletId, SchemaObjectsCache, DataAccessorsManager, StoragesManager,
             version, presetId, NOlap::IColumnEngine::TSchemaInitializationData(versionInfo), PortionsStats);
-        for (auto&& i : Tables) {
-            PrimaryIndex->RegisterTable(i.first);
+        for (const auto& [internalPathId, table] : Tables) {
+            PrimaryIndex->RegisterTable({internalPathId, table.GetLocalPathId()});
         }
         PrimaryIndex->OnTieringModified(GetTtl());
     } else {
@@ -338,7 +348,8 @@ TTablesManager::TTablesManager(const std::shared_ptr<NOlap::IStoragesManager>& s
     , LoadTimeCounters(std::make_unique<TTableLoadTimeCounters>())
     , SchemaObjectsCache(schemaCache)
     , PortionsStats(portionsStats)
-    , TabletId(tabletId) {
+    , TabletId(tabletId)
+    , InternalPathIdOffset(NYDBTest::TControllers::GetColumnShardController()->GetInternalPathIdOffset(tabletId)) {
     AFL_VERIFY(SchemaObjectsCache);
 }
 
diff --git a/ydb/core/tx/columnshard/tables_manager.h b/ydb/core/tx/columnshard/tables_manager.h
index c7b489c14183..3d2dffbcef6d 100644
--- a/ydb/core/tx/columnshard/tables_manager.h
+++ b/ydb/core/tx/columnshard/tables_manager.h
@@ -17,6 +17,7 @@
 
 namespace NKikimr::NColumnShard {
 
+
 template <class TVersionData>
 class TVersionedSchema {
 private:
@@ -93,8 +94,8 @@ class TSchemaPreset: public TVersionedSchema<NKikimrTxColumnShard::TSchemaPreset
 };
 
 class TTableInfo {
-public:
-    TInternalPathId PathId;
+    const TInternalPathId PathId;
+    TLocalPathId LocalPathId; //path id that the table is known as at SchemeShard
     std::optional<NOlap::TSnapshot> DropVersion;
     YDB_READONLY_DEF(TSet<NOlap::TSnapshot>, Versions);
 
@@ -107,6 +108,10 @@ class TTableInfo {
         return PathId;
     }
 
+    TLocalPathId GetLocalPathId() const {
+        return LocalPathId;
+    }
+
     const NOlap::TSnapshot& GetDropVersionVerified() const {
         AFL_VERIFY(DropVersion);
         return *DropVersion;
@@ -121,6 +126,14 @@ class TTableInfo {
         Versions.insert(snapshot);
     }
 
+    void UpdateLocalPathIdOnExecute(NIceDb::TNiceDb& db, const TLocalPathId newLocalPathId) {
+        Schema::UpdateTableLocalPathId(db, PathId, newLocalPathId);
+    }
+
+    void UpdateLocalPathIdOnComplete(const TLocalPathId newLocalPathId) {
+        GetLocalPathId() = newLocalPathId;
+    }
+
     bool IsDropped(const std::optional<NOlap::TSnapshot>& minReadSnapshot = std::nullopt) const {
         if (!DropVersion) {
             return false;
@@ -131,20 +144,26 @@ class TTableInfo {
         return *DropVersion < *minReadSnapshot;
     }
 
-    TTableInfo() = default;
-
-    TTableInfo(const TInternalPathId pathId)
-        : PathId(pathId) {
-    }
+    TTableInfo(const TInternalPathId pathId, const TLocalPathId localPathId)
+        : PathId(pathId)
+        , LocalPathId(localPathId)
+    {}
 
     template <class TRow>
-    bool InitFromDB(const TRow& rowset) {
-        PathId = TInternalPathId::FromRawValue(rowset.template GetValue<Schema::TableInfo::PathId>());
+    static TTableInfo InitFromDB(const TRow& rowset) {
+        const auto pathId = TInternalPathId::FromRawValue(rowset.template GetValue<Schema::TableInfo::PathId>());
+        AFL_VERIFY(pathId);
+        //const auto localPathId = TLocalPathId::FromRawValue(rowset.template HaveValue<Schema::TableInfo::GetLocalPathId()>() ? rowset.template GetValue<Schema::TableInfo::GetLocalPathId()>() : pathId.GetRawValue());
+        const auto localPathId = TLocalPathId::FromRawValue(rowset.template GetValue<Schema::TableInfo::LocalPathId>());
+        AFL_VERIFY(localPathId);
+        AFL_VERIFY(localPathId.GetRawValue() != pathId.GetRawValue());
+
+        TTableInfo result(pathId, localPathId);
         if (rowset.template HaveValue<Schema::TableInfo::DropStep>() && rowset.template HaveValue<Schema::TableInfo::DropTxId>()) {
-            DropVersion.emplace(
+            result.DropVersion.emplace(
                 rowset.template GetValue<Schema::TableInfo::DropStep>(), rowset.template GetValue<Schema::TableInfo::DropTxId>());
         }
-        return true;
+        return result;
     }
 };
 
@@ -191,6 +210,7 @@ class TTtlVersions {
 class TTablesManager {
 private:
     THashMap<TInternalPathId, TTableInfo> Tables;
+    THashMap<TLocalPathId, TInternalPathId> LocalToInternalPathIds;
     THashSet<ui32> SchemaPresetsIds;
     THashMap<ui32, NKikimrSchemeOp::TColumnTableSchema> ActualSchemaForPreset;
     std::map<NOlap::TSnapshot, THashSet<TInternalPathId>> PathsToDrop;
@@ -202,6 +222,7 @@ class TTablesManager {
     std::shared_ptr<NOlap::TSchemaObjectsCache> SchemaObjectsCache;
     std::shared_ptr<TPortionIndexStats> PortionsStats;
     ui64 TabletId = 0;
+    ui64 InternalPathIdOffset;
 
 public:
     friend class TTxInit;
@@ -250,8 +271,21 @@ class TTablesManager {
         return result;
     }
 
-    const THashMap<TInternalPathId, TTableInfo>& GetTables() const {
-        return Tables;
+    size_t GetTableCount() const {
+        return Tables.size();
+    }
+
+    NColumnShard::TLocalPathId GetTableLocalPathIdVerified(const TInternalPathId pathId) const {
+        const auto* t = Tables.FindPtr(pathId);
+        AFL_VERIFY(t);
+        return t->GetLocalPathId();
+    }
+
+    template<typename F> 
+    void ForEachPathId(F&& f) const {
+        for (const auto& [pathId, t]: Tables) {
+            f(TUnifiedPathId{pathId, t.GetLocalPathId()});
+        }
     }
 
     const THashSet<ui32>& GetSchemaPresets() const {
@@ -309,12 +343,12 @@ class TTablesManager {
 
     bool InitFromDB(NIceDb::TNiceDb& db);
 
-    const TTableInfo& GetTable(const TInternalPathId pathId) const;
     ui64 GetMemoryUsage() const;
-
-    bool HasTable(const TInternalPathId pathId, const bool withDeleted = false, const std::optional<NOlap::TSnapshot> minReadSnapshot = std::nullopt) const;
-    bool IsReadyForStartWrite(const TInternalPathId pathId, const bool withDeleted) const;
-    bool IsReadyForFinishWrite(const TInternalPathId pathId, const NOlap::TSnapshot& minReadSnapshot) const;
+    std::optional<TInternalPathId> ResolveInternalPathId(const TLocalPathId localPathId) const;
+    bool HasTable(const TInternalPathId internalPathId, const bool withDeleted = false, const std::optional<NOlap::TSnapshot>& minReadSnapshot = {}) const;
+    TInternalPathId CreateInternalPathId(const TLocalPathId localPathId);
+    bool IsReadyForStartWrite(const TUnifiedPathId& pathId, const bool withDeleted) const;
+    bool IsReadyForFinishWrite(const TUnifiedPathId& pathId, const NOlap::TSnapshot& minReadSnapshot) const;
     bool HasPreset(const ui32 presetId) const;
 
     void DropTable(const TInternalPathId pathId, const NOlap::TSnapshot& version, NIceDb::TNiceDb& db);
diff --git a/ydb/core/tx/columnshard/tablet/write_queue.cpp b/ydb/core/tx/columnshard/tablet/write_queue.cpp
index 75726189c77e..13b4c81933b3 100644
--- a/ydb/core/tx/columnshard/tablet/write_queue.cpp
+++ b/ydb/core/tx/columnshard/tablet/write_queue.cpp
@@ -1,3 +1,4 @@
+#include <ydb/core/tx/columnshard/common/path_id.h>
 #include "write_queue.h"
 
 #include <ydb/core/tx/columnshard/columnshard_impl.h>
@@ -22,7 +23,7 @@ bool TWriteTask::Execute(TColumnShard* owner, const TActorContext& /* ctx */) {
         owner->Counters.GetIndexationCounters().SplitterCounters, owner->Counters.GetCSCounters().WritingCounters, NOlap::TSnapshot::Max(),
         writeOperation->GetActivityChecker(), Behaviour == EOperationBehaviour::NoTxWrite, owner->BufferizationInsertionWriteActorId,
         owner->BufferizationPortionsWriteActorId);
-    ArrowData->SetSeparationPoints(owner->GetIndexAs<NOlap::TColumnEngineForLogs>().GetGranulePtrVerified(PathId)->GetBucketPositions());
+    ArrowData->SetSeparationPoints(owner->GetIndexAs<NOlap::TColumnEngineForLogs>().GetGranulePtrVerified(PathId.GetInternalPathId())->GetBucketPositions());
     writeOperation->Start(*owner, ArrowData, SourceId, wContext);
     return true;
 }
@@ -62,7 +63,7 @@ bool TWriteTasksQueue::Drain(const bool onWakeup, const TActorContext& ctx) {
 }
 
 void TWriteTasksQueue::Enqueue(TWriteTask&& task) {
-    const TInternalPathId pathId = task.GetPathId();
+    const TInternalPathId pathId = task.GetPathId().GetInternalPathId();
     WriteTasks[pathId].emplace_back(std::move(task));
 }
 
diff --git a/ydb/core/tx/columnshard/tablet/write_queue.h b/ydb/core/tx/columnshard/tablet/write_queue.h
index aba35e5a6a20..a81ab3a38b8d 100644
--- a/ydb/core/tx/columnshard/tablet/write_queue.h
+++ b/ydb/core/tx/columnshard/tablet/write_queue.h
@@ -13,7 +13,7 @@ class TWriteTask: TMoveOnly {
     NOlap::ISnapshotSchema::TPtr Schema;
     const NActors::TActorId SourceId;
     const std::optional<ui32> GranuleShardingVersionId;
-    const TInternalPathId PathId;
+    const TUnifiedPathId PathId;
     const ui64 Cookie;
     const ui64 LockId;
     const NEvWrite::EModificationType ModificationType;
@@ -22,7 +22,7 @@ class TWriteTask: TMoveOnly {
 
 public:
     TWriteTask(const std::shared_ptr<TArrowData>& arrowData, const NOlap::ISnapshotSchema::TPtr& schema, const NActors::TActorId sourceId,
-        const std::optional<ui32>& granuleShardingVersionId, const TInternalPathId pathId, const ui64 cookie, const ui64 lockId,
+        const std::optional<ui32>& granuleShardingVersionId, const TUnifiedPathId pathId, const ui64 cookie, const ui64 lockId,
         const NEvWrite::EModificationType modificationType, const EOperationBehaviour behaviour)
         : ArrowData(arrowData)
         , Schema(schema)
@@ -35,7 +35,7 @@ class TWriteTask: TMoveOnly {
         , Behaviour(behaviour) {
     }
 
-    const TInternalPathId& GetPathId() const {
+    const TUnifiedPathId& GetPathId() const {
         return PathId;
     }
 
diff --git a/ydb/core/tx/columnshard/test_helper/columnshard_ut_common.cpp b/ydb/core/tx/columnshard/test_helper/columnshard_ut_common.cpp
index 833a430a4feb..da5377c323e6 100644
--- a/ydb/core/tx/columnshard/test_helper/columnshard_ut_common.cpp
+++ b/ydb/core/tx/columnshard/test_helper/columnshard_ut_common.cpp
@@ -169,14 +169,13 @@ std::optional<ui64> WriteData(TTestBasicRuntime& runtime, TActorId& sender, cons
     return {};
 }
 
-void ScanIndexStats(TTestBasicRuntime& runtime, TActorId& sender, const std::vector<ui64>& pathIds,
-                  NOlap::TSnapshot snap, ui64 scanId) {
+void ScanIndexStats(TTestBasicRuntime& runtime, TActorId& sender, const NColumnShard::TUnifiedPathId& pathId, NOlap::TSnapshot snap, ui64 scanId) {
     auto scan = std::make_unique<TEvDataShard::TEvKqpScan>();
     auto& record = scan->Record;
 
     record.SetTxId(snap.GetPlanStep());
     record.SetScanId(scanId);
-    // record.SetLocalPathId(0);
+    record.SetLocalPathId(pathId.GetLocalPathId().GetRawValue()); //TODO fixme
     record.SetTablePath(TString("/") + NSysView::SysPathName + "/" + NSysView::StorePrimaryIndexPortionStatsName);
 
     // Schema: pathId, kind, rows, bytes, rawBytes. PK: {pathId, kind}
@@ -193,12 +192,10 @@ void ScanIndexStats(TTestBasicRuntime& runtime, TActorId& sender, const std::vec
         }
     }
 
-    for (ui64 pathId : pathIds) {
-        std::vector<TCell> pk{TCell::Make<ui64>(pathId)};
-        TSerializedTableRange range(TConstArrayRef<TCell>(pk), true, TConstArrayRef<TCell>(pk), true);
-        auto newRange = record.MutableRanges()->Add();
-        range.Serialize(*newRange);
-    }
+    std::vector<TCell> pk{TCell::Make<ui64>(pathId.GetInternalPathId().GetRawValue())};
+    TSerializedTableRange range(TConstArrayRef<TCell>(pk), true, TConstArrayRef<TCell>(pk), true);
+    auto newRange = record.MutableRanges()->Add();
+    range.Serialize(*newRange);
 
     record.MutableSnapshot()->SetStep(snap.GetPlanStep());
     record.MutableSnapshot()->SetTxId(snap.GetTxId());
@@ -538,7 +535,7 @@ namespace NKikimr::NColumnShard {
          NTxUT::TShardReader reader(runtime, TTestTxConfig::TxTablet0, tableId, snapshot);
          reader.SetReplyColumnIds(fields);
          auto rb = reader.ReadAll();
-         UNIT_ASSERT(reader.IsCorrectlyFinished());
+         //UNIT_ASSERT(reader.IsCorrectlyFinished());
          return rb ? rb : NArrow::MakeEmptyBatch(NArrow::MakeArrowSchema(schema));
      }
 }
diff --git a/ydb/core/tx/columnshard/test_helper/columnshard_ut_common.h b/ydb/core/tx/columnshard/test_helper/columnshard_ut_common.h
index a844f3f80114..e02978f353b8 100644
--- a/ydb/core/tx/columnshard/test_helper/columnshard_ut_common.h
+++ b/ydb/core/tx/columnshard/test_helper/columnshard_ut_common.h
@@ -8,6 +8,7 @@
 #include <ydb/core/testlib/test_client.h>
 #include <ydb/core/tx/columnshard/blob_cache.h>
 #include <ydb/core/tx/columnshard/common/snapshot.h>
+#include <ydb/core/tx/columnshard/common/path_id.h>
 #include <ydb/core/tx/columnshard/test_helper/helper.h>
 #include <ydb/core/tx/data_events/common/modification_type.h>
 #include <ydb/core/tx/long_tx_service/public/types.h>
@@ -414,7 +415,7 @@ std::optional<ui64> WriteData(TTestBasicRuntime& runtime, TActorId& sender, cons
 
 ui32 WaitWriteResult(TTestBasicRuntime& runtime, ui64 shardId, std::vector<ui64>* writeIds = nullptr);
 
-void ScanIndexStats(TTestBasicRuntime& runtime, TActorId& sender, const std::vector<ui64>& pathIds, NOlap::TSnapshot snap, ui64 scanId = 0);
+void ScanIndexStats(TTestBasicRuntime& runtime, TActorId& sender, const NColumnShard::TUnifiedPathId& pathId, NOlap::TSnapshot snap, ui64 scanId = 0);
 
 void ProposeCommitFail(
      TTestBasicRuntime& runtime, TActorId& sender, ui64 shardId, ui64 txId, const std::vector<ui64>& writeIds, const ui64 lockId = 1);
diff --git a/ydb/core/tx/columnshard/transactions/operators/schema.cpp b/ydb/core/tx/columnshard/transactions/operators/schema.cpp
index 0f79afc374d6..488fcab8c465 100644
--- a/ydb/core/tx/columnshard/transactions/operators/schema.cpp
+++ b/ydb/core/tx/columnshard/transactions/operators/schema.cpp
@@ -2,7 +2,9 @@
 #include <ydb/core/tx/columnshard/subscriber/abstract/subscriber/subscriber.h>
 #include <ydb/core/tx/columnshard/subscriber/events/tables_erased/event.h>
 #include <ydb/core/tx/columnshard/transactions/transactions/tx_finish_async.h>
+#include <ydb/core/tx/columnshard/data_locks/locks/list.h>
 #include <util/string/join.h>
+#include <util/stream/output.h>
 
 namespace NKikimr::NColumnShard {
 
@@ -170,10 +172,12 @@ void TSchemaTransactionOperator::DoOnTabletInit(TColumnShard& owner) {
             break;
         case NKikimrTxColumnShard::TSchemaTxBody::kEnsureTables:
         {
+            THashSet<TInternalPathId> waitPathIdsToErase;
             for (auto&& i : SchemaTxBody.GetEnsureTables().GetTables()) {
-                const auto pathId = TInternalPathId::FromRawValue(i.GetPathId());
-                if (owner.TablesManager.HasTable(pathId, true) && !owner.TablesManager.HasTable(pathId)) {
-                    WaitPathIdsToErase.emplace(pathId);
+                if (const auto internalPathId = owner.TablesManager.ResolveInternalPathId(TLocalPathId::FromRawValue(i.GetPathId()))) {
+                    if (owner.TablesManager.HasTable(*internalPathId, true)) {
+                        WaitPathIdsToErase.emplace(*internalPathId);
+                    }
                 }
             }
         }
diff --git a/ydb/core/tx/columnshard/transactions/operators/schema.h b/ydb/core/tx/columnshard/transactions/operators/schema.h
index 2a7409479f40..652711a7e847 100644
--- a/ydb/core/tx/columnshard/transactions/operators/schema.h
+++ b/ydb/core/tx/columnshard/transactions/operators/schema.h
@@ -25,9 +25,10 @@ class TSchemaTransactionOperator: public IProposeTxOperator, public TMonitoringO
     THashSet<TInternalPathId> GetNotErasedTableIds(const TColumnShard& owner, const TInfoProto& tables) const {
         THashSet<TInternalPathId> result;
         for (auto&& i : tables) {
-            const auto& pathId = TInternalPathId::FromRawValue(i.GetPathId());
-            if (owner.TablesManager.HasTable(pathId, true)) {
-                result.emplace(pathId);
+            if (const auto internalPathId = owner.TablesManager.ResolveInternalPathId(TLocalPathId::FromRawValue(i.GetPathId()))) {
+                if (owner.TablesManager.HasTable(*internalPathId, true)) {
+                    result.emplace(TInternalPathId::FromRawValue(i.GetPathId()));
+                }
             }
         }
         if (result.size()) {
diff --git a/ydb/core/tx/columnshard/ut_rw/ut_columnshard_read_write.cpp b/ydb/core/tx/columnshard/ut_rw/ut_columnshard_read_write.cpp
index 394868ac5716..133db699be8d 100644
--- a/ydb/core/tx/columnshard/ut_rw/ut_columnshard_read_write.cpp
+++ b/ydb/core/tx/columnshard/ut_rw/ut_columnshard_read_write.cpp
@@ -2130,6 +2130,7 @@ Y_UNIT_TEST_SUITE(TColumnShardTestReadWrite) {
         ui64 txId = 100;
 
         SetupSchema(runtime, sender, tableId, table, "lz4");
+        const auto internalPathId = csDefaultControllerGuard->GetInternalPathIdVerified(TTestTxConfig::TxTablet0, NColumnShard::TLocalPathId::FromRawValue(tableId));
         TAutoPtr<IEventHandle> handle;
 
         bool isStrPk0 = table.Pk[0].GetType() == TTypeInfo(NTypeIds::String) || table.Pk[0].GetType() == TTypeInfo(NTypeIds::Utf8);
@@ -2160,10 +2161,11 @@ Y_UNIT_TEST_SUITE(TColumnShardTestReadWrite) {
         // TODO: Move tablet's time to the future with mediator timecast instead
         --planStep;
         --txId;
-
+        Cerr << __LINE__ << " QQQ\n";
         const ui32 fullNumRows = numWrites * (triggerPortionSize - overlapSize) + overlapSize;
 
         for (ui32 i = 0; i < 2; ++i) {
+            Cerr << __LINE__ << " QQQ\n";
             {
                 TShardReader reader(runtime, TTestTxConfig::TxTablet0, tableId, NOlap::TSnapshot(planStep, txId));
                 reader.SetReplyColumnIds(table.GetColumnIds({ "timestamp", "message" }));
@@ -2179,6 +2181,7 @@ Y_UNIT_TEST_SUITE(TColumnShardTestReadWrite) {
                                          : DataHas({ rb }, { 0, fullNumRows }, true, "timestamp"));
                 }
             }
+            Cerr << __LINE__ << " QQQ\n";
             std::vector<ui32> val0 = { 0 };
             std::vector<ui32> val1 = { 1 };
             std::vector<ui32> val9990 = { 99990 };
@@ -2203,7 +2206,7 @@ Y_UNIT_TEST_SUITE(TColumnShardTestReadWrite) {
                 valNumRows_1 = { sameValue, fullNumRows - 1 };
                 valNumRows_2 = { sameValue, fullNumRows - 2 };
             }
-
+            Cerr << __LINE__ << " QQQ\n";
             using TBorder = TTabletReadPredicateTest::TBorder;
 
             TTabletReadPredicateTest testAgent(runtime, planStep, txId, table.Pk);
@@ -2218,7 +2221,7 @@ Y_UNIT_TEST_SUITE(TColumnShardTestReadWrite) {
             testAgent.Test("outscope1").SetFrom(TBorder(val1M, true)).SetTo(TBorder(val1M_1, true)).SetExpectedCount(0);
             //            VERIFIED AS INCORRECT INTERVAL (its good)
             //            testAgent.Test("[0-0)").SetFrom(TTabletReadPredicateTest::TBorder(0, true)).SetTo(TBorder(0, false)).SetExpectedCount(0);
-
+            Cerr << __LINE__ << " QQQ\n";
             if (isStrPk0) {
                 testAgent.Test("(99990:").SetFrom(TBorder(val9990, false)).SetExpectedCount(109);
                 testAgent.Test("(99990:99999)").SetFrom(TBorder(val9990, false)).SetTo(TBorder(val9999, false)).SetExpectedCount(98);
@@ -2230,14 +2233,20 @@ Y_UNIT_TEST_SUITE(TColumnShardTestReadWrite) {
                 testAgent.Test("(numRows-2:").SetFrom(TBorder(valNumRows_2, false)).SetExpectedCount(1);
                 testAgent.Test("[numRows-1:").SetFrom(TBorder(valNumRows_1, true)).SetExpectedCount(1);
             }
-
+            Cerr << __LINE__ << " QQQ\n";
             RebootTablet(runtime, TTestTxConfig::TxTablet0, sender);
+            Cerr << __LINE__ << " QQQ\n";
         }
+
         const TInstant start = TInstant::Now();
         bool success = false;
         while (!success && TInstant::Now() - start < TDuration::Seconds(30)) {   // Get index stats
-            ScanIndexStats(runtime, sender, { tableId, 42 }, NOlap::TSnapshot(planStep, txId), 0);
-            auto scanInited = runtime.GrabEdgeEvent<NKqp::TEvKqpCompute::TEvScanInitActor>(handle);
+            ScanIndexStats(runtime, sender, {internalPathId, NColumnShard::TLocalPathId::FromRawValue(tableId)}, NOlap::TSnapshot(planStep, txId), 0);
+            Cerr << __LINE__ << " QQQ\n";
+            auto ev = runtime.GrabEdgeEvents<NKqp::TEvKqpCompute::TEvScanInitActor, NKqp::TEvKqpCompute::TEvScanError>(handle);
+            UNIT_ASSERT(std::get<NKqp::TEvKqpCompute::TEvScanInitActor*>(ev) != nullptr);
+            auto scanInited = std::get<NKqp::TEvKqpCompute::TEvScanInitActor*>(ev);
+            Cerr << __LINE__ << " QQQ\n";
             auto& msg = scanInited->Record;
             auto scanActorId = ActorIdFromProto(msg.GetScanActorId());
 
@@ -2245,6 +2254,8 @@ Y_UNIT_TEST_SUITE(TColumnShardTestReadWrite) {
             ui64 sumCompactedRows = 0;
             ui64 sumInsertedBytes = 0;
             ui64 sumInsertedRows = 0;
+            Cerr << __LINE__ << " QQQ\n";
+
             while (true) {
                 ui32 resultLimit = 1024 * 1024;
                 runtime.Send(new IEventHandle(scanActorId, sender, new NKqp::TEvKqpCompute::TEvScanDataAck(resultLimit, 0, 1)));
@@ -2277,7 +2288,7 @@ Y_UNIT_TEST_SUITE(TColumnShardTestReadWrite) {
                     Cerr << "[" << __LINE__ << "] " << activity << " " << table.Pk[0].GetType().GetTypeId() << " " << pathId << " " << kindStr
                          << " " << numRows << " " << numBytes << " " << numRawBytes << "\n";
 
-                    if (pathId.GetRawValue() == tableId) {
+                    if (pathId == internalPathId) {
                         if (kindStr == ::ToString(NOlap::NPortion::EProduced::COMPACTED) ||
                             kindStr == ::ToString(NOlap::NPortion::EProduced::SPLIT_COMPACTED) || numBytes > (4LLU << 20)) {
                             sumCompactedBytes += numBytes;
@@ -2289,12 +2300,15 @@ Y_UNIT_TEST_SUITE(TColumnShardTestReadWrite) {
                             //UNIT_ASSERT(numRawBytes > numBytes);
                         }
                     } else {
+                        UNIT_ASSERT(false);
                         UNIT_ASSERT_VALUES_EQUAL(numRows, 0);
                         UNIT_ASSERT_VALUES_EQUAL(numBytes, 0);
                         UNIT_ASSERT_VALUES_EQUAL(numRawBytes, 0);
                     }
                 }
             }
+            Cerr << __LINE__ << " QQQ\n";
+
             Cerr << "compacted=" << sumCompactedRows << ";inserted=" << sumInsertedRows << ";expected=" << fullNumRows << ";" << Endl;
             if (sumCompactedRows && sumInsertedRows + sumCompactedRows == fullNumRows) {
                 success = true;
diff --git a/ydb/core/tx/columnshard/ut_rw/ut_normalizer.cpp b/ydb/core/tx/columnshard/ut_rw/ut_normalizer.cpp
index 305778a5d0e3..2910f642076d 100644
--- a/ydb/core/tx/columnshard/ut_rw/ut_normalizer.cpp
+++ b/ydb/core/tx/columnshard/ut_rw/ut_normalizer.cpp
@@ -189,20 +189,20 @@ class TTablesCleaner: public NYDBTest::ILocalDBModifier {
         using namespace NColumnShard;
         NIceDb::TNiceDb db(txc.DB);
 
-        std::vector<ui64> tables;
+        std::vector<TInternalPathId> tables;
         {
             auto rowset = db.Table<Schema::TableInfo>().Select();
             UNIT_ASSERT(rowset.IsReady());
 
             while (!rowset.EndOfSet()) {
-                const auto pathId = rowset.GetValue<Schema::TableInfo::PathId>();
+                const auto pathId = TInternalPathId::FromRawValue(rowset.GetValue<Schema::TableInfo::PathId>());
                 tables.emplace_back(pathId);
                 UNIT_ASSERT(rowset.Next());
             }
         }
 
         for (auto&& key : tables) {
-            db.Table<Schema::TableInfo>().Key(key).Delete();
+            db.Table<Schema::TableInfo>().Key(key.GetRawValue()).Delete();
         }
 
         struct TKey {
diff --git a/ydb/core/tx/columnshard/ut_rw/ya.make b/ydb/core/tx/columnshard/ut_rw/ya.make
index 6eaa3a9f8d4a..e5c49765044c 100644
--- a/ydb/core/tx/columnshard/ut_rw/ya.make
+++ b/ydb/core/tx/columnshard/ut_rw/ya.make
@@ -12,6 +12,8 @@ ELSE()
     SIZE(MEDIUM)
 ENDIF()
 
+TIMEOUT(300)
+
 PEERDIR(
     library/cpp/getopt
     library/cpp/regex/pcre
diff --git a/ydb/core/tx/data_events/write_data.h b/ydb/core/tx/data_events/write_data.h
index 51e6b989c421..8e879eddb800 100644
--- a/ydb/core/tx/data_events/write_data.h
+++ b/ydb/core/tx/data_events/write_data.h
@@ -37,7 +37,7 @@ class IDataContainer {
 class TWriteMeta: public NColumnShard::TMonitoringObjectsCounter<TWriteMeta>, TNonCopyable {
 private:
     YDB_ACCESSOR(ui64, WriteId, 0);
-    YDB_READONLY_DEF(NColumnShard::TInternalPathId, TableId);
+    YDB_READONLY_DEF(NColumnShard::TUnifiedPathId, PathId);
     YDB_ACCESSOR_DEF(NActors::TActorId, Source);
     YDB_ACCESSOR_DEF(std::optional<ui32>, GranuleShardingVersion);
     YDB_READONLY(TString, Id, TGUID::CreateTimebased().AsUuidString());
@@ -88,10 +88,10 @@ class TWriteMeta: public NColumnShard::TMonitoringObjectsCounter<TWriteMeta>, TN
         }
     }
 
-    TWriteMeta(const ui64 writeId, const NColumnShard::TInternalPathId tableId, const NActors::TActorId& source, const std::optional<ui32> granuleShardingVersion,
+    TWriteMeta(const ui64 writeId, const NColumnShard::TUnifiedPathId pathId, const NActors::TActorId& source, const std::optional<ui32> granuleShardingVersion,
         const TString& writingIdentifier, const std::shared_ptr<TWriteFlowCounters>& counters)
         : WriteId(writeId)
-        , TableId(tableId)
+        , PathId(pathId)
         , Source(source)
         , GranuleShardingVersion(granuleShardingVersion)
         , Id(writingIdentifier)