be/src/storage/predicate_collector.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 <memory>
#include <set>
#include <string>
#include <unordered_map>

#include "common/status.h"
#include "exprs/vexpr_fwd.h"
#include "gen_cpp/Exprs_types.h"
#include "runtime/runtime_state.h"
#include "storage/index/inverted/query/query_info.h"

namespace doris {

class VSlotRef;
class TabletIndex;
class TabletSchema;
using TabletSchemaSPtr = std::shared_ptr<TabletSchema>;

struct TermInfoComparer {
    bool operator()(const segment_v2::TermInfo& lhs, const segment_v2::TermInfo& rhs) const {
        return lhs.term < rhs.term;
    }
};

struct CollectInfo {
    std::set<segment_v2::TermInfo, TermInfoComparer> term_infos;
    std::shared_ptr<const TabletIndex> owned_index_meta;
    const TabletIndex* index_meta = nullptr;
};
using CollectInfoMap = std::unordered_map<std::wstring, CollectInfo>;

class PredicateCollector {
public:
    virtual ~PredicateCollector() = default;

    virtual Status collect(RuntimeState* state, const TabletSchemaSPtr& tablet_schema,
                           const VExprSPtr& expr, CollectInfoMap* collect_infos) = 0;

protected:
    VSlotRef* find_slot_ref(const VExprSPtr& expr) const;
    std::string build_field_name(int32_t col_unique_id, const std::string& suffix_path) const;
};

class MatchPredicateCollector : public PredicateCollector {
public:
    Status collect(RuntimeState* state, const TabletSchemaSPtr& tablet_schema,
                   const VExprSPtr& expr, CollectInfoMap* collect_infos) override;
};

class SearchPredicateCollector : public PredicateCollector {
public:
    Status collect(RuntimeState* state, const TabletSchemaSPtr& tablet_schema,
                   const VExprSPtr& expr, CollectInfoMap* collect_infos) override;

private:
    enum class ClauseTypeCategory { NON_TOKENIZED, TOKENIZED, COMPOUND };

    Status collect_from_clause(const TSearchClause& clause, RuntimeState* state,
                               const TabletSchemaSPtr& tablet_schema,
                               CollectInfoMap* collect_infos);
    Status collect_from_leaf(const TSearchClause& clause, RuntimeState* state,
                             const TabletSchemaSPtr& tablet_schema, CollectInfoMap* collect_infos);
    bool is_score_query_type(const std::string& clause_type) const;
    ClauseTypeCategory get_clause_type_category(const std::string& clause_type) const;
};

using PredicateCollectorPtr = std::unique_ptr<PredicateCollector>;

} // namespace doris