diff options
| author | chertus <azuikov@ydb.tech> | 2023-05-10 19:04:22 +0300 |
|---|---|---|
| committer | chertus <azuikov@ydb.tech> | 2023-05-10 19:04:22 +0300 |
| commit | f3a53429c5823402916d1cbf31d10866e9b05cf3 (patch) | |
| tree | a2f5928d1a26993d684a3cbfaf48b12fec321680 | |
| parent | 0375f35448b89361c79286bfa01b1bbbf611e611 (diff) | |
| download | ydb-f3a53429c5823402916d1cbf31d10866e9b05cf3.tar.gz | |
TVector -> std::vector in ColumnShard
45 files changed, 330 insertions, 330 deletions
diff --git a/ydb/core/formats/arrow/arrow_batch_builder.cpp b/ydb/core/formats/arrow/arrow_batch_builder.cpp index b7107e7ce1..be0040edb2 100644 --- a/ydb/core/formats/arrow/arrow_batch_builder.cpp +++ b/ydb/core/formats/arrow/arrow_batch_builder.cpp @@ -196,7 +196,7 @@ TArrowBatchBuilder::TArrowBatchBuilder(arrow::Compression::type codec) WriteOptions.use_threads = false; } -bool TArrowBatchBuilder::Start(const TVector<std::pair<TString, NScheme::TTypeInfo>>& ydbColumns) { +bool TArrowBatchBuilder::Start(const std::vector<std::pair<TString, NScheme::TTypeInfo>>& ydbColumns) { YdbSchema = ydbColumns; auto schema = MakeArrowSchema(ydbColumns); auto status = arrow::RecordBatchBuilder::Make(schema, arrow::default_memory_pool(), RowsToReserve, &BatchBuilder); diff --git a/ydb/core/formats/arrow/arrow_batch_builder.h b/ydb/core/formats/arrow/arrow_batch_builder.h index 303e57d23c..90bded2d72 100644 --- a/ydb/core/formats/arrow/arrow_batch_builder.h +++ b/ydb/core/formats/arrow/arrow_batch_builder.h @@ -151,7 +151,7 @@ public: TArrowBatchBuilder(arrow::Compression::type codec = arrow::Compression::UNCOMPRESSED); ~TArrowBatchBuilder() = default; - bool Start(const TVector<std::pair<TString, NScheme::TTypeInfo>>& columns, + bool Start(const std::vector<std::pair<TString, NScheme::TTypeInfo>>& columns, ui64 maxRowsInBlock, ui64 maxBytesInBlock, TString& err) override { Y_UNUSED(maxRowsInBlock); Y_UNUSED(maxBytesInBlock); @@ -174,20 +174,20 @@ public: return NumBytes; } - bool Start(const TVector<std::pair<TString, NScheme::TTypeInfo>>& columns); + bool Start(const std::vector<std::pair<TString, NScheme::TTypeInfo>>& columns); std::shared_ptr<arrow::RecordBatch> FlushBatch(bool reinitialize); std::shared_ptr<arrow::RecordBatch> GetBatch() const { return Batch; } protected: void AppendCell(const TCell& cell, ui32 colNum); - const TVector<std::pair<TString, NScheme::TTypeInfo>>& GetYdbSchema() const { + const std::vector<std::pair<TString, NScheme::TTypeInfo>>& GetYdbSchema() const { return YdbSchema; } private: arrow::ipc::IpcWriteOptions WriteOptions; - TVector<std::pair<TString, NScheme::TTypeInfo>> YdbSchema; + std::vector<std::pair<TString, NScheme::TTypeInfo>> YdbSchema; std::unique_ptr<arrow::RecordBatchBuilder> BatchBuilder; std::shared_ptr<arrow::RecordBatch> Batch; size_t RowsToReserve{DEFAULT_ROWS_TO_RESERVE}; diff --git a/ydb/core/formats/arrow/arrow_helpers.cpp b/ydb/core/formats/arrow/arrow_helpers.cpp index 04d5fbd7ce..00b9ee850c 100644 --- a/ydb/core/formats/arrow/arrow_helpers.cpp +++ b/ydb/core/formats/arrow/arrow_helpers.cpp @@ -109,7 +109,7 @@ std::shared_ptr<arrow::DataType> GetCSVArrowType(NScheme::TTypeInfo typeId) { } } -std::vector<std::shared_ptr<arrow::Field>> MakeArrowFields(const TVector<std::pair<TString, NScheme::TTypeInfo>>& columns) { +std::vector<std::shared_ptr<arrow::Field>> MakeArrowFields(const std::vector<std::pair<TString, NScheme::TTypeInfo>>& columns) { std::vector<std::shared_ptr<arrow::Field>> fields; fields.reserve(columns.size()); for (auto& [name, ydbType] : columns) { @@ -119,7 +119,7 @@ std::vector<std::shared_ptr<arrow::Field>> MakeArrowFields(const TVector<std::pa return fields; } -std::shared_ptr<arrow::Schema> MakeArrowSchema(const TVector<std::pair<TString, NScheme::TTypeInfo>>& ydbColumns) { +std::shared_ptr<arrow::Schema> MakeArrowSchema(const std::vector<std::pair<TString, NScheme::TTypeInfo>>& ydbColumns) { return std::make_shared<arrow::Schema>(MakeArrowFields(ydbColumns)); } @@ -338,7 +338,7 @@ std::shared_ptr<arrow::RecordBatch> ToBatch(const std::shared_ptr<arrow::Table>& std::shared_ptr<arrow::RecordBatch> CombineSortedBatches(const std::vector<std::shared_ptr<arrow::RecordBatch>>& batches, const std::shared_ptr<TSortDescription>& description) { - TVector<NArrow::IInputStream::TPtr> streams; + std::vector<NArrow::IInputStream::TPtr> streams; for (auto& batch : batches) { streams.push_back(std::make_shared<NArrow::TOneBatchInputStream>(batch)); } @@ -589,8 +589,8 @@ std::vector<std::shared_ptr<arrow::Array>> Finish(std::vector<std::unique_ptr<ar return out; } -TVector<TString> ColumnNames(const std::shared_ptr<arrow::Schema>& schema) { - TVector<TString> out; +std::vector<TString> ColumnNames(const std::shared_ptr<arrow::Schema>& schema) { + std::vector<TString> out; out.reserve(schema->num_fields()); for (int i = 0; i < schema->num_fields(); ++i) { auto& name = schema->field(i)->name(); diff --git a/ydb/core/formats/arrow/arrow_helpers.h b/ydb/core/formats/arrow/arrow_helpers.h index c6bebcce3d..91f3731e66 100644 --- a/ydb/core/formats/arrow/arrow_helpers.h +++ b/ydb/core/formats/arrow/arrow_helpers.h @@ -60,8 +60,8 @@ inline bool ArrayEqualView(const std::shared_ptr<arrow::Array>& x, const std::sh struct TSortDescription; -std::vector<std::shared_ptr<arrow::Field>> MakeArrowFields(const TVector<std::pair<TString, NScheme::TTypeInfo>>& columns); -std::shared_ptr<arrow::Schema> MakeArrowSchema(const TVector<std::pair<TString, NScheme::TTypeInfo>>& columns); +std::vector<std::shared_ptr<arrow::Field>> MakeArrowFields(const std::vector<std::pair<TString, NScheme::TTypeInfo>>& columns); +std::shared_ptr<arrow::Schema> MakeArrowSchema(const std::vector<std::pair<TString, NScheme::TTypeInfo>>& columns); TString SerializeSchema(const arrow::Schema& schema); std::shared_ptr<arrow::Schema> DeserializeSchema(const TString& str); @@ -107,7 +107,7 @@ std::vector<std::shared_ptr<arrow::Array>> Finish(std::vector<std::unique_ptr<ar std::shared_ptr<arrow::UInt64Array> MakeUI64Array(ui64 value, i64 size); std::shared_ptr<arrow::UInt64Array> MakePermutation(int size, bool reverse = false); -TVector<TString> ColumnNames(const std::shared_ptr<arrow::Schema>& schema); +std::vector<TString> ColumnNames(const std::shared_ptr<arrow::Schema>& schema); size_t LowerBound(const std::vector<TRawReplaceKey>& batchKeys, const TReplaceKey& key, size_t offset = 0); bool ReserveData(arrow::ArrayBuilder& builder, const size_t size); bool MergeBatchColumns(const std::vector<std::shared_ptr<arrow::RecordBatch>>& batches, std::shared_ptr<arrow::RecordBatch>& result, const std::vector<std::string>& columnsOrder = {}, const bool orderFieldsAreNecessary = true); diff --git a/ydb/core/formats/arrow/converter.h b/ydb/core/formats/arrow/converter.h index f4dff7c919..47906fb481 100644 --- a/ydb/core/formats/arrow/converter.h +++ b/ydb/core/formats/arrow/converter.h @@ -20,7 +20,7 @@ public: // Converts an arrow batch into YDB rows feeding them IRowWriter one by one class TArrowToYdbConverter { private: - TVector<std::pair<TString, NScheme::TTypeInfo>> YdbSchema_; // Destination schema (allow shrink and reorder) + std::vector<std::pair<TString, NScheme::TTypeInfo>> YdbSchema_; // Destination schema (allow shrink and reorder) IRowWriter& RowWriter_; template <typename TArray> @@ -63,7 +63,7 @@ public: static bool NeedConversion(const NScheme::TTypeInfo& typeInRequest, const NScheme::TTypeInfo& expectedType); - TArrowToYdbConverter(const TVector<std::pair<TString, NScheme::TTypeInfo>>& ydbSchema, IRowWriter& rowWriter) + TArrowToYdbConverter(const std::vector<std::pair<TString, NScheme::TTypeInfo>>& ydbSchema, IRowWriter& rowWriter) : YdbSchema_(ydbSchema) , RowWriter_(rowWriter) {} diff --git a/ydb/core/formats/arrow/ut_arrow.cpp b/ydb/core/formats/arrow/ut_arrow.cpp index d1d77b1578..b167abc736 100644 --- a/ydb/core/formats/arrow/ut_arrow.cpp +++ b/ydb/core/formats/arrow/ut_arrow.cpp @@ -118,8 +118,8 @@ struct TDataRow { return std::make_shared<arrow::Schema>(std::move(fields)); } - static TVector<std::pair<TString, TTypeInfo>> MakeYdbSchema() { - TVector<std::pair<TString, TTypeInfo>> columns = { + static std::vector<std::pair<TString, TTypeInfo>> MakeYdbSchema() { + std::vector<std::pair<TString, TTypeInfo>> columns = { {"bool", TTypeInfo(NTypeIds::Bool) }, {"i8", TTypeInfo(NTypeIds::Int8) }, {"i16", TTypeInfo(NTypeIds::Int16) }, @@ -174,7 +174,7 @@ struct TDataRow { TOwnedCellVec SerializedCells() const { NKikimr::TDbTupleRef value = ToDbTupleRef(); - TVector<TCell> cells(value.Cells().data(), value.Cells().data() + value.Cells().size()); + std::vector<TCell> cells(value.Cells().data(), value.Cells().data() + value.Cells().size()); auto binaryJson = NBinaryJson::SerializeToBinaryJson(TStringBuf(JsonDocument.data(), JsonDocument.size())); UNIT_ASSERT(binaryJson.Defined()); @@ -571,7 +571,7 @@ Y_UNIT_TEST_SUITE(ArrowTest) { Y_UNIT_TEST(ArrowToYdbConverter) { std::vector<TDataRow> rows = TestRows(); - TVector<TOwnedCellVec> cellRows; + std::vector<TOwnedCellVec> cellRows; for (const TDataRow& row : rows) { cellRows.push_back(TOwnedCellVec(row.SerializedCells())); } @@ -584,7 +584,7 @@ Y_UNIT_TEST_SUITE(ArrowTest) { UNIT_ASSERT_EQUAL(expectedSchema->Equals(*batch->schema()), true); struct TRowWriter : public NArrow::IRowWriter { - TVector<TOwnedCellVec> Rows; + std::vector<TOwnedCellVec> Rows; void AddRow(const TConstArrayRef<TCell> &cells) override { Rows.push_back(TOwnedCellVec(cells)); @@ -662,7 +662,7 @@ Y_UNIT_TEST_SUITE(ArrowTest) { std::shared_ptr<arrow::RecordBatch> batch = ExtractBatch(MakeTable1000()); UNIT_ASSERT(CheckSorted1000(batch)); - TVector<std::shared_ptr<arrow::RecordBatch>> batches; + std::vector<std::shared_ptr<arrow::RecordBatch>> batches; batches.push_back(batch->Slice(0, 100)); // 0..100 batches.push_back(batch->Slice(100, 200)); // 100..300 batches.push_back(batch->Slice(200, 400)); // 200..600 @@ -672,9 +672,9 @@ Y_UNIT_TEST_SUITE(ArrowTest) { auto descr = std::make_shared<NArrow::TSortDescription>(batch->schema()); descr->NotNull = true; - TVector<std::shared_ptr<arrow::RecordBatch>> sorted; + std::vector<std::shared_ptr<arrow::RecordBatch>> sorted; { // maxBatchSize = 500, no limit - TVector<NArrow::IInputStream::TPtr> streams; + std::vector<NArrow::IInputStream::TPtr> streams; for (auto& batch : batches) { streams.push_back(std::make_shared<NArrow::TOneBatchInputStream>(batch)); } @@ -701,7 +701,7 @@ Y_UNIT_TEST_SUITE(ArrowTest) { std::shared_ptr<arrow::RecordBatch> batch = ExtractBatch(MakeTable1000()); UNIT_ASSERT(CheckSorted1000(batch)); - TVector<std::shared_ptr<arrow::RecordBatch>> batches; + std::vector<std::shared_ptr<arrow::RecordBatch>> batches; batches.push_back(batch->Slice(0, 100)); // 0..100 batches.push_back(batch->Slice(100, 200)); // 100..300 batches.push_back(batch->Slice(200, 400)); // 200..600 @@ -712,9 +712,9 @@ Y_UNIT_TEST_SUITE(ArrowTest) { descr->NotNull = true; descr->Inverse(); - TVector<std::shared_ptr<arrow::RecordBatch>> sorted; + std::vector<std::shared_ptr<arrow::RecordBatch>> sorted; { // maxBatchSize = 500, no limit - TVector<NArrow::IInputStream::TPtr> streams; + std::vector<NArrow::IInputStream::TPtr> streams; for (auto& batch : batches) { streams.push_back(std::make_shared<NArrow::TOneBatchInputStream>(batch)); } @@ -741,7 +741,7 @@ Y_UNIT_TEST_SUITE(ArrowTest) { std::shared_ptr<arrow::RecordBatch> batch = ExtractBatch(MakeTable1000()); UNIT_ASSERT(CheckSorted1000(batch)); - TVector<std::shared_ptr<arrow::RecordBatch>> batches; + std::vector<std::shared_ptr<arrow::RecordBatch>> batches; batches.push_back(AddSnapColumn(batch->Slice(0, 400), 0)); batches.push_back(AddSnapColumn(batch->Slice(200, 400), 1)); batches.push_back(AddSnapColumn(batch->Slice(400, 400), 2)); @@ -754,9 +754,9 @@ Y_UNIT_TEST_SUITE(ArrowTest) { descr->Directions.back() = -1; // greater snapshot first descr->NotNull = true; - TVector<std::shared_ptr<arrow::RecordBatch>> sorted; + std::vector<std::shared_ptr<arrow::RecordBatch>> sorted; { - TVector<NArrow::IInputStream::TPtr> streams; + std::vector<NArrow::IInputStream::TPtr> streams; for (auto& batch : batches) { streams.push_back(std::make_shared<NArrow::TOneBatchInputStream>(batch)); } @@ -785,7 +785,7 @@ Y_UNIT_TEST_SUITE(ArrowTest) { std::shared_ptr<arrow::RecordBatch> batch = ExtractBatch(MakeTable1000()); UNIT_ASSERT(CheckSorted1000(batch)); - TVector<std::shared_ptr<arrow::RecordBatch>> batches; + std::vector<std::shared_ptr<arrow::RecordBatch>> batches; batches.push_back(AddSnapColumn(batch->Slice(0, 400), 0)); batches.push_back(AddSnapColumn(batch->Slice(200, 400), 1)); batches.push_back(AddSnapColumn(batch->Slice(400, 400), 2)); @@ -799,9 +799,9 @@ Y_UNIT_TEST_SUITE(ArrowTest) { descr->NotNull = true; descr->Inverse(); - TVector<std::shared_ptr<arrow::RecordBatch>> sorted; + std::vector<std::shared_ptr<arrow::RecordBatch>> sorted; { - TVector<NArrow::IInputStream::TPtr> streams; + std::vector<NArrow::IInputStream::TPtr> streams; for (auto& batch : batches) { streams.push_back(std::make_shared<NArrow::TOneBatchInputStream>(batch)); } diff --git a/ydb/core/formats/clickhouse_block.cpp b/ydb/core/formats/clickhouse_block.cpp index 2b5a629b51..6ca01b6862 100644 --- a/ydb/core/formats/clickhouse_block.cpp +++ b/ydb/core/formats/clickhouse_block.cpp @@ -555,7 +555,7 @@ size_t AddValue(const TMutableColumnPtr& column, const TCell& cell, NScheme::TTy return column->byteSize() - prevBytes; } -TTypesAndNames MakeColumns(const TDataTypeRegistryPtr& dataTypeRegistry, const TVector<std::pair<TString, NScheme::TTypeInfo>>& columns) { +TTypesAndNames MakeColumns(const TDataTypeRegistryPtr& dataTypeRegistry, const std::vector<std::pair<TString, NScheme::TTypeInfo>>& columns) { TTypesAndNames res; for (auto& c : columns) { TDataTypePtr dataType = dataTypeRegistry->GetByYdbType(c.second); @@ -575,7 +575,7 @@ class TBlockBuilder : public NKikimr::IBlockBuilder { public: explicit TBlockBuilder(TDataTypeRegistryPtr dataTypeRegistry); ~TBlockBuilder(); - bool Start(const TVector<std::pair<TString, NScheme::TTypeInfo>>& columns, ui64 maxRowsInBlock, ui64 maxBytesInBlock, TString& err) override; + bool Start(const std::vector<std::pair<TString, NScheme::TTypeInfo>>& columns, ui64 maxRowsInBlock, ui64 maxBytesInBlock, TString& err) override; void AddRow(const NKikimr::TDbTupleRef& key, const NKikimr::TDbTupleRef& value) override; TString Finish() override; size_t Bytes() const override; @@ -594,7 +594,7 @@ private: class TBlockBuilder::TImpl { constexpr static ui32 DBMS_MIN_REVISION_WITH_CURRENT_AGGREGATION_VARIANT_SELECTION_METHOD = 54408; public: - TImpl(const TDataTypeRegistryPtr& dataTypeRegistry, const TVector<std::pair<TString, NScheme::TTypeInfo>>& columns, ui64 maxRowsInBlock, ui64 maxBytesInBlock) + TImpl(const TDataTypeRegistryPtr& dataTypeRegistry, const std::vector<std::pair<TString, NScheme::TTypeInfo>>& columns, ui64 maxRowsInBlock, ui64 maxBytesInBlock) : MaxRowsInBlock(maxRowsInBlock) , MaxBytesInBlock(maxBytesInBlock) , BlockTemplate(MakeColumns(dataTypeRegistry, columns)) @@ -663,7 +663,7 @@ TBlockBuilder::TBlockBuilder(TDataTypeRegistryPtr dataTypeRegistry) TBlockBuilder::~TBlockBuilder() { } -bool TBlockBuilder::Start(const TVector<std::pair<TString, NScheme::TTypeInfo>>& columns, ui64 maxRowsInBlock, ui64 maxBytesInBlock, TString& err) { +bool TBlockBuilder::Start(const std::vector<std::pair<TString, NScheme::TTypeInfo>>& columns, ui64 maxRowsInBlock, ui64 maxBytesInBlock, TString& err) { try { Impl.Reset(new TImpl(DataTypeRegistry, columns, maxRowsInBlock, maxBytesInBlock)); } catch (std::exception& e) { diff --git a/ydb/core/formats/factory.h b/ydb/core/formats/factory.h index 40d44a12d4..74d9025332 100644 --- a/ydb/core/formats/factory.h +++ b/ydb/core/formats/factory.h @@ -11,7 +11,7 @@ class IBlockBuilder { public: virtual ~IBlockBuilder() = default; - virtual bool Start(const TVector<std::pair<TString, NScheme::TTypeInfo>>& columns, ui64 maxRowsInBlock, ui64 maxBytesInBlock, TString& err) = 0; + virtual bool Start(const std::vector<std::pair<TString, NScheme::TTypeInfo>>& columns, ui64 maxRowsInBlock, ui64 maxBytesInBlock, TString& err) = 0; virtual void AddRow(const TDbTupleRef& key, const TDbTupleRef& value) = 0; virtual TString Finish() = 0; virtual size_t Bytes() const = 0; diff --git a/ydb/core/tx/columnshard/blob_manager.cpp b/ydb/core/tx/columnshard/blob_manager.cpp index 4526fceb7a..5ed428342f 100644 --- a/ydb/core/tx/columnshard/blob_manager.cpp +++ b/ydb/core/tx/columnshard/blob_manager.cpp @@ -24,11 +24,11 @@ struct TBlobBatch::TBatchInfo : TNonCopyable { const ui32 Step; const ui32 Channel; - TVector<ui32> BlobSizes; - TVector<bool> InFlight; + std::vector<ui32> BlobSizes; + std::vector<bool> InFlight; i32 InFlightCount; ui64 TotalSizeBytes; - TVector<TString> SmallBlobs; + std::vector<TString> SmallBlobs; TBatchInfo(TIntrusivePtr<TTabletStorageInfo> tabletInfo, TAllocatedGenStepConstPtr genStep, ui32 channel) : TabletInfo(tabletInfo) @@ -155,8 +155,8 @@ bool TBlobManager::LoadState(IBlobManagerDb& db) { } // Load the keep and delete queues - TVector<TUnifiedBlobId> blobsToKeep; - TVector<TUnifiedBlobId> blobsToDelete; + std::vector<TUnifiedBlobId> blobsToKeep; + std::vector<TUnifiedBlobId> blobsToDelete; TBlobGroupSelector dsGroupSelector(TabletInfo); if (!db.LoadLists(blobsToKeep, blobsToDelete, &dsGroupSelector)) { return false; diff --git a/ydb/core/tx/columnshard/blob_manager_db.cpp b/ydb/core/tx/columnshard/blob_manager_db.cpp index b627558843..c7a8b90bd5 100644 --- a/ydb/core/tx/columnshard/blob_manager_db.cpp +++ b/ydb/core/tx/columnshard/blob_manager_db.cpp @@ -23,7 +23,7 @@ void TBlobManagerDb::SaveLastGcBarrier(const TGenStep& lastCollectedGenStep) { Schema::SaveSpecialValue(db, Schema::EValueIds::LastGcBarrierStep, std::get<1>(lastCollectedGenStep)); } -bool TBlobManagerDb::LoadLists(TVector<TUnifiedBlobId>& blobsToKeep, TVector<TUnifiedBlobId>& blobsToDelete, +bool TBlobManagerDb::LoadLists(std::vector<TUnifiedBlobId>& blobsToKeep, std::vector<TUnifiedBlobId>& blobsToDelete, const NOlap::IBlobGroupSelector* dsGroupSelector) { blobsToKeep.clear(); diff --git a/ydb/core/tx/columnshard/blob_manager_db.h b/ydb/core/tx/columnshard/blob_manager_db.h index 72f0031c35..e840c0d336 100644 --- a/ydb/core/tx/columnshard/blob_manager_db.h +++ b/ydb/core/tx/columnshard/blob_manager_db.h @@ -16,7 +16,7 @@ public: virtual bool LoadLastGcBarrier(TGenStep& lastCollectedGenStep) = 0; virtual void SaveLastGcBarrier(const TGenStep& lastCollectedGenStep) = 0; - virtual bool LoadLists(TVector<TUnifiedBlobId>& blobsToKeep, TVector<TUnifiedBlobId>& blobsToDelete, + virtual bool LoadLists(std::vector<TUnifiedBlobId>& blobsToKeep, std::vector<TUnifiedBlobId>& blobsToDelete, const NOlap::IBlobGroupSelector* dsGroupSelector) = 0; virtual void AddBlobToKeep(const TUnifiedBlobId& blobId) = 0; virtual void EraseBlobToKeep(const TUnifiedBlobId& blobId) = 0; @@ -43,7 +43,7 @@ public: bool LoadLastGcBarrier(TGenStep& lastCollectedGenStep) override; void SaveLastGcBarrier(const TGenStep& lastCollectedGenStep) override; - bool LoadLists(TVector<TUnifiedBlobId>& blobsToKeep, TVector<TUnifiedBlobId>& blobsToDelete, + bool LoadLists(std::vector<TUnifiedBlobId>& blobsToKeep, std::vector<TUnifiedBlobId>& blobsToDelete, const NOlap::IBlobGroupSelector* dsGroupSelector) override; void AddBlobToKeep(const TUnifiedBlobId& blobId) override; void EraseBlobToKeep(const TUnifiedBlobId& blobId) override; diff --git a/ydb/core/tx/columnshard/columnshard__plan_step.cpp b/ydb/core/tx/columnshard/columnshard__plan_step.cpp index d11687dc72..97f48de577 100644 --- a/ydb/core/tx/columnshard/columnshard__plan_step.cpp +++ b/ydb/core/tx/columnshard/columnshard__plan_step.cpp @@ -21,7 +21,7 @@ public: private: TEvTxProcessing::TEvPlanStep::TPtr Ev; - THashMap<TActorId, TVector<ui64>> TxAcks; + THashMap<TActorId, std::vector<ui64>> TxAcks; std::unique_ptr<TEvTxProcessing::TEvPlanStepAccepted> Result; }; @@ -36,7 +36,7 @@ bool TTxPlanStep::Execute(TTransactionContext& txc, const TActorContext& ctx) { auto& record = Ev->Get()->Record; ui64 step = record.GetStep(); - TVector<ui64> txIds; + std::vector<ui64> txIds; for (const auto& tx : record.GetTransactions()) { Y_VERIFY(tx.HasTxId()); Y_VERIFY(tx.HasAckTo()); diff --git a/ydb/core/tx/columnshard/columnshard__read.cpp b/ydb/core/tx/columnshard/columnshard__read.cpp index bd7c9894ab..2345be01ef 100644 --- a/ydb/core/tx/columnshard/columnshard__read.cpp +++ b/ydb/core/tx/columnshard/columnshard__read.cpp @@ -12,8 +12,8 @@ namespace NKikimr::NColumnShard { namespace { template <typename T, typename U> -TVector<T> ProtoToVector(const U& cont) { - return TVector<T>(cont.begin(), cont.end()); +std::vector<T> ProtoToVector(const U& cont) { + return std::vector<T>(cont.begin(), cont.end()); } } diff --git a/ydb/core/tx/columnshard/columnshard__read_base.cpp b/ydb/core/tx/columnshard/columnshard__read_base.cpp index bf21cb1419..3a69c0d33f 100644 --- a/ydb/core/tx/columnshard/columnshard__read_base.cpp +++ b/ydb/core/tx/columnshard/columnshard__read_base.cpp @@ -25,7 +25,7 @@ TTxReadBase::PrepareReadMetadata(const TActorContext& ctx, const NOlap::TReadDes NOlap::TDataStorageAccessor dataAccessor(insertTable, index, batchCache); auto readMetadata = std::make_shared<NOlap::TReadMetadata>(index->GetVersionedIndex(), read.GetSnapshot(), isReverse ? NOlap::TReadMetadata::ESorting::DESC : NOlap::TReadMetadata::ESorting::ASC); - + if (!readMetadata->Init(read, dataAccessor, error)) { return nullptr; } diff --git a/ydb/core/tx/columnshard/columnshard__scan.cpp b/ydb/core/tx/columnshard/columnshard__scan.cpp index 8595380343..a925f1876e 100644 --- a/ydb/core/tx/columnshard/columnshard__scan.cpp +++ b/ydb/core/tx/columnshard/columnshard__scan.cpp @@ -41,7 +41,7 @@ private: private: TEvColumnShard::TEvScan::TPtr Ev; - TVector<TReadMetadataPtr> ReadMetadataRanges; + std::vector<TReadMetadataPtr> ReadMetadataRanges; }; @@ -73,7 +73,7 @@ public: public: TColumnShardScan(const TActorId& columnShardActorId, const TActorId& scanComputeActorId, ui32 scanId, ui64 txId, ui32 scanGen, ui64 requestCookie, - ui64 tabletId, TDuration timeout, TVector<TTxScan::TReadMetadataPtr>&& readMetadataList, + ui64 tabletId, TDuration timeout, std::vector<TTxScan::TReadMetadataPtr>&& readMetadataList, NKikimrTxDataShard::EScanDataFormat dataFormat, const TScanCounters& scanCountersPool) : ColumnShardActorId(columnShardActorId) , ScanComputeActorId(scanComputeActorId) @@ -577,12 +577,12 @@ private: const NKikimrTxDataShard::EScanDataFormat DataFormat; const ui64 TabletId; - TVector<NOlap::TReadMetadataBase::TConstPtr> ReadMetadataRanges; + std::vector<NOlap::TReadMetadataBase::TConstPtr> ReadMetadataRanges; ui32 ReadMetadataIndex; std::unique_ptr<TScanIteratorBase> ScanIterator; - TVector<std::pair<TString, NScheme::TTypeInfo>> ResultYqlSchema; - TVector<std::pair<TString, NScheme::TTypeInfo>> KeyYqlSchema; + std::vector<std::pair<TString, NScheme::TTypeInfo>> ResultYqlSchema; + std::vector<std::pair<TString, NScheme::TTypeInfo>> KeyYqlSchema; const TSerializedTableRange TableRange; const TSmallVec<bool> SkipNullKeys; const TInstant Deadline; @@ -743,7 +743,7 @@ private: }; static bool FillPredicatesFromRange(NOlap::TReadDescription& read, const ::NKikimrTx::TKeyRange& keyRange, - const TVector<std::pair<TString, NScheme::TTypeInfo>>& ydbPk, ui64 tabletId, const NOlap::TIndexInfo* indexInfo) { + const std::vector<std::pair<TString, NScheme::TTypeInfo>>& ydbPk, ui64 tabletId, const NOlap::TIndexInfo* indexInfo) { TSerializedTableRange range(keyRange); auto fromPredicate = std::make_shared<NOlap::TPredicate>(); auto toPredicate = std::make_shared<NOlap::TPredicate>(); @@ -951,7 +951,7 @@ void TTxScan::Complete(const TActorContext& ctx) { if (IS_LOG_PRIORITY_ENABLED(ctx, NActors::NLog::PRI_TRACE, NKikimrServices::TX_COLUMNSHARD)) { detailedInfo << " read metadata: (" << TContainerPrinter(ReadMetadataRanges) << ")" << " req: " << request; } - TVector<NOlap::TReadMetadata::TConstPtr> rMetadataRanges; + std::vector<NOlap::TReadMetadata::TConstPtr> rMetadataRanges; if (ReadMetadataRanges.empty()) { LOG_S_DEBUG("TTxScan failed " diff --git a/ydb/core/tx/columnshard/columnshard__stats_scan.cpp b/ydb/core/tx/columnshard/columnshard__stats_scan.cpp index cc6191e19b..fd36c78d4e 100644 --- a/ydb/core/tx/columnshard/columnshard__stats_scan.cpp +++ b/ydb/core/tx/columnshard/columnshard__stats_scan.cpp @@ -33,7 +33,7 @@ std::shared_ptr<arrow::RecordBatch> TStatsIterator::FillStatsBatch() { ui64 numRows = 0; numRows += NUM_KINDS * IndexStats.size(); - TVector<ui32> allColumnIds; + std::vector<ui32> allColumnIds; for (const auto& c : PrimaryIndexStatsSchema.Columns) { allColumnIds.push_back(c.second.Id); } diff --git a/ydb/core/tx/columnshard/columnshard_common.cpp b/ydb/core/tx/columnshard/columnshard_common.cpp index 2c4405be15..7a95dbc3f5 100644 --- a/ydb/core/tx/columnshard/columnshard_common.cpp +++ b/ydb/core/tx/columnshard/columnshard_common.cpp @@ -10,8 +10,8 @@ using EAggregate = NArrow::EAggregate; using TAssign = NSsa::TAssign; using TAggregateAssign = NSsa::TAggregateAssign; -TVector<NScheme::TTypeInfo> ExtractTypes(const TVector<std::pair<TString, NScheme::TTypeInfo>>& columns) { - TVector<NScheme::TTypeInfo> types; +std::vector<NScheme::TTypeInfo> ExtractTypes(const std::vector<std::pair<TString, NScheme::TTypeInfo>>& columns) { + std::vector<NScheme::TTypeInfo> types; types.reserve(columns.size()); for (auto& [name, type] : columns) { types.push_back(type); @@ -19,13 +19,13 @@ TVector<NScheme::TTypeInfo> ExtractTypes(const TVector<std::pair<TString, NSchem return types; } -TString FromCells(const TConstArrayRef<TCell>& cells, const TVector<std::pair<TString, NScheme::TTypeInfo>>& columns) { +TString FromCells(const TConstArrayRef<TCell>& cells, const std::vector<std::pair<TString, NScheme::TTypeInfo>>& columns) { Y_VERIFY(cells.size() == columns.size()); if (cells.empty()) { return {}; } - TVector<NScheme::TTypeInfo> types = ExtractTypes(columns); + std::vector<NScheme::TTypeInfo> types = ExtractTypes(columns); NArrow::TArrowBatchBuilder batchBuilder; batchBuilder.Reserve(1); @@ -46,9 +46,9 @@ using EOperation = NArrow::EOperation; using TPredicate = NOlap::TPredicate; std::pair<TPredicate, TPredicate> RangePredicates(const TSerializedTableRange& range, - const TVector<std::pair<TString, NScheme::TTypeInfo>>& columns) { - TVector<TCell> leftCells; - TVector<std::pair<TString, NScheme::TTypeInfo>> leftColumns; + const std::vector<std::pair<TString, NScheme::TTypeInfo>>& columns) { + std::vector<TCell> leftCells; + std::vector<std::pair<TString, NScheme::TTypeInfo>> leftColumns; bool leftTrailingNull = false; { TConstArrayRef<TCell> cells = range.From.GetCells(); @@ -67,8 +67,8 @@ std::pair<TPredicate, TPredicate> RangePredicates(const TSerializedTableRange& r } } - TVector<TCell> rightCells; - TVector<std::pair<TString, NScheme::TTypeInfo>> rightColumns; + std::vector<TCell> rightCells; + std::vector<std::pair<TString, NScheme::TTypeInfo>> rightColumns; bool rightTrailingNull = false; { TConstArrayRef<TCell> cells = range.To.GetCells(); diff --git a/ydb/core/tx/columnshard/columnshard_common.h b/ydb/core/tx/columnshard/columnshard_common.h index ae1c03f69d..abe331ed44 100644 --- a/ydb/core/tx/columnshard/columnshard_common.h +++ b/ydb/core/tx/columnshard/columnshard_common.h @@ -15,7 +15,7 @@ using IColumnResolver = NOlap::IColumnResolver; using NOlap::TWriteId; std::pair<NOlap::TPredicate, NOlap::TPredicate> -RangePredicates(const TSerializedTableRange& range, const TVector<std::pair<TString, NScheme::TTypeInfo>>& columns); +RangePredicates(const TSerializedTableRange& range, const std::vector<std::pair<TString, NScheme::TTypeInfo>>& columns); class TBatchCache { public: diff --git a/ydb/core/tx/columnshard/columnshard_impl.cpp b/ydb/core/tx/columnshard/columnshard_impl.cpp index 271779dedf..4004ca1511 100644 --- a/ydb/core/tx/columnshard/columnshard_impl.cpp +++ b/ydb/core/tx/columnshard/columnshard_impl.cpp @@ -680,7 +680,7 @@ std::unique_ptr<TEvPrivate::TEvIndexing> TColumnShard::SetupIndexation() { ui32 ignored = 0; ui64 size = 0; ui64 bytesToIndex = 0; - TVector<const NOlap::TInsertedData*> dataToIndex; + std::vector<const NOlap::TInsertedData*> dataToIndex; dataToIndex.reserve(TLimits::MIN_SMALL_BLOBS_TO_INSERT); THashMap<ui64, ui64> overloadedPathGranules; for (auto& [pathId, committed] : InsertTable->GetCommitted()) { @@ -728,7 +728,7 @@ std::unique_ptr<TEvPrivate::TEvIndexing> TColumnShard::SetupIndexation() { << size << " bytes in " << blobs << " blobs ignored " << ignored << " at tablet " << TabletID()); - TVector<NOlap::TInsertedData> data; + std::vector<NOlap::TInsertedData> data; THashMap<TUnifiedBlobId, std::shared_ptr<arrow::RecordBatch>> cachedBlobs; data.reserve(dataToIndex.size()); for (auto& ptr : dataToIndex) { @@ -790,7 +790,7 @@ std::unique_ptr<TEvPrivate::TEvCompaction> TColumnShard::SetupCompaction() { Settings.CacheDataAfterCompaction); if (Tiers) { ev->SetTiering(Tiers->GetTiering()); - } + } return std::make_unique<TEvPrivate::TEvCompaction>(std::move(ev), *BlobManager); } @@ -871,7 +871,7 @@ std::unique_ptr<TEvPrivate::TEvWriteIndex> TColumnShard::SetupCleanup() { Y_VERIFY(changes->AppendedPortions.empty()); // Filter PortionsToDrop - TVector<NOlap::TPortionInfo> portionsCanBedropped; + std::vector<NOlap::TPortionInfo> portionsCanBedropped; THashSet<ui64> excludedPortions; for (const auto& portionInfo : changes->PortionsToDrop) { ui64 portionId = portionInfo.Records.front().Portion; diff --git a/ydb/core/tx/columnshard/columnshard_private_events.h b/ydb/core/tx/columnshard/columnshard_private_events.h index 0349c8ffaf..685f6c4788 100644 --- a/ydb/core/tx/columnshard/columnshard_private_events.h +++ b/ydb/core/tx/columnshard/columnshard_private_events.h @@ -31,7 +31,7 @@ struct TEvPrivate { THashMap<ui64, NKikimr::NOlap::TTiering> Tiering; std::shared_ptr<NOlap::TColumnEngineChanges> IndexChanges; THashMap<TUnifiedBlobId, std::shared_ptr<arrow::RecordBatch>> CachedBlobs; - TVector<TString> Blobs; + std::vector<TString> Blobs; bool GranuleCompaction{false}; TBlobBatch BlobBatch; TUsage ResourceUsage; diff --git a/ydb/core/tx/columnshard/columnshard_ut_common.cpp b/ydb/core/tx/columnshard/columnshard_ut_common.cpp index 3333820f3a..c227d77ecb 100644 --- a/ydb/core/tx/columnshard/columnshard_ut_common.cpp +++ b/ydb/core/tx/columnshard/columnshard_ut_common.cpp @@ -25,12 +25,12 @@ void TTester::Setup(TTestActorRuntime& runtime) { auto domain = TDomainsInfo::TDomain::ConstructDomainWithExplicitTabletIds( "dc-1", domainId, FAKE_SCHEMESHARD_TABLET_ID, - domainId, domainId, TVector<ui32>{domainId}, - domainId, TVector<ui32>{domainId}, + domainId, domainId, std::vector<ui32>{domainId}, + domainId, std::vector<ui32>{domainId}, planResolution, - TVector<ui64>{TDomainsInfo::MakeTxCoordinatorIDFixed(domainId, 1)}, - TVector<ui64>{}, - TVector<ui64>{TDomainsInfo::MakeTxAllocatorIDFixed(domainId, 1)}); + std::vector<ui64>{TDomainsInfo::MakeTxCoordinatorIDFixed(domainId, 1)}, + std::vector<ui64>{}, + std::vector<ui64>{TDomainsInfo::MakeTxAllocatorIDFixed(domainId, 1)}); TVector<ui64> ids = runtime.GetTxAllocatorTabletIds(); ids.insert(ids.end(), domain->TxAllocators.begin(), domain->TxAllocators.end()); @@ -115,7 +115,7 @@ std::optional<ui64> WriteData(TTestBasicRuntime& runtime, TActorId& sender, cons return {}; } -void ScanIndexStats(TTestBasicRuntime& runtime, TActorId& sender, const TVector<ui64>& pathIds, +void ScanIndexStats(TTestBasicRuntime& runtime, TActorId& sender, const std::vector<ui64>& pathIds, NOlap::TSnapshot snap, ui64 scanId) { auto scan = std::make_unique<TEvColumnShard::TEvScan>(); auto& record = scan->Record; @@ -140,7 +140,7 @@ void ScanIndexStats(TTestBasicRuntime& runtime, TActorId& sender, const TVector< } for (ui64 pathId : pathIds) { - TVector<TCell> pk{TCell::Make<ui64>(pathId)}; + 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); @@ -153,7 +153,7 @@ void ScanIndexStats(TTestBasicRuntime& runtime, TActorId& sender, const TVector< ForwardToTablet(runtime, TTestTxConfig::TxTablet0, sender, scan.release()); } -void ProposeCommit(TTestBasicRuntime& runtime, TActorId& sender, ui64 metaShard, ui64 txId, const TVector<ui64>& writeIds) { +void ProposeCommit(TTestBasicRuntime& runtime, TActorId& sender, ui64 metaShard, ui64 txId, const std::vector<ui64>& writeIds) { NKikimrTxColumnShard::ETransactionKind txKind = NKikimrTxColumnShard::ETransactionKind::TX_KIND_COMMIT; TString txBody = TTestSchema::CommitTxBody(metaShard, writeIds); @@ -169,7 +169,7 @@ void ProposeCommit(TTestBasicRuntime& runtime, TActorId& sender, ui64 metaShard, UNIT_ASSERT_EQUAL(res.GetStatus(), NKikimrTxColumnShard::EResultStatus::PREPARED); } -void ProposeCommit(TTestBasicRuntime& runtime, TActorId& sender, ui64 txId, const TVector<ui64>& writeIds) { +void ProposeCommit(TTestBasicRuntime& runtime, TActorId& sender, ui64 txId, const std::vector<ui64>& writeIds) { ProposeCommit(runtime, sender, 0, txId, writeIds); } @@ -194,8 +194,8 @@ void PlanCommit(TTestBasicRuntime& runtime, TActorId& sender, ui64 planStep, con } } -TVector<TCell> MakeTestCells(const TVector<TTypeInfo>& types, ui32 value, TVector<TString>& mem) { - TVector<TCell> cells; +std::vector<TCell> MakeTestCells(const std::vector<TTypeInfo>& types, ui32 value, std::vector<TString>& mem) { + std::vector<TCell> cells; cells.reserve(types.size()); for (auto& typeInfo : types) { @@ -237,24 +237,24 @@ TVector<TCell> MakeTestCells(const TVector<TTypeInfo>& types, ui32 value, TVecto return cells; } -TString MakeTestBlob(std::pair<ui64, ui64> range, const TVector<std::pair<TString, TTypeInfo>>& columns, +TString MakeTestBlob(std::pair<ui64, ui64> range, const std::vector<std::pair<TString, TTypeInfo>>& columns, const THashSet<TString>& nullColumns) { TString err; NArrow::TArrowBatchBuilder batchBuilder(arrow::Compression::LZ4_FRAME); batchBuilder.Start(columns, 0, 0, err); - TVector<ui32> nullPositions; + std::vector<ui32> nullPositions; for (size_t i = 0; i < columns.size(); ++i) { if (nullColumns.contains(columns[i].first)) { nullPositions.push_back(i); } } - TVector<TString> mem; - TVector<TTypeInfo> types = TTestSchema::ExtractTypes(columns); + std::vector<TString> mem; + std::vector<TTypeInfo> types = TTestSchema::ExtractTypes(columns); // insert, not ordered for (size_t i = range.first; i < range.second; i += 2) { - TVector<TCell> cells = MakeTestCells(types, i, mem); + std::vector<TCell> cells = MakeTestCells(types, i, mem); for (auto& pos : nullPositions) { cells[pos] = TCell(); } @@ -262,7 +262,7 @@ TString MakeTestBlob(std::pair<ui64, ui64> range, const TVector<std::pair<TStrin batchBuilder.AddRow(unused, NKikimr::TDbTupleRef(types.data(), cells.data(), types.size())); } for (size_t i = range.first + 1; i < range.second; i += 2) { - TVector<TCell> cells = MakeTestCells(types, i, mem); + std::vector<TCell> cells = MakeTestCells(types, i, mem); for (auto& pos : nullPositions) { cells[pos] = TCell(); } @@ -281,11 +281,11 @@ TString MakeTestBlob(std::pair<ui64, ui64> range, const TVector<std::pair<TStrin } TSerializedTableRange MakeTestRange(std::pair<ui64, ui64> range, bool inclusiveFrom, bool inclusiveTo, - const TVector<std::pair<TString, TTypeInfo>>& columns) { - TVector<TString> mem; - TVector<TTypeInfo> types = TTestSchema::ExtractTypes(columns); - TVector<TCell> cellsFrom = MakeTestCells(types, range.first, mem); - TVector<TCell> cellsTo = MakeTestCells(types, range.second, mem); + const std::vector<std::pair<TString, TTypeInfo>>& columns) { + std::vector<TString> mem; + std::vector<TTypeInfo> types = TTestSchema::ExtractTypes(columns); + std::vector<TCell> cellsFrom = MakeTestCells(types, range.first, mem); + std::vector<TCell> cellsTo = MakeTestCells(types, range.second, mem); return TSerializedTableRange(TConstArrayRef<TCell>(cellsFrom), inclusiveFrom, TConstArrayRef<TCell>(cellsTo), inclusiveTo); diff --git a/ydb/core/tx/columnshard/columnshard_ut_common.h b/ydb/core/tx/columnshard/columnshard_ut_common.h index 09027dc4cc..537d6cfe12 100644 --- a/ydb/core/tx/columnshard/columnshard_ut_common.h +++ b/ydb/core/tx/columnshard/columnshard_ut_common.h @@ -103,7 +103,7 @@ struct TTestSchema { }; static auto YdbSchema(const std::pair<TString, TTypeInfo>& firstKeyItem = {"timestamp", TTypeInfo(NTypeIds::Timestamp) }) { - TVector<std::pair<TString, TTypeInfo>> schema = { + std::vector<std::pair<TString, TTypeInfo>> schema = { // PK firstKeyItem, {"resource_type", TTypeInfo(NTypeIds::Utf8) }, @@ -120,7 +120,7 @@ struct TTestSchema { }; static auto YdbExoticSchema() { - TVector<std::pair<TString, TTypeInfo>> schema = { + std::vector<std::pair<TString, TTypeInfo>> schema = { // PK {"timestamp", TTypeInfo(NTypeIds::Timestamp) }, {"resource_type", TTypeInfo(NTypeIds::Utf8) }, @@ -138,7 +138,7 @@ struct TTestSchema { }; static auto YdbPkSchema() { - TVector<std::pair<TString, TTypeInfo>> schema = { + std::vector<std::pair<TString, TTypeInfo>> schema = { {"timestamp", TTypeInfo(NTypeIds::Timestamp) }, {"resource_type", TTypeInfo(NTypeIds::Utf8) }, {"resource_id", TTypeInfo(NTypeIds::Utf8) }, @@ -148,7 +148,7 @@ struct TTestSchema { } static auto YdbAllTypesSchema() { - TVector<std::pair<TString, TTypeInfo>> schema = { + std::vector<std::pair<TString, TTypeInfo>> schema = { { "ts", TTypeInfo(NTypeIds::Timestamp) }, { "i8", TTypeInfo(NTypeIds::Int8) }, @@ -192,8 +192,8 @@ struct TTestSchema { return col; } - static void InitSchema(const TVector<std::pair<TString, TTypeInfo>>& columns, - const TVector<std::pair<TString, TTypeInfo>>& pk, + static void InitSchema(const std::vector<std::pair<TString, TTypeInfo>>& columns, + const std::vector<std::pair<TString, TTypeInfo>>& pk, const TTableSpecials& specials, NKikimrSchemeOp::TColumnTableSchema* schema) { @@ -238,8 +238,8 @@ struct TTestSchema { return false; } - static TString CreateTableTxBody(ui64 pathId, const TVector<std::pair<TString, TTypeInfo>>& columns, - const TVector<std::pair<TString, TTypeInfo>>& pk, + static TString CreateTableTxBody(ui64 pathId, const std::vector<std::pair<TString, TTypeInfo>>& columns, + const std::vector<std::pair<TString, TTypeInfo>>& pk, const TTableSpecials& specials = {}) { NKikimrTxColumnShard::TSchemaTxBody tx; auto* table = tx.MutableEnsureTables()->AddTables(); @@ -263,8 +263,8 @@ struct TTestSchema { return out; } - static TString CreateInitShardTxBody(ui64 pathId, const TVector<std::pair<TString, TTypeInfo>>& columns, - const TVector<std::pair<TString, TTypeInfo>>& pk, + static TString CreateInitShardTxBody(ui64 pathId, const std::vector<std::pair<TString, TTypeInfo>>& columns, + const std::vector<std::pair<TString, TTypeInfo>>& pk, const TTableSpecials& specials = {}, const TString& ownerPath = "/Root/olap") { NKikimrTxColumnShard::TSchemaTxBody tx; auto* table = tx.MutableInitShard()->AddTables(); @@ -281,8 +281,8 @@ struct TTestSchema { return out; } - static TString CreateStandaloneTableTxBody(ui64 pathId, const TVector<std::pair<TString, TTypeInfo>>& columns, - const TVector<std::pair<TString, TTypeInfo>>& pk, + static TString CreateStandaloneTableTxBody(ui64 pathId, const std::vector<std::pair<TString, TTypeInfo>>& columns, + const std::vector<std::pair<TString, TTypeInfo>>& pk, const TTableSpecials& specials = {}) { NKikimrTxColumnShard::TSchemaTxBody tx; auto* table = tx.MutableEnsureTables()->AddTables(); @@ -328,7 +328,7 @@ struct TTestSchema { static NMetadata::NFetcher::ISnapshot::TPtr BuildSnapshot(const TTableSpecials& specials); - static TString CommitTxBody(ui64 metaShard, const TVector<ui64>& writeIds) { + static TString CommitTxBody(ui64 metaShard, const std::vector<ui64>& writeIds) { NKikimrTxColumnShard::TCommitTxBody proto; if (metaShard) { proto.SetTxInitiator(metaShard); @@ -342,7 +342,7 @@ struct TTestSchema { return txBody; } - static TString TtlTxBody(const TVector<ui64>& pathIds, TString ttlColumnName, ui64 tsSeconds) { + static TString TtlTxBody(const std::vector<ui64>& pathIds, TString ttlColumnName, ui64 tsSeconds) { NKikimrTxColumnShard::TTtlTxBody proto; proto.SetTtlColumnName(ttlColumnName); proto.SetUnixTimeSeconds(tsSeconds); @@ -355,8 +355,8 @@ struct TTestSchema { return txBody; } - static TVector<TString> ExtractNames(const TVector<std::pair<TString, NScheme::TTypeInfo>>& columns) { - TVector<TString> out; + static std::vector<TString> ExtractNames(const std::vector<std::pair<TString, NScheme::TTypeInfo>>& columns) { + std::vector<TString> out; out.reserve(columns.size()); for (auto& col : columns) { out.push_back(col.first); @@ -364,8 +364,8 @@ struct TTestSchema { return out; } - static TVector<NScheme::TTypeInfo> ExtractTypes(const TVector<std::pair<TString, NScheme::TTypeInfo>>& columns) { - TVector<NScheme::TTypeInfo> types; + static std::vector<NScheme::TTypeInfo> ExtractTypes(const std::vector<std::pair<TString, NScheme::TTypeInfo>>& columns) { + std::vector<NScheme::TTypeInfo> types; types.reserve(columns.size()); for (auto& [name, type] : columns) { types.push_back(type); @@ -382,10 +382,10 @@ bool WriteData(TTestBasicRuntime& runtime, TActorId& sender, ui64 metaShard, ui6 std::optional<ui64> WriteData(TTestBasicRuntime& runtime, TActorId& sender, const NLongTxService::TLongTxId& longTxId, ui64 tableId, const TString& dedupId, const TString& data, std::shared_ptr<arrow::Schema> schema = {}); -void ScanIndexStats(TTestBasicRuntime& runtime, TActorId& sender, const TVector<ui64>& pathIds, +void ScanIndexStats(TTestBasicRuntime& runtime, TActorId& sender, const std::vector<ui64>& pathIds, NOlap::TSnapshot snap, ui64 scanId = 0); -void ProposeCommit(TTestBasicRuntime& runtime, TActorId& sender, ui64 metaShard, ui64 txId, const TVector<ui64>& writeIds); -void ProposeCommit(TTestBasicRuntime& runtime, TActorId& sender, ui64 txId, const TVector<ui64>& writeIds); +void ProposeCommit(TTestBasicRuntime& runtime, TActorId& sender, ui64 metaShard, ui64 txId, const std::vector<ui64>& writeIds); +void ProposeCommit(TTestBasicRuntime& runtime, TActorId& sender, ui64 txId, const std::vector<ui64>& writeIds); void PlanCommit(TTestBasicRuntime& runtime, TActorId& sender, ui64 planStep, const TSet<ui64>& txIds); inline void PlanCommit(TTestBasicRuntime& runtime, TActorId& sender, ui64 planStep, ui64 txId) { @@ -394,9 +394,9 @@ inline void PlanCommit(TTestBasicRuntime& runtime, TActorId& sender, ui64 planSt PlanCommit(runtime, sender, planStep, ids); } -TString MakeTestBlob(std::pair<ui64, ui64> range, const TVector<std::pair<TString, NScheme::TTypeInfo>>& columns, +TString MakeTestBlob(std::pair<ui64, ui64> range, const std::vector<std::pair<TString, NScheme::TTypeInfo>>& columns, const THashSet<TString>& nullColumns = {}); TSerializedTableRange MakeTestRange(std::pair<ui64, ui64> range, bool inclusiveFrom, bool inclusiveTo, - const TVector<std::pair<TString, NScheme::TTypeInfo>>& columns); + const std::vector<std::pair<TString, NScheme::TTypeInfo>>& columns); } diff --git a/ydb/core/tx/columnshard/engines/column_engine.h b/ydb/core/tx/columnshard/engines/column_engine.h index cd030c6187..444fe64427 100644 --- a/ydb/core/tx/columnshard/engines/column_engine.h +++ b/ydb/core/tx/columnshard/engines/column_engine.h @@ -135,13 +135,13 @@ public: TSnapshot InitSnapshot = TSnapshot::Zero(); TSnapshot ApplySnapshot = TSnapshot::Zero(); std::unique_ptr<TCompactionInfo> CompactionInfo; - TVector<NOlap::TInsertedData> DataToIndex; - TVector<TPortionInfo> SwitchedPortions; // Portions that would be replaced by new ones - TVector<TPortionInfo> AppendedPortions; // New portions after indexing or compaction - TVector<TPortionInfo> PortionsToDrop; - TVector<std::pair<TPortionInfo, TPortionEvictionFeatures>> PortionsToEvict; // {portion, TPortionEvictionFeatures} - TVector<TColumnRecord> EvictedRecords; - TVector<std::pair<TPortionInfo, ui64>> PortionsToMove; // {portion, new granule} + std::vector<NOlap::TInsertedData> DataToIndex; + std::vector<TPortionInfo> SwitchedPortions; // Portions that would be replaced by new ones + std::vector<TPortionInfo> AppendedPortions; // New portions after indexing or compaction + std::vector<TPortionInfo> PortionsToDrop; + std::vector<std::pair<TPortionInfo, TPortionEvictionFeatures>> PortionsToEvict; // {portion, TPortionEvictionFeatures} + std::vector<TColumnRecord> EvictedRecords; + std::vector<std::pair<TPortionInfo, ui64>> PortionsToMove; // {portion, new granule} THashMap<TBlobRange, TString> Blobs; THashMap<TUnifiedBlobId, std::shared_ptr<arrow::RecordBatch>> CachedBlobs; bool NeedRepeat{false}; @@ -177,7 +177,7 @@ public: /// Returns blob-ranges grouped by blob-id. static THashMap<TUnifiedBlobId, std::vector<TBlobRange>> - GroupedBlobRanges(const TVector<TPortionInfo>& portions) { + GroupedBlobRanges(const std::vector<TPortionInfo>& portions) { Y_VERIFY(portions.size()); THashMap<TUnifiedBlobId, std::vector<TBlobRange>> sameBlobRanges; @@ -193,7 +193,7 @@ public: /// Returns blob-ranges grouped by blob-id. static THashMap<TUnifiedBlobId, std::vector<TBlobRange>> - GroupedBlobRanges(const TVector<std::pair<TPortionInfo, TPortionEvictionFeatures>>& portions) { + GroupedBlobRanges(const std::vector<std::pair<TPortionInfo, TPortionEvictionFeatures>>& portions) { Y_VERIFY(portions.size()); THashMap<TUnifiedBlobId, std::vector<TBlobRange>> sameBlobRanges; @@ -228,12 +228,12 @@ struct TSelectInfo { } }; - TVector<TGranuleRecord> Granules; // ordered by key (ascending) - TVector<TPortionInfo> Portions; + std::vector<TGranuleRecord> Granules; // ordered by key (ascending) + std::vector<TPortionInfo> Portions; - TVector<ui64> GranulesOrder(bool rev = false) const { + std::vector<ui64> GranulesOrder(bool rev = false) const { size_t size = Granules.size(); - TVector<ui64> order(size); + std::vector<ui64> order(size); if (rev) { size_t pos = size - 1; for (size_t i = 0; i < size; ++i, --pos) { @@ -384,7 +384,7 @@ public: const THashSet<ui32>& columnIds, const TPKRangesFilter& pkRangesFilter) const = 0; virtual std::unique_ptr<TCompactionInfo> Compact(ui64& lastCompactedGranule) = 0; - virtual std::shared_ptr<TColumnEngineChanges> StartInsert(TVector<TInsertedData>&& dataToIndex) = 0; + virtual std::shared_ptr<TColumnEngineChanges> StartInsert(std::vector<TInsertedData>&& dataToIndex) = 0; virtual std::shared_ptr<TColumnEngineChanges> StartCompaction(std::unique_ptr<TCompactionInfo>&& compactionInfo, const TSnapshot& outdatedSnapshot) = 0; virtual std::shared_ptr<TColumnEngineChanges> StartCleanup(const TSnapshot& snapshot, THashSet<ui64>& pathsToDrop, diff --git a/ydb/core/tx/columnshard/engines/column_engine_logs.cpp b/ydb/core/tx/columnshard/engines/column_engine_logs.cpp index 352c441bde..ec5b3b2579 100644 --- a/ydb/core/tx/columnshard/engines/column_engine_logs.cpp +++ b/ydb/core/tx/columnshard/engines/column_engine_logs.cpp @@ -12,7 +12,7 @@ namespace NKikimr::NOlap { namespace { -bool InitInGranuleMerge(const TMark& granuleMark, TVector<TPortionInfo>& portions, const TCompactionLimits& limits, +bool InitInGranuleMerge(const TMark& granuleMark, std::vector<TPortionInfo>& portions, const TCompactionLimits& limits, const TSnapshot& snap, TColumnEngineForLogs::TMarksGranules& marksGranules) { ui64 oldTimePlanStep = snap.GetPlanStep() - TDuration::Seconds(limits.InGranuleCompactSeconds).MilliSeconds(); ui32 insertedCount = 0; @@ -22,7 +22,7 @@ bool InitInGranuleMerge(const TMark& granuleMark, TVector<TPortionInfo>& portion THashSet<ui64> goodCompacted; THashSet<ui64> nextToGood; { - TMap<NArrow::TReplaceKey, TVector<const TPortionInfo*>> points; + TMap<NArrow::TReplaceKey, std::vector<const TPortionInfo*>> points; for (const auto& portionInfo : portions) { if (portionInfo.IsInserted()) { @@ -96,7 +96,7 @@ bool InitInGranuleMerge(const TMark& granuleMark, TVector<TPortionInfo>& portion std::vector<TMark> borders; borders.push_back(granuleMark); - TVector<TPortionInfo> tmp; + std::vector<TPortionInfo> tmp; tmp.reserve(portions.size()); for (const auto& portionInfo : portions) { ui64 curPortion = portionInfo.Portion(); @@ -127,8 +127,8 @@ bool InitInGranuleMerge(const TMark& granuleMark, TVector<TPortionInfo>& portion return true; } -TVector<const TPortionInfo*> GetActualPortions(const THashMap<ui64, TPortionInfo>& portions) { - TVector<const TPortionInfo*> out; +std::vector<const TPortionInfo*> GetActualPortions(const THashMap<ui64, TPortionInfo>& portions) { + std::vector<const TPortionInfo*> out; out.reserve(portions.size()); for (auto& [portion, portionInfo] : portions) { if (portionInfo.IsActive()) { @@ -463,7 +463,7 @@ bool TColumnEngineForLogs::LoadCounters(IDbWrapper& db) { return CountersTable->Load(db, callback); } -std::shared_ptr<TColumnEngineChanges> TColumnEngineForLogs::StartInsert(TVector<TInsertedData>&& dataToIndex) { +std::shared_ptr<TColumnEngineChanges> TColumnEngineForLogs::StartInsert(std::vector<TInsertedData>&& dataToIndex) { Y_VERIFY(dataToIndex.size()); auto changes = std::make_shared<TChanges>(TMark(MarkSchema), std::move(dataToIndex), Limits); @@ -712,11 +712,11 @@ std::shared_ptr<TColumnEngineChanges> TColumnEngineForLogs::StartTtl(const THash return changes; } -TVector<TVector<std::pair<TMark, ui64>>> TColumnEngineForLogs::EmptyGranuleTracks(ui64 pathId) const { +std::vector<std::vector<std::pair<TMark, ui64>>> TColumnEngineForLogs::EmptyGranuleTracks(ui64 pathId) const { Y_VERIFY(PathGranules.contains(pathId)); const auto& pathGranules = PathGranules.find(pathId)->second; - TVector<TVector<std::pair<TMark, ui64>>> emptyGranules; + std::vector<std::vector<std::pair<TMark, ui64>>> emptyGranules; ui64 emptyStart = 0; for (const auto& [mark, granule]: pathGranules) { Y_VERIFY(Granules.contains(granule)); @@ -861,7 +861,7 @@ bool TColumnEngineForLogs::ApplyChanges(IDbWrapper& db, std::shared_ptr<TColumnE } bool TColumnEngineForLogs::ApplyChanges(IDbWrapper& db, const TChanges& changes, const TSnapshot& snapshot, bool apply) { - const TVector<TPortionInfo>* switchedPortions = nullptr; + const std::vector<TPortionInfo>* switchedPortions = nullptr; if (changes.IsCompaction()) { Y_VERIFY(changes.CompactionInfo); switchedPortions = &changes.SwitchedPortions; @@ -1193,12 +1193,12 @@ bool TColumnEngineForLogs::CanInsert(const TChanges& changes, const TSnapshot& c return true; } -TMap<TSnapshot, TVector<ui64>> TColumnEngineForLogs::GetOrderedPortions(ui64 granule, const TSnapshot& snapshot) const { +TMap<TSnapshot, std::vector<ui64>> TColumnEngineForLogs::GetOrderedPortions(ui64 granule, const TSnapshot& snapshot) const { Y_VERIFY(Granules.contains(granule)); auto& spg = Granules.find(granule)->second; Y_VERIFY(spg); - TMap<TSnapshot, TVector<ui64>> out; + TMap<TSnapshot, std::vector<ui64>> out; for (const auto& [portion, portionInfo] : spg->Portions) { if (portionInfo.Empty()) { continue; @@ -1261,7 +1261,7 @@ std::shared_ptr<TSelectInfo> TColumnEngineForLogs::Select(ui64 pathId, TSnapshot auto& portions = spg->Portions; bool granuleHasDataForSnaphsot = false; - TMap<TSnapshot, TVector<ui64>> orderedPortions = GetOrderedPortions(granule, snapshot); + TMap<TSnapshot, std::vector<ui64>> orderedPortions = GetOrderedPortions(granule, snapshot); for (auto& [snap, vec] : orderedPortions) { for (auto& portion : vec) { auto& portionInfo = portions.find(portion)->second; @@ -1298,7 +1298,7 @@ std::shared_ptr<TSelectInfo> TColumnEngineForLogs::Select(ui64 pathId, TSnapshot return out; } -static bool NeedSplit(const TVector<const TPortionInfo*>& actual, const TCompactionLimits& limits, bool& inserted) { +static bool NeedSplit(const std::vector<const TPortionInfo*>& actual, const TCompactionLimits& limits, bool& inserted) { if (actual.size() < 2) { return false; } diff --git a/ydb/core/tx/columnshard/engines/column_engine_logs.h b/ydb/core/tx/columnshard/engines/column_engine_logs.h index 374b044e01..ff1a042488 100644 --- a/ydb/core/tx/columnshard/engines/column_engine_logs.h +++ b/ydb/core/tx/columnshard/engines/column_engine_logs.h @@ -61,7 +61,7 @@ public: }; TChanges(const TMark& defaultMark, - TVector<NOlap::TInsertedData>&& blobsToIndex, const TCompactionLimits& limits) + std::vector<NOlap::TInsertedData>&& blobsToIndex, const TCompactionLimits& limits) : TColumnEngineChanges(TColumnEngineChanges::INSERT) , DefaultMark(defaultMark) { @@ -206,7 +206,7 @@ public: public: bool Load(IDbWrapper& db, THashSet<TUnifiedBlobId>& lostBlobs, const THashSet<ui64>& pathsToDrop = {}) override; - std::shared_ptr<TColumnEngineChanges> StartInsert(TVector<TInsertedData>&& dataToIndex) override; + std::shared_ptr<TColumnEngineChanges> StartInsert(std::vector<TInsertedData>&& dataToIndex) override; std::shared_ptr<TColumnEngineChanges> StartCompaction(std::unique_ptr<TCompactionInfo>&& compactionInfo, const TSnapshot& outdatedSnapshot) override; std::shared_ptr<TColumnEngineChanges> StartCleanup(const TSnapshot& snapshot, THashSet<ui64>& pathsToDrop, @@ -297,11 +297,11 @@ private: EStatsUpdateType updateType) const; bool CanInsert(const TChanges& changes, const TSnapshot& commitSnap) const; - TMap<TSnapshot, TVector<ui64>> GetOrderedPortions(ui64 granule, const TSnapshot& snapshot = TSnapshot::Max()) const; + TMap<TSnapshot, std::vector<ui64>> GetOrderedPortions(ui64 granule, const TSnapshot& snapshot = TSnapshot::Max()) const; void UpdateOverloaded(const THashMap<ui64, std::shared_ptr<TGranuleMeta>>& granules); /// Return lists of adjacent empty granules for the path. - TVector<TVector<std::pair<TMark, ui64>>> EmptyGranuleTracks(const ui64 pathId) const; + std::vector<std::vector<std::pair<TMark, ui64>>> EmptyGranuleTracks(const ui64 pathId) const; }; } // namespace NKikimr::NOlap diff --git a/ydb/core/tx/columnshard/engines/index_info.cpp b/ydb/core/tx/columnshard/engines/index_info.cpp index 76fc2c9110..cbdafb694d 100644 --- a/ydb/core/tx/columnshard/engines/index_info.cpp +++ b/ydb/core/tx/columnshard/engines/index_info.cpp @@ -11,8 +11,8 @@ namespace NKikimr::NOlap { const TString TIndexInfo::STORE_INDEX_STATS_TABLE = TString("/") + NSysView::SysPathName + "/" + NSysView::StorePrimaryIndexStatsName; const TString TIndexInfo::TABLE_INDEX_STATS_TABLE = TString("/") + NSysView::SysPathName + "/" + NSysView::TablePrimaryIndexStatsName; -static TVector<TString> NamesOnly(const TVector<TNameTypeInfo>& columns) { - TVector<TString> out; +static std::vector<TString> NamesOnly(const std::vector<TNameTypeInfo>& columns) { + std::vector<TString> out; out.reserve(columns.size()); for (const auto& [name, _] : columns) { out.push_back(name); @@ -100,8 +100,8 @@ TString TIndexInfo::GetColumnName(ui32 id, bool required) const { } } -TVector<TString> TIndexInfo::GetColumnNames(const TVector<ui32>& ids) const { - TVector<TString> out; +std::vector<TString> TIndexInfo::GetColumnNames(const std::vector<ui32>& ids) const { + std::vector<TString> out; out.reserve(ids.size()); for (ui32 id : ids) { const auto ci = Columns.find(id); @@ -111,7 +111,7 @@ TVector<TString> TIndexInfo::GetColumnNames(const TVector<ui32>& ids) const { return out; } -TVector<TNameTypeInfo> TIndexInfo::GetColumns(const TVector<ui32>& ids) const { +std::vector<TNameTypeInfo> TIndexInfo::GetColumns(const std::vector<ui32>& ids) const { return NOlap::GetColumns(*this, ids); } @@ -181,7 +181,7 @@ std::shared_ptr<arrow::Schema> TIndexInfo::ArrowSchema() const { return Schema; } - TVector<ui32> ids; + std::vector<ui32> ids; ids.reserve(Columns.size()); for (const auto& [id, _] : Columns) { ids.push_back(id); @@ -215,7 +215,7 @@ std::shared_ptr<arrow::Schema> TIndexInfo::ArrowSchemaWithSpecials() const { std::shared_ptr<arrow::Schema> TIndexInfo::AddColumns( const std::shared_ptr<arrow::Schema>& src, - const TVector<TString>& columns) const + const std::vector<TString>& columns) const { std::shared_ptr<arrow::Schema> all = ArrowSchemaWithSpecials(); auto fields = src->fields(); @@ -233,12 +233,12 @@ std::shared_ptr<arrow::Schema> TIndexInfo::AddColumns( return std::make_shared<arrow::Schema>(std::move(fields)); } -std::shared_ptr<arrow::Schema> TIndexInfo::ArrowSchema(const TVector<ui32>& columnIds, bool withSpecials) const { +std::shared_ptr<arrow::Schema> TIndexInfo::ArrowSchema(const std::vector<ui32>& columnIds, bool withSpecials) const { return MakeArrowSchema(Columns, columnIds, withSpecials); } -TVector<ui32> TIndexInfo::GetColumnIds(const TVector<TString>& columnNames) const { - TVector<ui32> ids; +std::vector<ui32> TIndexInfo::GetColumnIds(const std::vector<TString>& columnNames) const { + std::vector<ui32> ids; ids.reserve(columnNames.size()); for (auto& name : columnNames) { auto columnId = GetColumnIdOptional(name); @@ -250,7 +250,7 @@ TVector<ui32> TIndexInfo::GetColumnIds(const TVector<TString>& columnNames) cons return ids; } -std::shared_ptr<arrow::Schema> TIndexInfo::ArrowSchema(const TVector<TString>& names) const { +std::shared_ptr<arrow::Schema> TIndexInfo::ArrowSchema(const std::vector<TString>& names) const { auto columnIds = GetColumnIds(names); if (columnIds.empty()) { return {}; @@ -326,7 +326,7 @@ bool TIndexInfo::AllowTtlOverColumn(const TString& name) const { return MinMaxIdxColumnsIds.contains(it->second); } -std::shared_ptr<arrow::Schema> MakeArrowSchema(const NTable::TScheme::TTableSchema::TColumns& columns, const TVector<ui32>& ids, bool withSpecials) { +std::shared_ptr<arrow::Schema> MakeArrowSchema(const NTable::TScheme::TTableSchema::TColumns& columns, const std::vector<ui32>& ids, bool withSpecials) { std::vector<std::shared_ptr<arrow::Field>> fields; fields.reserve(withSpecials ? ids.size() + 2 : ids.size()); @@ -346,12 +346,12 @@ std::shared_ptr<arrow::Schema> MakeArrowSchema(const NTable::TScheme::TTableSche std::string colName(column.Name.data(), column.Name.size()); fields.emplace_back(std::make_shared<arrow::Field>(colName, NArrow::GetArrowType(column.PType))); } - + return std::make_shared<arrow::Schema>(std::move(fields)); } -TVector<TNameTypeInfo> GetColumns(const NTable::TScheme::TTableSchema& tableSchema, const TVector<ui32>& ids) { - TVector<std::pair<TString, NScheme::TTypeInfo>> out; +std::vector<TNameTypeInfo> GetColumns(const NTable::TScheme::TTableSchema& tableSchema, const std::vector<ui32>& ids) { + std::vector<std::pair<TString, NScheme::TTypeInfo>> out; out.reserve(ids.size()); for (const ui32 id : ids) { const auto ci = tableSchema.Columns.find(id); diff --git a/ydb/core/tx/columnshard/engines/index_info.h b/ydb/core/tx/columnshard/engines/index_info.h index 0ee36f922e..5b745b4f39 100644 --- a/ydb/core/tx/columnshard/engines/index_info.h +++ b/ydb/core/tx/columnshard/engines/index_info.h @@ -74,13 +74,13 @@ public: TString GetColumnName(ui32 id, bool required = true) const; /// Returns names of columns defined by the specific ids. - TVector<TString> GetColumnNames(const TVector<ui32>& ids) const; + std::vector<TString> GetColumnNames(const std::vector<ui32>& ids) const; /// Returns info of columns defined by specific ids. - TVector<TNameTypeInfo> GetColumns(const TVector<ui32>& ids) const; + std::vector<TNameTypeInfo> GetColumns(const std::vector<ui32>& ids) const; /// Traditional Primary Key (includes uniqueness, search and sorting logic) - TVector<TNameTypeInfo> GetPrimaryKey() const { + std::vector<TNameTypeInfo> GetPrimaryKey() const { return GetColumns(KeyColumns); } @@ -112,15 +112,15 @@ public: Y_VERIFY(MinMaxIdxColumnsIds.contains(GetColumnId(ttlColumn))); } - TVector<ui32> GetColumnIds(const TVector<TString>& columnNames) const; + std::vector<ui32> GetColumnIds(const std::vector<TString>& columnNames) const; std::shared_ptr<arrow::Schema> ArrowSchema() const; std::shared_ptr<arrow::Schema> ArrowSchemaWithSpecials() const; std::shared_ptr<arrow::Schema> AddColumns(const std::shared_ptr<arrow::Schema>& schema, - const TVector<TString>& columns) const; + const std::vector<TString>& columns) const; - std::shared_ptr<arrow::Schema> ArrowSchema(const TVector<ui32>& columnIds, bool withSpecials = false) const; - std::shared_ptr<arrow::Schema> ArrowSchema(const TVector<TString>& columnNames) const; + std::shared_ptr<arrow::Schema> ArrowSchema(const std::vector<ui32>& columnIds, bool withSpecials = false) const; + std::shared_ptr<arrow::Schema> ArrowSchema(const std::vector<TString>& columnNames) const; std::shared_ptr<arrow::Field> ArrowColumnField(ui32 columnId) const; std::shared_ptr<arrow::RecordBatch> PrepareForInsert(const TString& data, const TString& metadata, TString& strError) const; @@ -168,9 +168,9 @@ private: TCompression DefaultCompression; }; -std::shared_ptr<arrow::Schema> MakeArrowSchema(const NTable::TScheme::TTableSchema::TColumns& columns, const TVector<ui32>& ids, bool withSpecials = false); +std::shared_ptr<arrow::Schema> MakeArrowSchema(const NTable::TScheme::TTableSchema::TColumns& columns, const std::vector<ui32>& ids, bool withSpecials = false); /// Extracts columns with the specific ids from the schema. -TVector<TNameTypeInfo> GetColumns(const NTable::TScheme::TTableSchema& tableSchema, const TVector<ui32>& ids); +std::vector<TNameTypeInfo> GetColumns(const NTable::TScheme::TTableSchema& tableSchema, const std::vector<ui32>& ids); } // namespace NKikimr::NOlap diff --git a/ydb/core/tx/columnshard/engines/index_logic_logs.cpp b/ydb/core/tx/columnshard/engines/index_logic_logs.cpp index 6522d25221..e4ed20b5cb 100644 --- a/ydb/core/tx/columnshard/engines/index_logic_logs.cpp +++ b/ydb/core/tx/columnshard/engines/index_logic_logs.cpp @@ -44,7 +44,7 @@ std::shared_ptr<arrow::RecordBatch> TIndexationLogic::AddSpecials(const std::sha bool TEvictionLogic::UpdateEvictedPortion(TPortionInfo& portionInfo, TPortionEvictionFeatures& evictFeatures, const THashMap<TBlobRange, TString>& srcBlobs, - TVector<TColumnRecord>& evictedRecords, TVector<TString>& newBlobs) const { + std::vector<TColumnRecord>& evictedRecords, std::vector<TString>& newBlobs) const { Y_VERIFY(portionInfo.TierName != evictFeatures.TargetTierName); auto* tiering = GetTieringMap().FindPtr(evictFeatures.PathId); @@ -89,14 +89,14 @@ bool TEvictionLogic::UpdateEvictedPortion(TPortionInfo& portionInfo, return true; } -TVector<TPortionInfo> TIndexLogicBase::MakeAppendedPortions(const ui64 pathId, +std::vector<TPortionInfo> TIndexLogicBase::MakeAppendedPortions(const ui64 pathId, const std::shared_ptr<arrow::RecordBatch> batch, const ui64 granule, const TSnapshot& minSnapshot, - TVector<TString>& blobs) const { + std::vector<TString>& blobs) const { Y_VERIFY(batch->num_rows()); const auto schema = IndexInfo.ArrowSchemaWithSpecials(); - TVector<TPortionInfo> out; + std::vector<TPortionInfo> out; TString tierName; TCompression compression = IndexInfo.GetDefaultCompression(); @@ -116,7 +116,7 @@ TVector<TPortionInfo> TIndexLogicBase::MakeAppendedPortions(const ui64 pathId, TPortionInfo portionInfo; portionInfo.Records.reserve(schema->num_fields()); - TVector<TString> portionBlobs; + std::vector<TString> portionBlobs; portionBlobs.reserve(schema->num_fields()); // Serialize portion's columns into blobs @@ -159,7 +159,7 @@ TVector<TPortionInfo> TIndexLogicBase::MakeAppendedPortions(const ui64 pathId, return out; } -std::vector<std::shared_ptr<arrow::RecordBatch>> TCompactionLogic::PortionsToBatches(const TVector<TPortionInfo>& portions, +std::vector<std::shared_ptr<arrow::RecordBatch>> TCompactionLogic::PortionsToBatches(const std::vector<TPortionInfo>& portions, const THashMap<TBlobRange, TString>& blobs, bool insertedOnly) const { // TODO: schema changes @@ -220,7 +220,7 @@ THashMap<ui64, std::shared_ptr<arrow::RecordBatch>> TIndexLogicBase::SliceIntoGr return out; } -TVector<TString> TIndexationLogic::Apply(std::shared_ptr<TColumnEngineChanges> indexChanges) const { +std::vector<TString> TIndexationLogic::Apply(std::shared_ptr<TColumnEngineChanges> indexChanges) const { auto changes = std::static_pointer_cast<TColumnEngineForLogs::TChanges>(indexChanges); Y_VERIFY(!changes->DataToIndex.empty()); Y_VERIFY(changes->AppendedPortions.empty()); @@ -254,7 +254,7 @@ TVector<TString> TIndexationLogic::Apply(std::shared_ptr<TColumnEngineChanges> i } Y_VERIFY(minSnapshot.Valid()); - TVector<TString> blobs; + std::vector<TString> blobs; for (auto& [pathId, batches] : pathBatches) { changes->AddPathIfNotExists(pathId); @@ -286,7 +286,7 @@ TVector<TString> TIndexationLogic::Apply(std::shared_ptr<TColumnEngineChanges> i } std::shared_ptr<arrow::RecordBatch> TCompactionLogic::CompactInOneGranule(ui64 granule, - const TVector<TPortionInfo>& portions, + const std::vector<TPortionInfo>& portions, const THashMap<TBlobRange, TString>& blobs) const { std::vector<std::shared_ptr<arrow::RecordBatch>> batches; batches.reserve(portions.size()); @@ -306,16 +306,16 @@ std::shared_ptr<arrow::RecordBatch> TCompactionLogic::CompactInOneGranule(ui64 g return sortedBatch; } -TVector<TString> TCompactionLogic::CompactInGranule(std::shared_ptr<TColumnEngineForLogs::TChanges> changes) const { +std::vector<TString> TCompactionLogic::CompactInGranule(std::shared_ptr<TColumnEngineForLogs::TChanges> changes) const { const ui64 pathId = changes->SrcGranule->PathId; - TVector<TString> blobs; + std::vector<TString> blobs; auto& switchedProtions = changes->SwitchedPortions; Y_VERIFY(switchedProtions.size()); ui64 granule = switchedProtions[0].Granule(); auto batch = CompactInOneGranule(granule, switchedProtions, changes->Blobs); - TVector<TPortionInfo> portions; + std::vector<TPortionInfo> portions; if (!changes->MergeBorders.Empty()) { Y_VERIFY(changes->MergeBorders.GetOrderedMarks().size() > 1); auto slices = changes->MergeBorders.SliceIntoGranules(batch, IndexInfo); @@ -342,12 +342,12 @@ TVector<TString> TCompactionLogic::CompactInGranule(std::shared_ptr<TColumnEngin return blobs; } -TVector<std::pair<TMark, std::shared_ptr<arrow::RecordBatch>>> +std::vector<std::pair<TMark, std::shared_ptr<arrow::RecordBatch>>> TCompactionLogic::SliceGranuleBatches(const TIndexInfo& indexInfo, const TColumnEngineForLogs::TChanges& changes, const std::vector<std::shared_ptr<arrow::RecordBatch>>& batches, const TMark& ts0) const { - TVector<std::pair<TMark, std::shared_ptr<arrow::RecordBatch>>> out; + std::vector<std::pair<TMark, std::shared_ptr<arrow::RecordBatch>>> out; // Extract unique effective keys and their counts i64 numRows = 0; @@ -391,7 +391,7 @@ TCompactionLogic::SliceGranuleBatches(const TIndexInfo& indexInfo, } // Make split borders from uniq keys - TVector<NArrow::TReplaceKey> borders; + std::vector<NArrow::TReplaceKey> borders; borders.reserve(numRows / rowsInGranule); { ui32 sumRows = 0; @@ -409,7 +409,7 @@ TCompactionLogic::SliceGranuleBatches(const TIndexInfo& indexInfo, } // Find offsets in source batches - TVector<TVector<int>> offsets(batches.size()); // vec[batch][border] = offset + std::vector<std::vector<int>> offsets(batches.size()); // vec[batch][border] = offset for (size_t i = 0; i < batches.size(); ++i) { const auto& batch = batches[i]; auto& batchOffsets = offsets[i]; @@ -506,9 +506,9 @@ TCompactionLogic::SliceGranuleBatches(const TIndexInfo& indexInfo, } ui64 TCompactionLogic::TryMovePortions(const TMark& ts0, - TVector<TPortionInfo>& portions, + std::vector<TPortionInfo>& portions, std::vector<std::pair<TMark, ui64>>& tsIds, - TVector<std::pair<TPortionInfo, ui64>>& toMove) const { + std::vector<std::pair<TPortionInfo, ui64>>& toMove) const { std::vector<TPortionInfo*> partitioned(portions.size()); // Split portions by putting the inserted portions in the original order // at the beginning of the buffer and the compacted portions at the end. @@ -565,17 +565,17 @@ ui64 TCompactionLogic::TryMovePortions(const TMark& ts0, return numRows; } -TVector<TString> TCompactionLogic::CompactSplitGranule(const std::shared_ptr<TColumnEngineForLogs::TChanges>& changes) const { +std::vector<TString> TCompactionLogic::CompactSplitGranule(const std::shared_ptr<TColumnEngineForLogs::TChanges>& changes) const { const ui64 pathId = changes->SrcGranule->PathId; const TMark ts0 = changes->SrcGranule->Mark; - TVector<TPortionInfo>& portions = changes->SwitchedPortions; + std::vector<TPortionInfo>& portions = changes->SwitchedPortions; std::vector<std::pair<TMark, ui64>> tsIds; ui64 movedRows = TryMovePortions(ts0, portions, tsIds, changes->PortionsToMove); const auto& srcBatches = PortionsToBatches(portions, changes->Blobs, movedRows != 0); Y_VERIFY(srcBatches.size() == portions.size()); - TVector<TString> blobs; + std::vector<TString> blobs; if (movedRows) { Y_VERIFY(changes->PortionsToMove.size() >= 2); @@ -594,7 +594,7 @@ TVector<TString> TCompactionLogic::CompactSplitGranule(const std::shared_ptr<TCo const ui32 rowsInGranule = numRows / numSplitInto; Y_VERIFY(rowsInGranule); - TVector<std::pair<TMark, ui64>> newTsIds; + std::vector<std::pair<TMark, ui64>> newTsIds; ui32 tmpGranule = 0; ui32 sumRows = 0; // Always insert mark of the source granule at the beginning. @@ -623,7 +623,7 @@ TVector<TString> TCompactionLogic::CompactSplitGranule(const std::shared_ptr<TCo // Slice inserted portions with granules' borders THashMap<ui64, std::vector<std::shared_ptr<arrow::RecordBatch>>> idBatches; - TVector<TPortionInfo*> toSwitch; + std::vector<TPortionInfo*> toSwitch; toSwitch.reserve(portions.size()); for (size_t i = 0; i < portions.size(); ++i) { auto& portion = portions[i]; @@ -651,7 +651,7 @@ TVector<TString> TCompactionLogic::CompactSplitGranule(const std::shared_ptr<TCo // Update switchedPortions if we have moves if (toSwitch.size() != portions.size()) { - TVector<TPortionInfo> tmp; + std::vector<TPortionInfo> tmp; tmp.reserve(toSwitch.size()); for (auto* portionInfo : toSwitch) { tmp.emplace_back(std::move(*portionInfo)); @@ -691,7 +691,7 @@ TVector<TString> TCompactionLogic::CompactSplitGranule(const std::shared_ptr<TCo return blobs; } -TVector<TString> TCompactionLogic::Apply(std::shared_ptr<TColumnEngineChanges> changes) const { +std::vector<TString> TCompactionLogic::Apply(std::shared_ptr<TColumnEngineChanges> changes) const { Y_VERIFY(changes); Y_VERIFY(changes->CompactionInfo); Y_VERIFY(changes->DataToIndex.empty()); // not used @@ -706,14 +706,14 @@ TVector<TString> TCompactionLogic::Apply(std::shared_ptr<TColumnEngineChanges> c return CompactSplitGranule(castedChanges); } -TVector<TString> TEvictionLogic::Apply(std::shared_ptr<TColumnEngineChanges> changes) const { +std::vector<TString> TEvictionLogic::Apply(std::shared_ptr<TColumnEngineChanges> changes) const { Y_VERIFY(changes); Y_VERIFY(!changes->Blobs.empty()); // src data Y_VERIFY(!changes->PortionsToEvict.empty()); // src meta Y_VERIFY(changes->EvictedRecords.empty()); // dst meta - TVector<TString> newBlobs; - TVector<std::pair<TPortionInfo, TPortionEvictionFeatures>> evicted; + std::vector<TString> newBlobs; + std::vector<std::pair<TPortionInfo, TPortionEvictionFeatures>> evicted; evicted.reserve(changes->PortionsToEvict.size()); for (auto& [portionInfo, evictFeatures] : changes->PortionsToEvict) { diff --git a/ydb/core/tx/columnshard/engines/index_logic_logs.h b/ydb/core/tx/columnshard/engines/index_logic_logs.h index 86158ca4cf..ecd2100dbe 100644 --- a/ydb/core/tx/columnshard/engines/index_logic_logs.h +++ b/ydb/core/tx/columnshard/engines/index_logic_logs.h @@ -25,18 +25,18 @@ public: virtual ~TIndexLogicBase() { } - virtual TVector<TString> Apply(std::shared_ptr<TColumnEngineChanges> indexChanges) const = 0; + virtual std::vector<TString> Apply(std::shared_ptr<TColumnEngineChanges> indexChanges) const = 0; static THashMap<ui64, std::shared_ptr<arrow::RecordBatch>> SliceIntoGranules(const std::shared_ptr<arrow::RecordBatch>& batch, const std::vector<std::pair<TMark, ui64>>& granules, const TIndexInfo& indexInfo); protected: - TVector<TPortionInfo> MakeAppendedPortions(const ui64 pathId, + std::vector<TPortionInfo> MakeAppendedPortions(const ui64 pathId, const std::shared_ptr<arrow::RecordBatch> batch, const ui64 granule, const TSnapshot& minSnapshot, - TVector<TString>& blobs) const; + std::vector<TString>& blobs) const; static std::shared_ptr<arrow::RecordBatch> GetEffectiveKey(const std::shared_ptr<arrow::RecordBatch>& batch, const TIndexInfo& indexInfo); @@ -53,7 +53,7 @@ class TIndexationLogic: public TIndexLogicBase { public: using TIndexLogicBase::TIndexLogicBase; - TVector<TString> Apply(std::shared_ptr<TColumnEngineChanges> indexChanges) const override; + std::vector<TString> Apply(std::shared_ptr<TColumnEngineChanges> indexChanges) const override; private: // Although source batches are ordered only by PK (sorting key) resulting pathBatches are ordered by extended key. @@ -66,16 +66,16 @@ class TCompactionLogic: public TIndexLogicBase { public: using TIndexLogicBase::TIndexLogicBase; - TVector<TString> Apply(std::shared_ptr<TColumnEngineChanges> indexChanges) const override; + std::vector<TString> Apply(std::shared_ptr<TColumnEngineChanges> indexChanges) const override; private: - TVector<TString> CompactSplitGranule(const std::shared_ptr<TColumnEngineForLogs::TChanges>& changes) const; - TVector<TString> CompactInGranule(std::shared_ptr<TColumnEngineForLogs::TChanges> changes) const; - std::shared_ptr<arrow::RecordBatch> CompactInOneGranule(ui64 granule, const TVector<TPortionInfo>& portions, const THashMap<TBlobRange, TString>& blobs) const; + std::vector<TString> CompactSplitGranule(const std::shared_ptr<TColumnEngineForLogs::TChanges>& changes) const; + std::vector<TString> CompactInGranule(std::shared_ptr<TColumnEngineForLogs::TChanges> changes) const; + std::shared_ptr<arrow::RecordBatch> CompactInOneGranule(ui64 granule, const std::vector<TPortionInfo>& portions, const THashMap<TBlobRange, TString>& blobs) const; /// @return vec({ts, batch}). ts0 <= ts1 <= ... <= tsN /// @note We use ts from PK for split but there could be lots PK with the same ts. - TVector<std::pair<TMark, std::shared_ptr<arrow::RecordBatch>>> + std::vector<std::pair<TMark, std::shared_ptr<arrow::RecordBatch>>> SliceGranuleBatches(const TIndexInfo& indexInfo, const TColumnEngineForLogs::TChanges& changes, const std::vector<std::shared_ptr<arrow::RecordBatch>>& batches, @@ -85,11 +85,11 @@ private: /// @param[in,out] tsIds unchanged or marks from compacted portions ordered by mark /// @param[in,out] toMove unchanged or compacted portions ordered by primary key ui64 TryMovePortions(const TMark& ts0, - TVector<TPortionInfo>& portions, + std::vector<TPortionInfo>& portions, std::vector<std::pair<TMark, ui64>>& tsIds, - TVector<std::pair<TPortionInfo, ui64>>& toMove) const; + std::vector<std::pair<TPortionInfo, ui64>>& toMove) const; - std::vector<std::shared_ptr<arrow::RecordBatch>> PortionsToBatches(const TVector<TPortionInfo>& portions, + std::vector<std::shared_ptr<arrow::RecordBatch>> PortionsToBatches(const std::vector<TPortionInfo>& portions, const THashMap<TBlobRange, TString>& blobs, bool insertedOnly = false) const; }; @@ -98,12 +98,12 @@ class TEvictionLogic: public TIndexLogicBase { public: using TIndexLogicBase::TIndexLogicBase; - TVector<TString> Apply(std::shared_ptr<TColumnEngineChanges> indexChanges) const override; + std::vector<TString> Apply(std::shared_ptr<TColumnEngineChanges> indexChanges) const override; private: bool UpdateEvictedPortion(TPortionInfo& portionInfo, TPortionEvictionFeatures& evictFeatures, const THashMap<TBlobRange, TString>& srcBlobs, - TVector<TColumnRecord>& evictedRecords, TVector<TString>& newBlobs) const; + std::vector<TColumnRecord>& evictedRecords, std::vector<TString>& newBlobs) const; }; } diff --git a/ydb/core/tx/columnshard/engines/indexed_read_data.cpp b/ydb/core/tx/columnshard/engines/indexed_read_data.cpp index 735d5ed7b2..ebc5a0fb4b 100644 --- a/ydb/core/tx/columnshard/engines/indexed_read_data.cpp +++ b/ydb/core/tx/columnshard/engines/indexed_read_data.cpp @@ -207,7 +207,7 @@ TIndexedReadData::MakeNotIndexedBatch(const std::shared_ptr<arrow::RecordBatch>& return preparedBatch; } -TVector<TPartialReadResult> TIndexedReadData::GetReadyResults(const int64_t maxRowsInBatch) { +std::vector<TPartialReadResult> TIndexedReadData::GetReadyResults(const int64_t maxRowsInBatch) { Y_VERIFY(SortReplaceDescription); auto& indexInfo = ReadMetadata->GetIndexInfo(); @@ -334,7 +334,7 @@ TIndexedReadData::MergeNotIndexed(std::vector<std::shared_ptr<arrow::RecordBatch } // TODO: better implementation -static void MergeTooSmallBatches(TVector<TPartialReadResult>& out) { +static void MergeTooSmallBatches(std::vector<TPartialReadResult>& out) { if (out.size() < 10) { return; } @@ -366,7 +366,7 @@ static void MergeTooSmallBatches(TVector<TPartialReadResult>& out) { } auto batch = NArrow::ToBatch(*res); - TVector<TPartialReadResult> merged; + std::vector<TPartialReadResult> merged; merged.emplace_back(TPartialReadResult{ .ResultBatch = std::move(batch), .LastReadKey = std::move(out.back().LastReadKey) @@ -374,14 +374,14 @@ static void MergeTooSmallBatches(TVector<TPartialReadResult>& out) { out.swap(merged); } -TVector<TPartialReadResult> +std::vector<TPartialReadResult> TIndexedReadData::MakeResult(std::vector<std::vector<std::shared_ptr<arrow::RecordBatch>>>&& granules, int64_t maxRowsInBatch) const { Y_VERIFY(ReadMetadata->IsSorted()); Y_VERIFY(SortReplaceDescription); auto& indexInfo = ReadMetadata->GetIndexInfo(); - TVector<TPartialReadResult> out; + std::vector<TPartialReadResult> out; bool isDesc = ReadMetadata->IsDescSorted(); diff --git a/ydb/core/tx/columnshard/engines/indexed_read_data.h b/ydb/core/tx/columnshard/engines/indexed_read_data.h index 1c155767de..1673d49808 100644 --- a/ydb/core/tx/columnshard/engines/indexed_read_data.h +++ b/ydb/core/tx/columnshard/engines/indexed_read_data.h @@ -63,7 +63,7 @@ public: } /// @returns batches and corresponding last keys in correct order (i.e. sorted by by PK) - TVector<TPartialReadResult> GetReadyResults(const int64_t maxRowsInBatch); + std::vector<TPartialReadResult> GetReadyResults(const int64_t maxRowsInBatch); void AddNotIndexed(ui32 batchNo, TString blob, const TSnapshot& snapshot) { auto batch = NArrow::DeserializeBatch(blob, ReadMetadata->GetBlobSchema(snapshot)); @@ -99,7 +99,7 @@ private: std::shared_ptr<arrow::RecordBatch> MergeNotIndexed( std::vector<std::shared_ptr<arrow::RecordBatch>>&& batches) const; std::vector<std::vector<std::shared_ptr<arrow::RecordBatch>>> ReadyToOut(); - TVector<TPartialReadResult> MakeResult( + std::vector<TPartialReadResult> MakeResult( std::vector<std::vector<std::shared_ptr<arrow::RecordBatch>>>&& granules, int64_t maxRowsInBatch) const; }; diff --git a/ydb/core/tx/columnshard/engines/portion_info.h b/ydb/core/tx/columnshard/engines/portion_info.h index 6f00a50dc1..c70e4d7dcf 100644 --- a/ydb/core/tx/columnshard/engines/portion_info.h +++ b/ydb/core/tx/columnshard/engines/portion_info.h @@ -96,7 +96,7 @@ struct TPortionMeta { struct TPortionInfo { static constexpr const ui32 BLOB_BYTES_LIMIT = 8 * 1024 * 1024; - TVector<TColumnRecord> Records; + std::vector<TColumnRecord> Records; TPortionMeta Meta; ui32 FirstPkColumn = 0; TString TierName; @@ -266,7 +266,7 @@ private: }; template <class TSelfGetter, class TItemGetter = TSelfGetter> - int CompareByColumnIdsImpl(const TPortionInfo& item, const TVector<ui32>& columnIds) const { + int CompareByColumnIdsImpl(const TPortionInfo& item, const std::vector<ui32>& columnIds) const { for (auto&& i : columnIds) { std::shared_ptr<arrow::Scalar> valueSelf = TSelfGetter::Get(*this, i); std::shared_ptr<arrow::Scalar> valueItem = TItemGetter::Get(item, i); @@ -292,7 +292,7 @@ public: return CompareMinByColumnIds(item, info.KeyColumns); } - int CompareMinByColumnIds(const TPortionInfo& item, const TVector<ui32>& columnIds) const { + int CompareMinByColumnIds(const TPortionInfo& item, const std::vector<ui32>& columnIds) const { return CompareByColumnIdsImpl<TMinGetter>(item, columnIds); } @@ -444,7 +444,7 @@ public: for (auto& [pos, orderedChunks] : columnChunks) { auto field = schema->field(pos); - TVector<TAssembleBlobInfo> blobs; + std::vector<TAssembleBlobInfo> blobs; blobs.reserve(orderedChunks.size()); ui32 expected = 0; for (auto& [chunk, blobRange] : orderedChunks) { diff --git a/ydb/core/tx/columnshard/engines/predicate/container.cpp b/ydb/core/tx/columnshard/engines/predicate/container.cpp index 85b8ed827d..f69b079687 100644 --- a/ydb/core/tx/columnshard/engines/predicate/container.cpp +++ b/ydb/core/tx/columnshard/engines/predicate/container.cpp @@ -75,12 +75,12 @@ int TPredicateContainer::MatchScalar(const ui32 columnIdx, const std::shared_ptr } } -const TVector<TString>& TPredicateContainer::GetColumnNames() const { +const std::vector<TString>& TPredicateContainer::GetColumnNames() const { if (!ColumnNames) { if (Object) { ColumnNames = Object->ColumnNames(); } else { - ColumnNames = TVector<TString>(); + ColumnNames = std::vector<TString>(); } } return *ColumnNames; diff --git a/ydb/core/tx/columnshard/engines/predicate/container.h b/ydb/core/tx/columnshard/engines/predicate/container.h index 46ef03665d..4dee27271f 100644 --- a/ydb/core/tx/columnshard/engines/predicate/container.h +++ b/ydb/core/tx/columnshard/engines/predicate/container.h @@ -12,7 +12,7 @@ class TPredicateContainer { private: std::shared_ptr<NOlap::TPredicate> Object; NArrow::ECompareType CompareType; - mutable std::optional<TVector<TString>> ColumnNames; + mutable std::optional<std::vector<TString>> ColumnNames; TPredicateContainer(std::shared_ptr<NOlap::TPredicate> object) : Object(object) @@ -41,7 +41,7 @@ public: int MatchScalar(const ui32 columnIdx, const std::shared_ptr<arrow::Scalar>& s) const; - const TVector<TString>& GetColumnNames() const; + const std::vector<TString>& GetColumnNames() const; bool IsForwardInterval() const; diff --git a/ydb/core/tx/columnshard/engines/predicate/predicate.cpp b/ydb/core/tx/columnshard/engines/predicate/predicate.cpp index 7dc6d9ff54..71c17cbde4 100644 --- a/ydb/core/tx/columnshard/engines/predicate/predicate.cpp +++ b/ydb/core/tx/columnshard/engines/predicate/predicate.cpp @@ -22,8 +22,8 @@ TPredicate::TPredicate(EOperation op, const TString& serializedBatch, const std: } } -TVector<TString> TPredicate::ColumnNames() const { - TVector<TString> out; +std::vector<TString> TPredicate::ColumnNames() const { + std::vector<TString> out; out.reserve(Batch->num_columns()); for (const auto& field : Batch->schema()->fields()) { out.emplace_back(field->name()); diff --git a/ydb/core/tx/columnshard/engines/predicate/predicate.h b/ydb/core/tx/columnshard/engines/predicate/predicate.h index 02450d9686..644e4db2b7 100644 --- a/ydb/core/tx/columnshard/engines/predicate/predicate.h +++ b/ydb/core/tx/columnshard/engines/predicate/predicate.h @@ -50,7 +50,7 @@ public: return Operation == EOperation::GreaterEqual || Operation == EOperation::LessEqual; } - TVector<TString> ColumnNames() const; + std::vector<TString> ColumnNames() const; std::string ToString() const { return Empty() ? "()" : Batch->schema()->ToString(); diff --git a/ydb/core/tx/columnshard/engines/reader/description.h b/ydb/core/tx/columnshard/engines/reader/description.h index f02c04cdc5..69f299e449 100644 --- a/ydb/core/tx/columnshard/engines/reader/description.h +++ b/ydb/core/tx/columnshard/engines/reader/description.h @@ -32,19 +32,19 @@ public: std::shared_ptr<arrow::RecordBatch> ProgramParameters; // TODO // List of columns - TVector<ui32> ColumnIds; - TVector<TString> ColumnNames; - + std::vector<ui32> ColumnIds; + std::vector<TString> ColumnNames; + std::shared_ptr<NSsa::TProgram> AddProgram(const IColumnResolver& columnResolver, const NKikimrSSA::TProgram& program); TReadDescription(const TSnapshot& snapshot, const bool isReverse) - : Snapshot(snapshot) + : Snapshot(snapshot) , PKRangesFilter(isReverse) { } const TSnapshot& GetSnapshot() const { return Snapshot; - } + } }; } diff --git a/ydb/core/tx/columnshard/engines/reader/read_metadata.cpp b/ydb/core/tx/columnshard/engines/reader/read_metadata.cpp index c396b88bbb..a984369d33 100644 --- a/ydb/core/tx/columnshard/engines/reader/read_metadata.cpp +++ b/ydb/core/tx/columnshard/engines/reader/read_metadata.cpp @@ -18,7 +18,7 @@ std::shared_ptr<NOlap::TSelectInfo> TDataStorageAccessor::Select(const NOlap::TR if (readDescription.ReadNothing) { return std::make_shared<NOlap::TSelectInfo>(); } - return Index->Select(readDescription.PathId, + return Index->Select(readDescription.PathId, readDescription.GetSnapshot(), columnIds, readDescription.PKRangesFilter); @@ -38,8 +38,8 @@ std::unique_ptr<NColumnShard::TScanIteratorBase> TReadMetadata::StartScan(NColum bool TReadMetadata::Init(const TReadDescription& readDescription, const TDataStorageAccessor& dataAccessor, std::string& error) { auto& indexInfo = ResultIndexSchema->GetIndexInfo(); - - TVector<ui32> resultColumnsIds; + + std::vector<ui32> resultColumnsIds; if (readDescription.ColumnIds.size()) { resultColumnsIds = readDescription.ColumnIds; } else if (readDescription.ColumnNames.size()) { @@ -78,7 +78,7 @@ bool TReadMetadata::Init(const TReadDescription& readDescription, const TDataSto requiredColumns.erase(indexInfo.GetColumnName(col)); } - TVector<ui32> auxiliaryColumns; + std::vector<ui32> auxiliaryColumns; auxiliaryColumns.reserve(requiredColumns.size()); for (auto& reqCol : requiredColumns) { auxiliaryColumns.push_back(indexInfo.GetColumnId(reqCol)); @@ -87,14 +87,14 @@ bool TReadMetadata::Init(const TReadDescription& readDescription, const TDataSto AllColumns.insert(AllColumns.end(), ResultColumnsIds.begin(), ResultColumnsIds.end()); AllColumns.insert(AllColumns.end(), auxiliaryColumns.begin(), auxiliaryColumns.end()); } - + CommittedBlobs = dataAccessor.GetCommitedBlobs(readDescription); for (auto& cmt : CommittedBlobs) { if (auto batch = dataAccessor.GetCachedBatch(cmt.GetBlobId())) { CommittedBatches.emplace(cmt.GetBlobId(), batch); } } - + auto loadSchema = GetLoadSchema(Snapshot); if (!loadSchema) { return false; @@ -177,11 +177,11 @@ std::set<ui32> TReadMetadata::GetUsedColumnIds() const { return result; } -TVector<std::pair<TString, NScheme::TTypeInfo>> TReadStatsMetadata::GetResultYqlSchema() const { +std::vector<std::pair<TString, NScheme::TTypeInfo>> TReadStatsMetadata::GetResultYqlSchema() const { return NOlap::GetColumns(NColumnShard::PrimaryIndexStatsSchema, ResultColumnIds); } -TVector<std::pair<TString, NScheme::TTypeInfo>> TReadStatsMetadata::GetKeyYqlSchema() const { +std::vector<std::pair<TString, NScheme::TTypeInfo>> TReadStatsMetadata::GetKeyYqlSchema() const { return NOlap::GetColumns(NColumnShard::PrimaryIndexStatsSchema, NColumnShard::PrimaryIndexStatsSchema.KeyColumns); } @@ -229,7 +229,7 @@ NIndexedReader::IOrderPolicy::TPtr TReadMetadata::BuildSortingPolicy() const { } } } - + return std::make_shared<NIndexedReader::TPKSortingWithLimit>(this->shared_from_this()); } else { return std::make_shared<NIndexedReader::TAnySorting>(this->shared_from_this()); diff --git a/ydb/core/tx/columnshard/engines/reader/read_metadata.h b/ydb/core/tx/columnshard/engines/reader/read_metadata.h index 843bb4486c..56b3878581 100644 --- a/ydb/core/tx/columnshard/engines/reader/read_metadata.h +++ b/ydb/core/tx/columnshard/engines/reader/read_metadata.h @@ -113,8 +113,8 @@ public: bool IsDescSorted() const { return Sorting == ESorting::DESC; } bool IsSorted() const { return IsAscSorted() || IsDescSorted(); } - virtual TVector<std::pair<TString, NScheme::TTypeInfo>> GetResultYqlSchema() const = 0; - virtual TVector<std::pair<TString, NScheme::TTypeInfo>> GetKeyYqlSchema() const = 0; + virtual std::vector<std::pair<TString, NScheme::TTypeInfo>> GetResultYqlSchema() const = 0; + virtual std::vector<std::pair<TString, NScheme::TTypeInfo>> GetKeyYqlSchema() const = 0; virtual std::unique_ptr<NColumnShard::TScanIteratorBase> StartScan(NColumnShard::TDataTasksProcessorContainer tasksProcessor, const NColumnShard::TScanCounters& scanCounters) const = 0; // TODO: can this only be done for base class? @@ -131,8 +131,8 @@ private: TVersionedIndex IndexVersions; TSnapshot Snapshot; std::shared_ptr<ISnapshotSchema> ResultIndexSchema; - TVector<ui32> AllColumns; - TVector<ui32> ResultColumnsIds; + std::vector<ui32> AllColumns; + std::vector<ui32> ResultColumnsIds; public: using TConstPtr = std::shared_ptr<const TReadMetadata>; @@ -144,7 +144,7 @@ public: const TSnapshot& GetSnapshot() const { return Snapshot; } - + std::shared_ptr<NIndexedReader::IOrderPolicy> BuildSortingPolicy() const; TReadMetadata(const TVersionedIndex& info, const TSnapshot& snapshot, const ESorting sorting) @@ -161,7 +161,7 @@ public: ui64 GetSchemaColumnsCount() const { return AllColumns.size(); } - + std::shared_ptr<arrow::Schema> GetLoadSchema(const TSnapshot& version) const { const auto& indexInfo = IndexVersions.GetSchema(version)->GetIndexInfo(); return indexInfo.ArrowSchema(AllColumns, true); @@ -179,7 +179,7 @@ public: if (version && version < Snapshot) { return IndexVersions.GetSchema(*version)->GetIndexInfo(); } - return ResultIndexSchema->GetIndexInfo(); + return ResultIndexSchema->GetIndexInfo(); } std::vector<std::string> GetColumnsOrder() const { @@ -208,11 +208,11 @@ public: return ResultIndexSchema->GetIndexInfo().GetReplaceKey(); } - TVector<TNameTypeInfo> GetResultYqlSchema() const override { + std::vector<TNameTypeInfo> GetResultYqlSchema() const override { auto& indexInfo = ResultIndexSchema->GetIndexInfo(); auto resultSchema = GetResultSchema(); Y_VERIFY(resultSchema); - TVector<NTable::TTag> columnIds; + std::vector<NTable::TTag> columnIds; columnIds.reserve(resultSchema->num_fields()); for (const auto& field: resultSchema->fields()) { TString name = TStringBuilder() << field->name(); @@ -221,7 +221,7 @@ public: return indexInfo.GetColumns(columnIds); } - TVector<TNameTypeInfo> GetKeyYqlSchema() const override { + std::vector<TNameTypeInfo> GetKeyYqlSchema() const override { return ResultIndexSchema->GetIndexInfo().GetPrimaryKey(); } @@ -263,8 +263,8 @@ public: using TConstPtr = std::shared_ptr<const TReadStatsMetadata>; const ui64 TabletId; - TVector<ui32> ReadColumnIds; - TVector<ui32> ResultColumnIds; + std::vector<ui32> ReadColumnIds; + std::vector<ui32> ResultColumnIds; THashMap<ui64, std::shared_ptr<NOlap::TColumnEngineStats>> IndexStats; explicit TReadStatsMetadata(ui64 tabletId, const ESorting sorting) @@ -272,9 +272,9 @@ public: , TabletId(tabletId) {} - TVector<std::pair<TString, NScheme::TTypeInfo>> GetResultYqlSchema() const override; + std::vector<std::pair<TString, NScheme::TTypeInfo>> GetResultYqlSchema() const override; - TVector<std::pair<TString, NScheme::TTypeInfo>> GetKeyYqlSchema() const override; + std::vector<std::pair<TString, NScheme::TTypeInfo>> GetKeyYqlSchema() const override; std::unique_ptr<NColumnShard::TScanIteratorBase> StartScan(NColumnShard::TDataTasksProcessorContainer tasksProcessor, const NColumnShard::TScanCounters& scanCounters) const override; }; diff --git a/ydb/core/tx/columnshard/engines/ut_logs_engine.cpp b/ydb/core/tx/columnshard/engines/ut_logs_engine.cpp index 0043fb5709..36e22f2699 100644 --- a/ydb/core/tx/columnshard/engines/ut_logs_engine.cpp +++ b/ydb/core/tx/columnshard/engines/ut_logs_engine.cpp @@ -16,8 +16,8 @@ namespace { class TTestDbWrapper : public IDbWrapper { public: struct TIndex { - THashMap<ui64, TVector<TGranuleRecord>> Granules; // pathId -> granule - THashMap<ui64, TVector<TColumnRecord>> Columns; // granule -> columns + THashMap<ui64, std::vector<TGranuleRecord>> Granules; // pathId -> granule + THashMap<ui64, std::vector<TColumnRecord>> Columns; // granule -> columns THashMap<ui32, ui64> Counters; }; @@ -74,7 +74,7 @@ public: void EraseGranule(ui32 index, const IColumnEngine&, const TGranuleRecord& row) override { auto& pathGranules = Indices[index].Granules[row.PathId]; - TVector<TGranuleRecord> filtered; + std::vector<TGranuleRecord> filtered; filtered.reserve(pathGranules.size()); for (const TGranuleRecord& rec : pathGranules) { if (rec.Granule != row.Granule) { @@ -113,7 +113,7 @@ public: void EraseColumn(ui32 index, const TColumnRecord& row) override { auto& columns = Indices[index].Columns[row.Granule]; - TVector<TColumnRecord> filtered; + std::vector<TColumnRecord> filtered; filtered.reserve(columns.size()); for (auto& rec : columns) { if (rec != row) { @@ -153,7 +153,7 @@ private: THashMap<ui32, TIndex> Indices; }; -static const TVector<std::pair<TString, TTypeInfo>> testColumns = { +static const std::vector<std::pair<TString, TTypeInfo>> testColumns = { // PK {"timestamp", TTypeInfo(NTypeIds::Timestamp) }, {"resource_type", TTypeInfo(NTypeIds::Utf8) }, @@ -163,15 +163,15 @@ static const TVector<std::pair<TString, TTypeInfo>> testColumns = { {"message", TTypeInfo(NTypeIds::Utf8) } }; -static const TVector<std::pair<TString, TTypeInfo>> testKey = { +static const std::vector<std::pair<TString, TTypeInfo>> testKey = { {"timestamp", TTypeInfo(NTypeIds::Timestamp) }, {"resource_type", TTypeInfo(NTypeIds::Utf8) }, {"resource_id", TTypeInfo(NTypeIds::Utf8) }, {"uid", TTypeInfo(NTypeIds::Utf8) } }; -TIndexInfo TestTableInfo(const TVector<std::pair<TString, TTypeInfo>>& ydbSchema = testColumns, - const TVector<std::pair<TString, TTypeInfo>>& key = testKey) { +TIndexInfo TestTableInfo(const std::vector<std::pair<TString, TTypeInfo>>& ydbSchema = testColumns, + const std::vector<std::pair<TString, TTypeInfo>>& key = testKey) { TIndexInfo indexInfo("", 0); for (ui32 i = 0; i < ydbSchema.size(); ++i) { @@ -250,7 +250,7 @@ TString MakeTestBlob(i64 start = 0, i64 end = 100) { return NArrow::SerializeBatchNoCompression(batch); } -void AddIdsToBlobs(const TVector<TString>& srcBlobs, TVector<TPortionInfo>& portions, +void AddIdsToBlobs(const std::vector<TString>& srcBlobs, std::vector<TPortionInfo>& portions, THashMap<TBlobRange, TString>& blobs, ui32& step) { ui32 pos = 0; for (auto& portion : portions) { @@ -272,7 +272,7 @@ TCompactionLimits TestLimits() { } bool Insert(TColumnEngineForLogs& engine, TTestDbWrapper& db, TSnapshot snap, - TVector<TInsertedData>&& dataToIndex, THashMap<TBlobRange, TString>& blobs, ui32& step) { + std::vector<TInsertedData>&& dataToIndex, THashMap<TBlobRange, TString>& blobs, ui32& step) { std::shared_ptr<TColumnEngineChanges> changes = engine.StartInsert(std::move(dataToIndex)); if (!changes) { return false; @@ -281,7 +281,7 @@ bool Insert(TColumnEngineForLogs& engine, TTestDbWrapper& db, TSnapshot snap, changes->Blobs.insert(blobs.begin(), blobs.end()); TIndexationLogic logic(engine.GetIndexInfo()); - TVector<TString> newBlobs = logic.Apply(changes); + std::vector<TString> newBlobs = logic.Apply(changes); UNIT_ASSERT_VALUES_EQUAL(changes->AppendedPortions.size(), 1); UNIT_ASSERT_VALUES_EQUAL(newBlobs.size(), testColumns.size() + 2); // add 2 columns: planStep, txId @@ -290,7 +290,7 @@ bool Insert(TColumnEngineForLogs& engine, TTestDbWrapper& db, TSnapshot snap, } bool Insert(const TIndexInfo& tableInfo, TTestDbWrapper& db, TSnapshot snap, - TVector<TInsertedData>&& dataToIndex, THashMap<TBlobRange, TString>& blobs, ui32& step) { + std::vector<TInsertedData>&& dataToIndex, THashMap<TBlobRange, TString>& blobs, ui32& step) { TColumnEngineForLogs engine(0, TestLimits()); engine.UpdateDefaultSchema(snap, TIndexInfo(tableInfo)); THashSet<TUnifiedBlobId> lostBlobs; @@ -317,7 +317,7 @@ bool Compact(TColumnEngineForLogs& engine, TTestDbWrapper& db, TSnapshot snap, T changes->SetBlobs(std::move(blobs)); TCompactionLogic logic(engine.GetIndexInfo()); - TVector<TString> newBlobs = logic.Apply(changes); + std::vector<TString> newBlobs = logic.Apply(changes); UNIT_ASSERT_VALUES_EQUAL(changes->AppendedPortions.size(), expected.NewPortions); AddIdsToBlobs(newBlobs, changes->AppendedPortions, changes->Blobs, step); @@ -374,22 +374,22 @@ std::shared_ptr<TPredicate> MakeStrPredicate(const std::string& key, NArrow::EOp Y_UNIT_TEST_SUITE(TColumnEngineTestLogs) { - void WriteLoadRead(const TVector<std::pair<TString, TTypeInfo>>& ydbSchema, - const TVector<std::pair<TString, TTypeInfo>>& key) { + void WriteLoadRead(const std::vector<std::pair<TString, TTypeInfo>>& ydbSchema, + const std::vector<std::pair<TString, TTypeInfo>>& key) { TTestDbWrapper db; TIndexInfo tableInfo = TestTableInfo(ydbSchema, key); - TVector<ui64> paths = {1, 2}; + std::vector<ui64> paths = {1, 2}; TString testBlob = MakeTestBlob(); - TVector<TBlobRange> blobRanges; + std::vector<TBlobRange> blobRanges; blobRanges.push_back(MakeBlobRange(1, testBlob.size())); blobRanges.push_back(MakeBlobRange(2, testBlob.size())); // PlanStep, TxId, PathId, DedupId, BlobId, Data, [Metadata] TInstant writeTime = TInstant::Now(); - TVector<TInsertedData> dataToIndex = { + std::vector<TInsertedData> dataToIndex = { {1, 2, paths[0], "", blobRanges[0].BlobId, "", writeTime}, {2, 1, paths[0], "", blobRanges[1].BlobId, "", writeTime} }; @@ -458,7 +458,7 @@ Y_UNIT_TEST_SUITE(TColumnEngineTestLogs) { } Y_UNIT_TEST(IndexWriteLoadReadStrPK) { - TVector<std::pair<TString, TTypeInfo>> key = { + std::vector<std::pair<TString, TTypeInfo>> key = { {"resource_type", TTypeInfo(NTypeIds::Utf8) }, {"resource_id", TTypeInfo(NTypeIds::Utf8) }, {"uid", TTypeInfo(NTypeIds::Utf8) }, @@ -468,8 +468,8 @@ Y_UNIT_TEST_SUITE(TColumnEngineTestLogs) { WriteLoadRead(testColumns, key); } - void ReadWithPredicates(const TVector<std::pair<TString, TTypeInfo>>& ydbSchema, - const TVector<std::pair<TString, TTypeInfo>>& key) { + void ReadWithPredicates(const std::vector<std::pair<TString, TTypeInfo>>& ydbSchema, + const std::vector<std::pair<TString, TTypeInfo>>& key) { TTestDbWrapper db; TIndexInfo tableInfo = TestTableInfo(ydbSchema, key); @@ -488,7 +488,7 @@ Y_UNIT_TEST_SUITE(TColumnEngineTestLogs) { blobs[blobRange] = testBlob; // PlanStep, TxId, PathId, DedupId, BlobId, Data, [Metadata] - TVector<TInsertedData> dataToIndex; + std::vector<TInsertedData> dataToIndex; dataToIndex.push_back( TInsertedData{planStep, txId, pathId, "", blobRange.BlobId, "", TInstant::Now()}); @@ -559,7 +559,7 @@ Y_UNIT_TEST_SUITE(TColumnEngineTestLogs) { } Y_UNIT_TEST(IndexReadWithPredicatesStrPK) { - TVector<std::pair<TString, TTypeInfo>> key = { + std::vector<std::pair<TString, TTypeInfo>> key = { {"resource_type", TTypeInfo(NTypeIds::Utf8) }, {"resource_id", TTypeInfo(NTypeIds::Utf8) }, {"uid", TTypeInfo(NTypeIds::Utf8) }, @@ -594,7 +594,7 @@ Y_UNIT_TEST_SUITE(TColumnEngineTestLogs) { blobs[blobRange] = testBlob; // PlanStep, TxId, PathId, DedupId, BlobId, Data, [Metadata] - TVector<TInsertedData> dataToIndex; + std::vector<TInsertedData> dataToIndex; dataToIndex.push_back( TInsertedData{planStep, txId, pathId, "", blobRange.BlobId, "", TInstant::Now()}); @@ -632,7 +632,7 @@ Y_UNIT_TEST_SUITE(TColumnEngineTestLogs) { blobs[blobRange] = testBlob; // PlanStep, TxId, PathId, DedupId, BlobId, Data, [Metadata] - TVector<TInsertedData> dataToIndex; + std::vector<TInsertedData> dataToIndex; dataToIndex.push_back( TInsertedData{planStep, txId, pathId, "", blobRange.BlobId, "", TInstant::Now()}); @@ -669,7 +669,7 @@ Y_UNIT_TEST_SUITE(TColumnEngineTestLogs) { blobs[blobRange] = testBlob; // PlanStep, TxId, PathId, DedupId, BlobId, Data, [Metadata] - TVector<TInsertedData> dataToIndex; + std::vector<TInsertedData> dataToIndex; dataToIndex.push_back( TInsertedData{planStep, txId, pathId, "", blobRange.BlobId, "", TInstant::Now()}); 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 a940c5f549..0e3381317f 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 @@ -303,8 +303,8 @@ bool CheckColumns(const TString& blob, const NKikimrTxColumnShard::TMetadata& me } struct TestTableDescription { - TVector<std::pair<TString, TTypeInfo>> Schema = TTestSchema::YdbSchema(); - TVector<std::pair<TString, TTypeInfo>> Pk = TTestSchema::YdbPkSchema(); + std::vector<std::pair<TString, TTypeInfo>> Schema = TTestSchema::YdbSchema(); + std::vector<std::pair<TString, TTypeInfo>> Pk = TTestSchema::YdbPkSchema(); bool InStore = true; }; @@ -327,8 +327,8 @@ void SetupSchema(TTestBasicRuntime& runtime, TActorId& sender, ui64 pathId, } void SetupSchema(TTestBasicRuntime& runtime, TActorId& sender, ui64 pathId, - const TVector<std::pair<TString, TTypeInfo>>& schema = TTestSchema::YdbSchema(), - const TVector<std::pair<TString, TTypeInfo>>& pk = TTestSchema::YdbPkSchema(), + const std::vector<std::pair<TString, TTypeInfo>>& schema = TTestSchema::YdbSchema(), + const std::vector<std::pair<TString, TTypeInfo>>& pk = TTestSchema::YdbPkSchema(), TString codec = "none") { TestTableDescription table{schema, pk, true}; SetupSchema(runtime, sender, pathId, table, codec); @@ -385,12 +385,12 @@ void TestWrite(const TestTableDescription& table) { SetupSchema(runtime, sender, tableId, table); - const TVector<std::pair<TString, TTypeInfo>>& ydbSchema = table.Schema; + const std::vector<std::pair<TString, TTypeInfo>>& ydbSchema = table.Schema; bool ok = WriteData(runtime, sender, metaShard, writeId, tableId, MakeTestBlob({0, 100}, ydbSchema)); UNIT_ASSERT(ok); - TVector<std::pair<TString, TTypeInfo>> schema = ydbSchema; + std::vector<std::pair<TString, TTypeInfo>> schema = ydbSchema; // no data @@ -581,8 +581,8 @@ void TestWriteReadLongTxDup() { auto data = resRead.GetData(); auto meta = resRead.GetMeta(); UNIT_ASSERT(CheckColumns(data, meta, TTestSchema::ExtractNames(ydbSchema), numRows)); - UNIT_ASSERT(DataHas(TVector<TString>{data}, meta.GetSchema(), portion, true)); - UNIT_ASSERT(DataHasOnly(TVector<TString>{data}, meta.GetSchema(), portion)); + UNIT_ASSERT(DataHas(std::vector<TString>{data}, meta.GetSchema(), portion, true)); + UNIT_ASSERT(DataHasOnly(std::vector<TString>{data}, meta.GetSchema(), portion)); } } @@ -609,7 +609,7 @@ void TestWriteRead(bool reboots, const TestTableDescription& table = {}, TString }; auto proposeCommit = [&](TTestBasicRuntime& runtime, TActorId& sender, ui64 metaShard, ui64 txId, - const TVector<ui64>& writeIds) { + const std::vector<ui64>& writeIds) { ProposeCommit(runtime, sender, metaShard, txId, writeIds); if (reboots) { RebootTablet(runtime, TTestTxConfig::TxTablet0, sender); @@ -631,14 +631,14 @@ void TestWriteRead(bool reboots, const TestTableDescription& table = {}, TString SetupSchema(runtime, sender, tableId, table, codec); - const TVector<std::pair<TString, TTypeInfo>>& ydbSchema = table.Schema; - const TVector<std::pair<TString, TTypeInfo>>& testYdbPk = table.Pk; + const std::vector<std::pair<TString, TTypeInfo>>& ydbSchema = table.Schema; + const std::vector<std::pair<TString, TTypeInfo>>& testYdbPk = table.Pk; // ----xx // -----xx.. // xx---- // -xxxxx - TVector<std::pair<ui64, ui64>> portion = { + std::vector<std::pair<ui64, ui64>> portion = { {200, 300}, {250, 250 + 80 * 1000}, // committed -> index {0, 100}, @@ -704,7 +704,7 @@ void TestWriteRead(bool reboots, const TestTableDescription& table = {}, TString UNIT_ASSERT(resRead3.GetData().size() > 0); UNIT_ASSERT(CheckColumns(resRead3.GetData(), resRead3.GetMeta(), TTestSchema::ExtractNames(ydbSchema))); { - TVector<TString> readData; + std::vector<TString> readData; readData.push_back(resRead3.GetData()); auto& schema = resRead3.GetMeta().GetSchema(); UNIT_ASSERT(DataHas(readData, schema, portion[0])); @@ -804,7 +804,7 @@ void TestWriteRead(bool reboots, const TestTableDescription& table = {}, TString UNIT_ASSERT(resRead7.GetData().size() > 0); { - TVector<TString> readData; + std::vector<TString> readData; readData.push_back(resRead7.GetData()); auto& schema = resRead7.GetMeta().GetSchema(); UNIT_ASSERT(DataHas(readData, schema, portion[0])); // checks no checks REPLACE (indexed vs indexed) @@ -829,7 +829,7 @@ void TestWriteRead(bool reboots, const TestTableDescription& table = {}, TString UNIT_ASSERT(resRead8.GetData().size() > 0); { - TVector<TString> readData; + std::vector<TString> readData; readData.push_back(resRead8.GetData()); auto& schema = resRead8.GetMeta().GetSchema(); UNIT_ASSERT(DataHas(readData, schema, portion[0], true)); // checks REPLACE (indexed vs indexed) @@ -1015,8 +1015,8 @@ void TestWriteRead(bool reboots, const TestTableDescription& table = {}, TString } void TestCompactionInGranuleImpl(bool reboots, - const TVector<std::pair<TString, TTypeInfo>>& ydbSchema, - const TVector<std::pair<TString, TTypeInfo>>& ydbPk) { + const std::vector<std::pair<TString, TTypeInfo>>& ydbSchema, + const std::vector<std::pair<TString, TTypeInfo>>& ydbPk) { TTestBasicRuntime runtime; TTester::Setup(runtime); @@ -1037,7 +1037,7 @@ void TestCompactionInGranuleImpl(bool reboots, }; auto proposeCommit = [&](TTestBasicRuntime& runtime, TActorId& sender, ui64 metaShard, ui64 txId, - const TVector<ui64>& writeIds) { + const std::vector<ui64>& writeIds) { ProposeCommit(runtime, sender, metaShard, txId, writeIds); if (reboots) { RebootTablet(runtime, TTestTxConfig::TxTablet0, sender); @@ -1077,7 +1077,7 @@ void TestCompactionInGranuleImpl(bool reboots, // inserts triggered by count ui32 pos = triggerPortionSize; for (ui32 i = 0; i < 1; ++i, ++planStep, ++txId) { - TVector<ui64> ids; + std::vector<ui64> ids; ids.reserve(numWrites); for (ui32 w = 0; w < numWrites; ++w, ++writeId, pos += portionSize) { std::pair<ui64, ui64> portion = {pos, pos + portionSize}; @@ -1425,7 +1425,7 @@ void TestReadWithProgram(const TestTableDescription& table = {}) auto& meta = resRead.GetMeta(); auto& schema = meta.GetSchema(); - TVector<TString> readData; + std::vector<TString> readData; readData.push_back(resRead.GetData()); switch (i) { @@ -1618,7 +1618,7 @@ struct TReadAggregateResult { std::vector<int64_t> Counts = {100}; }; -void TestReadAggregate(const TVector<std::pair<TString, TTypeInfo>>& ydbSchema, const TString& testDataBlob, +void TestReadAggregate(const std::vector<std::pair<TString, TTypeInfo>>& ydbSchema, const TString& testDataBlob, bool addProjection, const std::vector<ui32>& aggKeys = {}, const TReadAggregateResult& expectedResult = {}, const TReadAggregateResult& expectedFiltered = {1, {1}, {1}, {1}}) { @@ -1999,9 +1999,9 @@ Y_UNIT_TEST_SUITE(TColumnShardTestReadWrite) { TTestBasicRuntime& Runtime; const ui64 PlanStep; const ui64 TxId; - const TVector<std::pair<TString, TTypeInfo>> YdbPk; + const std::vector<std::pair<TString, TTypeInfo>> YdbPk; public: - TTabletReadPredicateTest(TTestBasicRuntime& runtime, const ui64 planStep, const ui64 txId, const TVector<std::pair<TString, TTypeInfo>>& ydbPk) + TTabletReadPredicateTest(TTestBasicRuntime& runtime, const ui64 planStep, const ui64 txId, const std::vector<std::pair<TString, TTypeInfo>>& ydbPk) : Runtime(runtime) , PlanStep(planStep) , TxId(txId) @@ -2131,8 +2131,8 @@ Y_UNIT_TEST_SUITE(TColumnShardTestReadWrite) { } }; - void TestCompactionSplitGranule(const TVector<std::pair<TString, TTypeInfo>>& ydbSchema, - const TVector<std::pair<TString, TTypeInfo>>& ydbPk) { + void TestCompactionSplitGranule(const std::vector<std::pair<TString, TTypeInfo>>& ydbSchema, + const std::vector<std::pair<TString, TTypeInfo>>& ydbPk) { TTestBasicRuntime runtime; TTester::Setup(runtime); diff --git a/ydb/core/tx/columnshard/ut_schema/ut_columnshard_schema.cpp b/ydb/core/tx/columnshard/ut_schema/ut_columnshard_schema.cpp index 5414091dec..f317e268cc 100644 --- a/ydb/core/tx/columnshard/ut_schema/ut_columnshard_schema.cpp +++ b/ydb/core/tx/columnshard/ut_schema/ut_columnshard_schema.cpp @@ -25,8 +25,8 @@ enum class EInitialEviction { namespace { -static const TVector<std::pair<TString, TTypeInfo>> testYdbSchema = TTestSchema::YdbSchema(); -static const TVector<std::pair<TString, TTypeInfo>> testYdbPk = TTestSchema::YdbPkSchema(); +static const std::vector<std::pair<TString, TTypeInfo>> testYdbSchema = TTestSchema::YdbSchema(); +static const std::vector<std::pair<TString, TTypeInfo>> testYdbPk = TTestSchema::YdbPkSchema(); std::shared_ptr<arrow::RecordBatch> UpdateColumn(std::shared_ptr<arrow::RecordBatch> batch, TString columnName, i64 seconds) { std::string name(columnName.c_str(), columnName.size()); @@ -66,7 +66,7 @@ std::shared_ptr<arrow::RecordBatch> UpdateColumn(std::shared_ptr<arrow::RecordBa return arrow::RecordBatch::Make(schema, batch->num_rows(), columns); } -bool TriggerTTL(TTestBasicRuntime& runtime, TActorId& sender, NOlap::TSnapshot snap, const TVector<ui64>& pathIds, +bool TriggerTTL(TTestBasicRuntime& runtime, TActorId& sender, NOlap::TSnapshot snap, const std::vector<ui64>& pathIds, ui64 tsSeconds, const TString& ttlColumnName) { TString txBody = TTestSchema::TtlTxBody(pathIds, ttlColumnName, tsSeconds); auto event = std::make_unique<TEvColumnShard::TEvProposeTransaction>( @@ -130,7 +130,7 @@ bool CheckSame(const TString& blob, const TString& strSchema, ui32 expectedSize, } std::vector<TString> MakeData(const std::vector<ui64>& ts, ui32 portionSize, ui32 overlapSize, const TString& ttlColumnName, - const TVector<std::pair<TString, TTypeInfo>>& ydbSchema = testYdbSchema) { + const std::vector<std::pair<TString, TTypeInfo>>& ydbSchema = testYdbSchema) { UNIT_ASSERT(ts.size() == 2); TString data1 = MakeTestBlob({0, portionSize}, ydbSchema); @@ -189,7 +189,7 @@ static constexpr ui32 PORTION_ROWS = 80 * 1000; // ts[0] = 1600000000; // date -u --date='@1600000000' Sun Sep 13 12:26:40 UTC 2020 // ts[1] = 1620000000; // date -u --date='@1620000000' Mon May 3 00:00:00 UTC 2021 void TestTtl(bool reboots, bool internal, TTestSchema::TTableSpecials spec = {}, - const TVector<std::pair<TString, TTypeInfo>>& ydbSchema = testYdbSchema) + const std::vector<std::pair<TString, TTypeInfo>>& ydbSchema = testYdbSchema) { std::vector<ui64> ts = {1600000000, 1620000000}; @@ -965,7 +965,7 @@ Y_UNIT_TEST_SUITE(TColumnShardTestSchema) { Y_UNIT_TEST(CreateTable) { ui64 tableId = 1; - TVector<TTypeId> intTypes = { + std::vector<TTypeId> intTypes = { NTypeIds::Timestamp, NTypeIds::Int8, NTypeIds::Int16, @@ -992,7 +992,7 @@ Y_UNIT_TEST_SUITE(TColumnShardTestSchema) { } // TODO: support float types - TVector<TTypeId> floatTypes = { + std::vector<TTypeId> floatTypes = { NTypeIds::Float, NTypeIds::Double }; @@ -1005,7 +1005,7 @@ Y_UNIT_TEST_SUITE(TColumnShardTestSchema) { UNIT_ASSERT(!ok); } - TVector<TTypeId> strTypes = { + std::vector<TTypeId> strTypes = { NTypeIds::String, NTypeIds::Utf8 }; @@ -1018,7 +1018,7 @@ Y_UNIT_TEST_SUITE(TColumnShardTestSchema) { UNIT_ASSERT(ok); } - TVector<TTypeId> xsonTypes = { + std::vector<TTypeId> xsonTypes = { NTypeIds::Yson, NTypeIds::Json, NTypeIds::JsonDocument diff --git a/ydb/core/tx/columnshard/write_actor.cpp b/ydb/core/tx/columnshard/write_actor.cpp index 122603b480..4b3e675d21 100644 --- a/ydb/core/tx/columnshard/write_actor.cpp +++ b/ydb/core/tx/columnshard/write_actor.cpp @@ -191,13 +191,13 @@ public: auto indexChanges = WriteIndexEv->IndexChanges; LOG_S_DEBUG("Writing " << WriteIndexEv->Blobs.size() << " blobs at " << TabletId); - const TVector<TString>& blobs = WriteIndexEv->Blobs; + const std::vector<TString>& blobs = WriteIndexEv->Blobs; Y_VERIFY(blobs.size() > 0); size_t blobsPos = 0; // Send accumulated data and update records with the blob Id auto fnFlushAcummultedBlob = [this, &ctx] (TString& accumulatedBlob, NOlap::TPortionInfo& portionInfo, - TVector<std::pair<size_t, TString>>& recordsInBlob) + std::vector<std::pair<size_t, TString>>& recordsInBlob) { Y_VERIFY(accumulatedBlob.size() > 0); Y_VERIFY(recordsInBlob.size() > 0); @@ -222,7 +222,7 @@ public: }; TString accumulatedBlob; - TVector<std::pair<size_t, TString>> recordsInBlob; + std::vector<std::pair<size_t, TString>> recordsInBlob; Y_VERIFY(indexChanges->AppendedPortions.empty() || indexChanges->PortionsToEvict.empty()); size_t portionsToWrite = indexChanges->AppendedPortions.size() + indexChanges->PortionsToEvict.size(); diff --git a/ydb/core/tx/datashard/datashard__read_iterator.cpp b/ydb/core/tx/datashard/datashard__read_iterator.cpp index 7b214a03ca..b2bf66b126 100644 --- a/ydb/core/tx/datashard/datashard__read_iterator.cpp +++ b/ydb/core/tx/datashard/datashard__read_iterator.cpp @@ -20,7 +20,7 @@ constexpr ui64 MinRowsPerCheck = 1000; class TRowCountBlockBuilder : public IBlockBuilder { public: - bool Start(const TVector<std::pair<TString, NScheme::TTypeInfo>>&, ui64, ui64, TString&) override + bool Start(const std::vector<std::pair<TString, NScheme::TTypeInfo>>&, ui64, ui64, TString&) override { return true; } @@ -47,7 +47,7 @@ private: class TCellBlockBuilder : public IBlockBuilder { public: bool Start( - const TVector<std::pair<TString, NScheme::TTypeInfo>>& columns, + const std::vector<std::pair<TString, NScheme::TTypeInfo>>& columns, ui64 maxRowsInBlock, ui64 maxBytesInBlock, TString& err) override @@ -76,7 +76,7 @@ public: TVector<TOwnedCellVec> FlushBatch() { return std::move(Rows); } private: - TVector<std::pair<TString, NScheme::TTypeInfo>> Columns; + std::vector<std::pair<TString, NScheme::TTypeInfo>> Columns; TVector<TOwnedCellVec> Rows; ui64 BytesCount = 0; diff --git a/ydb/core/tx/datashard/datashard_ut_snapshot.cpp b/ydb/core/tx/datashard/datashard_ut_snapshot.cpp index 2c0a5c42cf..1256b07ec7 100644 --- a/ydb/core/tx/datashard/datashard_ut_snapshot.cpp +++ b/ydb/core/tx/datashard/datashard_ut_snapshot.cpp @@ -23,7 +23,7 @@ namespace { class TTextFormatBuilder : public IBlockBuilder { public: bool Start( - const TVector<std::pair<TString, NScheme::TTypeInfo>>& columns, + const std::vector<std::pair<TString, NScheme::TTypeInfo>>& columns, ui64 maxRowsInBlock, ui64 maxBytesInBlock, TString& err) override @@ -65,7 +65,7 @@ namespace { } private: - TVector<std::pair<TString, NScheme::TTypeInfo>> Columns; + std::vector<std::pair<TString, NScheme::TTypeInfo>> Columns; TString Buffer; }; @@ -2631,7 +2631,7 @@ Y_UNIT_TEST_SUITE(DataShardSnapshots) { UPSERT INTO `/Root/table-1` (key, value) VALUES (0, 0); UPSERT INTO `/Root/table-2` (key, value) VALUES (0, 0); )"), commitSender, commitSenderTxId, true)); - + runtime.SimulateSleep(TDuration::Seconds(1)); UNIT_ASSERT(!observer.BlockedReadSets.empty()); observer.InjectClearTasks = false; |