// 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 <functional>

#include <memory>

#include <mutex>

#include <shared_mutex>

#include <string>

#include "common/status.h"

#include "exec/olap_common.h"

#include "olap/shared_predicate.h"

#include "olap/tablet_schema.h"

#include "runtime/define_primitive_type.h"

#include "runtime/primitive_type.h"

#include "util/binary_cast.hpp"

#include "vec/common/arena.h"

#include "vec/core/field.h"

#include "vec/core/types.h"

#include "vec/runtime/vdatetime_value.h"

namespace doris {

class ColumnPredicate;

namespace vectorized {

class RuntimePredicate {

public:

    RuntimePredicate() = default;

    Status init(PrimitiveType type, bool nulls_first, bool is_asc, const std::string& col_name);

    bool inited() const {

        std::shared_lock<std::shared_mutex> rlock(_rwlock);

        return _inited;

    }

    bool need_update() const {

        std::shared_lock<std::shared_mutex> rlock(_rwlock);

        return _inited && _tablet_schema;

    }

    Status set_tablet_schema(TabletSchemaSPtr tablet_schema) {

        std::unique_lock<std::shared_mutex> wlock(_rwlock);

        // when sort node and scan node are not in the same backend, predicate will not be initialized

        if (_tablet_schema || !_inited) {

            return Status::OK();

        }

        RETURN_IF_ERROR(tablet_schema->have_column(_col_name));

        _tablet_schema = tablet_schema;

        _predicate = SharedPredicate::create_shared(

                _tablet_schema->field_index(_tablet_schema->column(_col_name).unique_id()));

        return Status::OK();

    }

    std::shared_ptr<ColumnPredicate> get_predicate() {

        std::shared_lock<std::shared_mutex> rlock(_rwlock);

        return _predicate;

    }

    Status update(const Field& value);

private:

    mutable std::shared_mutex _rwlock;

    Field _orderby_extrem {Field::Types::Null};

    std::shared_ptr<ColumnPredicate> _predicate;

    TabletSchemaSPtr _tablet_schema = nullptr;

    Arena _predicate_arena;

    std::function<std::string(const Field&)> _get_value_fn;

    bool _nulls_first = true;

    bool _is_asc;

    std::function<ColumnPredicate*(const TabletColumn&, int, const std::string&, bool,

                                   vectorized::Arena*)>

            _pred_constructor;

    bool _inited = false;

    std::string _col_name;

    template <PrimitiveType type>

    static std::string get_normal_value(const Field& field) {

        using ValueType = typename PrimitiveTypeTraits<type>::CppType;

        return cast_to_string<type, ValueType>(field.get<ValueType>(), 0);

    }

Unexecuted instantiation: _ZN5doris10vectorized16RuntimePredicate16get_normal_valueILNS_13PrimitiveTypeE2EEENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERKNS0_5FieldE

Unexecuted instantiation: _ZN5doris10vectorized16RuntimePredicate16get_normal_valueILNS_13PrimitiveTypeE3EEENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERKNS0_5FieldE

Unexecuted instantiation: _ZN5doris10vectorized16RuntimePredicate16get_normal_valueILNS_13PrimitiveTypeE4EEENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERKNS0_5FieldE

Unexecuted instantiation: _ZN5doris10vectorized16RuntimePredicate16get_normal_valueILNS_13PrimitiveTypeE5EEENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERKNS0_5FieldE

Unexecuted instantiation: _ZN5doris10vectorized16RuntimePredicate16get_normal_valueILNS_13PrimitiveTypeE6EEENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERKNS0_5FieldE

Unexecuted instantiation: _ZN5doris10vectorized16RuntimePredicate16get_normal_valueILNS_13PrimitiveTypeE7EEENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERKNS0_5FieldE

Unexecuted instantiation: _ZN5doris10vectorized16RuntimePredicate16get_normal_valueILNS_13PrimitiveTypeE25EEENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERKNS0_5FieldE

Unexecuted instantiation: _ZN5doris10vectorized16RuntimePredicate16get_normal_valueILNS_13PrimitiveTypeE26EEENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERKNS0_5FieldE

Unexecuted instantiation: _ZN5doris10vectorized16RuntimePredicate16get_normal_valueILNS_13PrimitiveTypeE36EEENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERKNS0_5FieldE

Unexecuted instantiation: _ZN5doris10vectorized16RuntimePredicate16get_normal_valueILNS_13PrimitiveTypeE37EEENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERKNS0_5FieldE

    static std::string get_date_value(const Field& field) {

        using ValueType = typename PrimitiveTypeTraits<TYPE_DATE>::CppType;

        ValueType value;

        Int64 v = field.get<Int64>();

        auto* p = (VecDateTimeValue*)&v;

        value.from_olap_date(p->to_olap_date());

        value.cast_to_date();

        return cast_to_string<TYPE_DATE, ValueType>(value, 0);

    }

    static std::string get_datetime_value(const Field& field) {

        using ValueType = typename PrimitiveTypeTraits<TYPE_DATETIME>::CppType;

        ValueType value;

        Int64 v = field.get<Int64>();

        auto* p = (VecDateTimeValue*)&v;

        value.from_olap_datetime(p->to_olap_datetime());

        value.to_datetime();

        return cast_to_string<TYPE_DATETIME, ValueType>(value, 0);

    }

    static std::string get_decimalv2_value(const Field& field) {

        // can NOT use PrimitiveTypeTraits<TYPE_DECIMALV2>::CppType since

        //   it is DecimalV2Value and Decimal128V2 can not convert to it implicitly

        using ValueType = Decimal128V2::NativeType;

        auto v = field.get<DecimalField<Decimal128V2>>();

        // use TYPE_DECIMAL128I instead of TYPE_DECIMALV2 since v.get_scale()

        //   is always 9 for DECIMALV2

        return cast_to_string<TYPE_DECIMAL128I, ValueType>(v.get_value(), v.get_scale());

    }

    template <PrimitiveType type>

    static std::string get_decimal_value(const Field& field) {

        using ValueType = typename PrimitiveTypeTraits<type>::CppType;

        auto v = field.get<DecimalField<ValueType>>();

        return cast_to_string<type, ValueType>(v.get_value(), v.get_scale());

    }

Unexecuted instantiation: _ZN5doris10vectorized16RuntimePredicate17get_decimal_valueILNS_13PrimitiveTypeE28EEENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERKNS0_5FieldE

Unexecuted instantiation: _ZN5doris10vectorized16RuntimePredicate17get_decimal_valueILNS_13PrimitiveTypeE29EEENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERKNS0_5FieldE

Unexecuted instantiation: _ZN5doris10vectorized16RuntimePredicate17get_decimal_valueILNS_13PrimitiveTypeE30EEENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERKNS0_5FieldE

Unexecuted instantiation: _ZN5doris10vectorized16RuntimePredicate17get_decimal_valueILNS_13PrimitiveTypeE35EEENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERKNS0_5FieldE

};

} // namespace vectorized

} // namespace doris