be/src/storage/key/row_key_encoder.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 <cstddef>
#include <cstdint>
#include <string>
#include <vector>

namespace doris {

class IOlapColumnDataAccessor;
class KeyCoder;
class TabletColumn;
class TabletSchema;

// Encodes rows into the sortable binary key format shared by the short key
// index and the primary key index. Each column is encoded as a one byte
// marker (KeyConsts) followed by the KeyCoder encoded value, a null column
// is encoded as KEY_NULL_FIRST_MARKER without value bytes.
class RowKeyEncoder {
public:
    RowKeyEncoder(const TabletSchema& schema, bool mow);

    // Encode the sort key columns at `pos` with full length.
    std::string full_encode(const std::vector<IOlapColumnDataAccessor*>& key_columns,
                            size_t pos) const;

    // For a mow table with cluster keys, encode the primary key columns at
    // `pos` with full length, producing the key stored in and probed against
    // the primary key index.
    std::string full_encode_primary_keys(const std::vector<IOlapColumnDataAccessor*>& key_columns,
                                         size_t pos) const;

    // Encode the short key columns at `pos`, each column truncated to its
    // index length.
    std::string encode_short_keys(const std::vector<IOlapColumnDataAccessor*>& key_columns,
                                  size_t pos) const;

    // Append the encoded sequence column at `pos` to `encoded_keys`. A null
    // sequence value is encoded as the minimal value of the column length so
    // that it sorts first in the primary key index.
    void append_seq_suffix(std::string* encoded_keys, const IOlapColumnDataAccessor* seq_column,
                           size_t pos) const;

    // Append the encoded row id to `encoded_keys`, only used by mow tables
    // with cluster keys.
    void append_rowid_suffix(std::string* encoded_keys, uint32_t rowid) const;

    size_t num_sort_key_columns() const { return _sort_key_coders.size(); }

private:
    static std::string _full_encode(const std::vector<const KeyCoder*>& key_coders,
                                    const std::vector<IOlapColumnDataAccessor*>& key_columns,
                                    size_t pos);

    void _init_mow(const TabletSchema& schema);
    void _init_non_mow(const TabletSchema& schema);
    void _add_default_sort_key_columns(const TabletSchema& schema);
    void _add_sort_key_column(const TabletColumn& column);

    // The sort-key view: whatever the segment sorts by. Cluster key columns
    // for mow tables with cluster keys, primary key columns otherwise. Used by
    // full_encode() and encode_short_keys().
    std::vector<const KeyCoder*> _sort_key_coders;
    std::vector<uint16_t> _sort_key_index_size;
    // The separate primary-key view used by mow tables with cluster keys. The
    // segment sorts by cluster key columns while its primary key index remains
    // based on the schema key columns.
    std::vector<const KeyCoder*> _primary_key_coders;
    // Mow-only suffix coders for the primary key index.
    const KeyCoder* _seq_coder = nullptr;
    const KeyCoder* _rowid_coder = nullptr;
    size_t _seq_col_length = 0;
    size_t _num_short_key_columns = 0;
};

} // namespace doris