be/src/cloud/cloud_cumulative_compaction.h

// Licensed to the Apache Software Foundation (ASF) under one
// or more contributor license agreements.  See the NOTICE file
// distributed with this work for additional information
// regarding copyright ownership.  The ASF licenses this file
// to you under the Apache License, Version 2.0 (the
// "License"); you may not use this file except in compliance
// with the License.  You may obtain a copy of the License at
//
//   http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing,
// software distributed under the License is distributed on an
// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
// KIND, either express or implied.  See the License for the
// specific language governing permissions and limitations
// under the License.

#pragma once

#include <limits>
#include <memory>
#include <optional>
#include <string_view>
#include <vector>

#include "cloud/cloud_storage_engine.h"
#include "cloud/cloud_tablet.h"
#include "storage/compaction/compaction.h"
#include "storage/compaction_task_tracker.h"
#include "storage/tablet/tablet_fwd.h"

namespace doris {

class RowsetMeta;

namespace cloud {

struct SegmentGroupMergeRange {
    int64_t segment_start;
    int64_t segment_end;
    int64_t merge_way_num;
};

bool is_single_rowset_compaction_candidate(const RowsetSharedPtr& rowset);

bool should_use_single_rowset_grouped_compaction(const std::vector<RowsetSharedPtr>& input_rowsets,
                                                 const TabletSchema& tablet_schema,
                                                 std::string_view compaction_policy);

std::vector<SegmentGroupMergeRange> build_segment_group_merge_ranges(const RowsetMeta& rowset_meta,
                                                                     int64_t segment_group_size);

} // namespace cloud

class CloudCumulativeCompaction : public CloudCompactionMixin {
public:
    CloudCumulativeCompaction(CloudStorageEngine& engine, CloudTabletSPtr tablet);

    ~CloudCumulativeCompaction() override;

    Status prepare_compact() override;
    Status execute_compact() override;
    Status request_global_lock();

    std::optional<CompactionProfileType> profile_type() const override {
        return CompactionProfileType::CUMULATIVE;
    }
    int64_t input_segments_num_value() const override { return _input_segments; }

    void do_lease();

    int64_t get_input_rowsets_bytes() const { return _input_rowsets_total_size; }
    int64_t get_input_num_rows() const { return _input_row_num; }

private:
    Status advance_cumulative_point_before_pick(int64_t min_conflict_version);

    Status pick_rowsets_to_compact();

    Status prepare_merge_input_rowsets(MergeInputRowsetsResult* result) override;

    Status do_merge_input_rowsets(const std::vector<RowsetReaderSharedPtr>& input_rs_readers,
                                  MergeInputRowsetsResult* result) override;

    void update_output_rowset_after_build(const MergeInputRowsetsResult& result) override;

    bool should_calculate_new_cumulative_point(int64_t input_cumulative_point) const;

    std::string_view compaction_name() const override { return "CloudCumulativeCompaction"; }

protected:
    Status modify_rowsets() override;

private:
    Status garbage_collection() override;

    void update_cumulative_point(int64_t input_cumulative_point, int64_t output_cumulative_point);

    ReaderType compaction_type() const override { return ReaderType::READER_CUMULATIVE_COMPACTION; }

    int64_t _input_segments = 0;
    // A task must use one execution mode even if the dynamic config changes while it is running.
    const bool _enable_parallel_cumu_compaction;
    int64_t _min_conflict_version = std::numeric_limits<int64_t>::max();
    int64_t _max_conflict_version = 0;
    // Snapshot values when pick input rowsets
    int64_t _base_compaction_cnt = 0;
    int64_t _cumulative_compaction_cnt = 0;
    int64_t _picked_cumulative_point = 0;
    Version _last_delete_version {-1, -1};
    std::optional<int64_t> _single_rowset_compaction_segment_group_size;
};

} // namespace doris