be/src/format_v2/column_mapper_nested.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 <span>
#include <string>
#include <vector>

#include "common/status.h"
#include "core/data_type/data_type.h"
#include "core/field.h"
#include "exprs/vexpr_fwd.h"
#include "exprs/vliteral.h"
#include "exprs/vslot_ref.h"
#include "format_v2/column_mapper.h"
#include "format_v2/file_reader.h"

namespace doris::format {

struct StructChildSelector {
    bool by_name = true;
    std::string name;
    size_t ordinal = 0;
};

struct NestedStructPath {
    GlobalIndex root_global_index;
    std::vector<StructChildSelector> selectors;
};

struct ResolvedNestedStructPath {
    LocalColumnIndex file_projection;
    std::vector<std::string> file_child_names;
    std::vector<DataTypePtr> file_child_types;
};

// A split-local literal produced by slot-literal predicate localization. This wrapper keeps the
// original table literal so a cloned conjunct can be localized again for another split.
class SplitLocalFileLiteral final : public VLiteral {
public:
    SplitLocalFileLiteral(const DataTypePtr& file_type, const Field& file_field,
                          DataTypePtr original_type, Field original_field);

    const DataTypePtr& original_type() const { return _original_type; }
    const Field& original_field() const { return _original_field; }
    Status clone_node(VExprSPtr* cloned_expr) const override {
        DORIS_CHECK(cloned_expr != nullptr);
        Field file_field;
        get_column_ptr()->get(0, file_field);
        *cloned_expr = std::make_shared<SplitLocalFileLiteral>(_data_type, file_field,
                                                               _original_type, _original_field);
        return Status::OK();
    }

private:
    DataTypePtr _original_type;
    Field _original_field;
};

GlobalIndex slot_ref_global_index(const VSlotRef& slot_ref);
bool is_struct_element_expr(const VExprSPtr& expr);
Field literal_field(const VExprSPtr& literal_expr);

bool resolve_nested_struct_path_for_file(const NestedStructPath& path,
                                         const std::vector<ColumnMapping>& mappings,
                                         ResolvedNestedStructPath* resolved,
                                         bool require_scan_projection = false);

bool resolve_nested_struct_expr_for_file(const VExprSPtr& expr,
                                         const std::vector<ColumnMapping>& mappings,
                                         ResolvedNestedStructPath* resolved);

void collect_nested_struct_paths(const VExprSPtr& expr, std::vector<NestedStructPath>* paths);

std::vector<const ColumnMapping*> present_child_mappings_in_file_order(
        const std::vector<ColumnMapping>& child_mappings);

Status build_file_child_projection_from_schema(const std::vector<ColumnDefinition>& children,
                                               std::span<const StructChildSelector> selectors,
                                               LocalColumnIndex* projection);

} // namespace doris::format