// 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 "core/column/column_complex.h"

#include "core/data_type/data_type_number.h"

#include "core/value/bitmap_value.h"

#include "exec/common/util.hpp"

namespace doris {

struct FunctionBitmapMinImpl {

static constexpr auto name = "bitmap_min";

static Int64 calculate(const BitmapValue& value) { return value.minimum(); }

};

struct FunctionBitmapMaxImpl {

static constexpr auto name = "bitmap_max";

static Int64 calculate(const BitmapValue& value) { return value.maximum(); }

};

template <typename Impl>

class FunctionBitmapSingle : public IFunction {

public:

static constexpr auto name = Impl::name;

static FunctionPtr create() { return std::make_shared<FunctionBitmapSingle>(); }

String get_name() const override { return name; }

size_t get_number_of_arguments() const override { return 1; }

DataTypePtr get_return_type_impl(const DataTypes& arguments) const override {

return make_nullable(std::make_shared<DataTypeInt64>());

}

Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments,

uint32_t result, size_t input_rows_count) const override {

auto result_column = ColumnInt64::create();

auto result_null_map_column = ColumnUInt8::create(input_rows_count, 0);

ColumnPtr argument_column = block.get_by_position(arguments[0]).column;

execute_straight(assert_cast<const ColumnBitmap*>(argument_column.get()),

result_column.get(), result_null_map_column.get()->get_data(),

input_rows_count);

block.get_by_position(result).column =

ColumnNullable::create(std::move(result_column), std::move(result_null_map_column));

return Status::OK();

}

private:

void execute_straight(const ColumnBitmap* date_column, ColumnInt64* result_column,

NullMap& result_null_map, size_t input_rows_count) const {

for (size_t i = 0; i < input_rows_count; i++) {

if (result_null_map[i]) {

result_column->insert_default();

continue;

}

BitmapValue value = date_column->get_element(i);

if (!value.cardinality()) {

result_null_map[i] = true;

result_column->insert_default();

continue;

}

result_column->insert(Field::create_field<TYPE_BIGINT>(Impl::calculate(value)));

}

}

};

} // namespace doris