be/src/exprs/lambda_function/lambda_execution_context.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 <glog/logging.h>

#include <ranges>
#include <set>
#include <string>
#include <utility>
#include <vector>

namespace doris {

class LambdaExecutionContext {
public:
    struct Binding {
        std::string name;
        int column_position = -1;
    };

    struct Frame {
        bool bind_by_name = true;
        bool parent_bindings_visible = true;
        std::vector<Binding> argument_bindings;
    };

    struct ResolveResult {
        bool searched_named_scope = false;
        bool found = false;
        int column_position = -1;
    };

    class FrameGuard {
    public:
        FrameGuard(LambdaExecutionContext& context, Frame frame) : _context(&context) {
            _context->push_frame(std::move(frame));
        }

        FrameGuard(FrameGuard&& other) = delete;
        FrameGuard& operator=(FrameGuard&& other) = delete;
        FrameGuard(const FrameGuard&) = delete;
        FrameGuard& operator=(const FrameGuard&) = delete;

        ~FrameGuard() { release(); }

    private:
        void release() {
            if (_context != nullptr) {
                _context->pop_frame();
                _context = nullptr;
            }
        }

        LambdaExecutionContext* _context;
    };

    void push_frame(Frame frame) { _frames.push_back(std::move(frame)); }

    void pop_frame() {
        DCHECK(!_frames.empty());
        _frames.pop_back();
    }

    ResolveResult resolve_column_position(const std::string& name) const {
        ResolveResult result;
        for (const auto& frame : std::ranges::reverse_view(_frames)) {
            result.searched_named_scope |= frame.bind_by_name;
            for (const auto& argument_binding :
                 std::ranges::reverse_view(frame.argument_bindings)) {
                if (argument_binding.name == name) {
                    result.found = true;
                    result.column_position = argument_binding.column_position;
                    return result;
                }
            }
            if (!frame.parent_bindings_visible) {
                break;
            }
        }
        return result;
    }

    void collect_visible_binding_column_positions(std::set<int>& column_positions) const {
        for (const auto& _frame : std::ranges::reverse_view(_frames)) {
            for (const auto& binding : _frame.argument_bindings) {
                if (binding.column_position >= 0) {
                    column_positions.insert(binding.column_position);
                }
            }
            if (!_frame.parent_bindings_visible) {
                break;
            }
        }
    }

private:
    std::vector<Frame> _frames;
};

} // namespace doris