be/src/storage/segment/page_handle.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 "runtime/exec_env.h"
#include "storage/cache/page_cache.h"
#include "util/slice.h" // for Slice

namespace doris {

// After disable page cache, sometimes we need to know the percentage of data pages in query memory.
inline bvar::Adder<int64_t> g_page_no_cache_mem_bytes("doris_page_no_cache_mem_bytes");

namespace segment_v2 {

// When a column page is read into memory, we use this to store it.
// A page's data may be in cache, or may not in cache. We use this
// class to unify these two cases.
// If client use this struct to wrap data not in cache, this class
// will free data's memory when it is destroyed.
class PageHandle {
public:
    PageHandle() : _is_data_owner(false) {}

    // This class will take the ownership of input data's memory. It will
    // free it when deconstructs.
    PageHandle(DataPage* data) : _is_data_owner(true), _data(data) {
        g_page_no_cache_mem_bytes << _data->capacity();
    }

    // This class will take the content of cache data, and will make input
    // cache_data to a invalid cache handle.
    PageHandle(PageCacheHandle cache_data)
            : _is_data_owner(false), _cache_data(std::move(cache_data)) {}

    // Move constructor
    PageHandle(PageHandle&& other) noexcept : _cache_data(std::move(other._cache_data)) {
        // we can use std::exchange if we switch c++14 on
        std::swap(_is_data_owner, other._is_data_owner);
        std::swap(_data, other._data);
    }

    PageHandle& operator=(PageHandle&& other) noexcept {
        std::swap(_is_data_owner, other._is_data_owner);
        std::swap(_data, other._data);
        _cache_data = std::move(other._cache_data);
        return *this;
    }

    ~PageHandle() {
        if (_is_data_owner) {
            g_page_no_cache_mem_bytes << -_data->capacity();
            delete _data;
        } else {
            DCHECK(_data == nullptr);
        }
    }

    // the return slice contains uncompressed page body, page footer, and footer size
    Slice data() const {
        if (_is_data_owner) {
            return Slice(_data->data(), _data->size());
        } else {
            return _cache_data.data();
        }
    }

private:
    // when this is true, it means this struct own data and _data is valid.
    // otherwise _cache_data is valid, and data is belong to cache.
    bool _is_data_owner = false;
    DataPage* _data = nullptr;
    PageCacheHandle _cache_data;

    // Don't allow copy and assign
    DISALLOW_COPY_AND_ASSIGN(PageHandle);
};

} // namespace segment_v2
} // namespace doris