static void push_empty_string(size_t index, ColumnString::Chars& chars,

ColumnString::Offsets& offsets) {

offsets[index] = chars.size();

}

static void push_null_string(size_t index, ColumnString::Chars& chars,

ColumnString::Offsets& offsets, NullMap& null_map) {

null_map[index] = 1;

push_empty_string(index, chars, offsets);

}

static void push_value_string(const std::string_view& string_value, size_t index,

ColumnString::Chars& chars, ColumnString::Offsets& offsets) {

DCHECK(string_value.data() != nullptr);

ColumnString::check_chars_length(chars.size() + string_value.size(), offsets.size());

chars.insert(string_value.data(), string_value.data() + string_value.size());

offsets[index] = chars.size();

}

static void push_value_string_reserved_and_allow_overflow(const std::string_view& string_value,

size_t index,

ColumnString::Chars& chars,

ColumnString::Offsets& offsets) {

chars.insert_assume_reserved_and_allow_overflow(string_value.data(),

string_value.data() + string_value.size());

offsets[index] = chars.size();

}

static void fast_repeat(uint8_t* dst, const uint8_t* src, size_t src_size,

int32_t repeat_times) {

if (UNLIKELY(repeat_times <= 0)) {

return;

}

uint8_t* dst_begin = dst;

uint8_t* dst_curr = dst;

int32_t k = 0;

int32_t is_odd = repeat_times & 1;

repeat_times >>= 1;

memcpy(dst_curr, src, src_size);

dst_curr += src_size;

for (; repeat_times > 0; k += 1, is_odd = repeat_times & 1, repeat_times >>= 1) {

int32_t len = src_size * (1 << k);

memcpy(dst_curr, dst_begin, len);

dst_curr += len;

if (is_odd) {

memcpy(dst_curr, dst_begin, len);

dst_curr += len;

}

}

}

static constexpr auto name = "substring";

static void substring_execute(Block& block, const ColumnNumbers& arguments, uint32_t result,

size_t input_rows_count) {

DCHECK_EQ(arguments.size(), 3);

auto res = ColumnString::create();

bool col_const[3];

ColumnPtr argument_columns[3];

for (int i = 0; i < 3; ++i) {

col_const[i] = is_column_const(*block.get_by_position(arguments[i]).column);

}

argument_columns[0] = col_const[0] ? static_cast<const ColumnConst&>(

*block.get_by_position(arguments[0]).column)

.convert_to_full_column()

: block.get_by_position(arguments[0]).column;

default_preprocess_parameter_columns(argument_columns, col_const, {1, 2}, block, arguments);

const auto* specific_str_column =

assert_cast<const ColumnString*>(argument_columns[0].get());

const auto* specific_start_column =

assert_cast<const ColumnVector<Int32>*>(argument_columns[1].get());

const auto* specific_len_column =

assert_cast<const ColumnVector<Int32>*>(argument_columns[2].get());

auto vectors = vectors_utf8<false>;

bool is_ascii = simd::VStringFunctions::is_ascii(

{specific_str_column->get_chars().data(), specific_str_column->get_chars().size()});

if (col_const[1] && col_const[2] && is_ascii) {

vectors = vectors_ascii<true>;

} else if (col_const[1] && col_const[2]) {

vectors = vectors_utf8<true>;

} else if (is_ascii) {

vectors = vectors_ascii<false>;

}

vectors(specific_str_column->get_chars(), specific_str_column->get_offsets(),

specific_start_column->get_data(), specific_len_column->get_data(),

res->get_chars(), res->get_offsets());

block.get_by_position(result).column = std::move(res);

}

template <bool is_const>

static void vectors_utf8(const ColumnString::Chars& chars, const ColumnString::Offsets& offsets,

const PaddedPODArray<Int32>& start, const PaddedPODArray<Int32>& len,

ColumnString::Chars& res_chars, ColumnString::Offsets& res_offsets) {

size_t size = offsets.size();

res_offsets.resize(size);

res_chars.reserve(chars.size());

std::array<std::byte, 128 * 1024> buf;

PMR::monotonic_buffer_resource pool {buf.data(), buf.size()};

PMR::vector<size_t> index {&pool};

if constexpr (is_const) {

if (start[0] == 0 || len[0] <= 0) {

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

StringOP::push_empty_string(i, res_chars, res_offsets);

}

return;

}

}

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

int str_size = offsets[i] - offsets[i - 1];

const char* str_data = (char*)chars.data() + offsets[i - 1];

int start_value = is_const ? start[0] : start[i];

int len_value = is_const ? len[0] : len[i];

// Unsigned numbers cannot be used here because start_value can be negative.

int char_len = simd::VStringFunctions::get_char_len(str_data, str_size);

// return empty string if start > src.length

// Here, start_value is compared against the length of the character.

if (start_value > char_len || str_size == 0 || start_value == 0 || len_value <= 0) {

StringOP::push_empty_string(i, res_chars, res_offsets);

continue;

}

size_t byte_pos = 0;

index.clear();

for (size_t j = 0, char_size = 0; j < str_size; j += char_size) {

char_size = get_utf8_byte_length(str_data[j]);

index.push_back(j);

// index_size represents the number of characters from the beginning of the character to the current position.

// So index.size() > start_value + len_value breaks because you don't need to get the characters after start + len characters.

if (start_value > 0 && index.size() > start_value + len_value) {

break;

}

}

int fixed_pos = start_value;

if (fixed_pos < -(int)index.size()) {

StringOP::push_empty_string(i, res_chars, res_offsets);

continue;

}

if (fixed_pos < 0) {

fixed_pos = index.size() + fixed_pos + 1;

}

byte_pos = index[fixed_pos - 1];

size_t fixed_len = str_size - byte_pos;

if (fixed_pos + len_value <= index.size()) {

fixed_len = index[fixed_pos + len_value - 1] - byte_pos;

}

if (byte_pos <= str_size && fixed_len > 0) {

StringOP::push_value_string_reserved_and_allow_overflow(

{str_data + byte_pos, fixed_len}, i, res_chars, res_offsets);

} else {

StringOP::push_empty_string(i, res_chars, res_offsets);

}

}

}

template <bool is_const>

static void vectors_ascii(const ColumnString::Chars& chars,

const ColumnString::Offsets& offsets,

const PaddedPODArray<Int32>& start, const PaddedPODArray<Int32>& len,

ColumnString::Chars& res_chars, ColumnString::Offsets& res_offsets) {

size_t size = offsets.size();

res_offsets.resize(size);

if constexpr (is_const) {

if (start[0] == 0 || len[0] <= 0) {

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

StringOP::push_empty_string(i, res_chars, res_offsets);

}

return;

}

res_chars.reserve(std::min(chars.size(), len[0] * size));

} else {

res_chars.reserve(chars.size());

}

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

int str_size = offsets[i] - offsets[i - 1];

const char* str_data = (char*)chars.data() + offsets[i - 1];

int start_value = is_const ? start[0] : start[i];

int len_value = is_const ? len[0] : len[i];

if (start_value > str_size || start_value < -str_size || str_size == 0 ||

len_value <= 0) {

StringOP::push_empty_string(i, res_chars, res_offsets);

continue;

}

int fixed_pos = start_value - 1;

if (fixed_pos < 0) {

fixed_pos = str_size + fixed_pos + 1;

}

size_t fixed_len = std::min(str_size - fixed_pos, len_value);

StringOP::push_value_string_reserved_and_allow_overflow(

{str_data + fixed_pos, fixed_len}, i, res_chars, res_offsets);

}

}

static constexpr auto name = "strcmp";

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

String get_name() const override { return name; }

size_t get_number_of_arguments() const override { return 2; }

DataTypePtr get_return_type_impl(const DataTypes& arguments) const override {

return std::make_shared<DataTypeInt8>();

}

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

uint32_t result, size_t input_rows_count) const override {

const auto& [arg0_column, arg0_const] =

unpack_if_const(block.get_by_position(arguments[0]).column);

const auto& [arg1_column, arg1_const] =

unpack_if_const(block.get_by_position(arguments[1]).column);

auto result_column = ColumnInt8::create(input_rows_count);

if (auto arg0 = check_and_get_column<ColumnString>(arg0_column.get())) {

if (auto arg1 = check_and_get_column<ColumnString>(arg1_column.get())) {

if (arg0_const) {

scalar_vector(arg0->get_data_at(0), *arg1, *result_column);

} else if (arg1_const) {

vector_scalar(*arg0, arg1->get_data_at(0), *result_column);

} else {

vector_vector(*arg0, *arg1, *result_column);

}

}

}

block.replace_by_position(result, std::move(result_column));

return Status::OK();

}

static void scalar_vector(const StringRef str, const ColumnString& vec1, ColumnInt8& res) {

size_t size = vec1.size();

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

res.get_data()[i] = str.compare(vec1.get_data_at(i));

}

}

static void vector_scalar(const ColumnString& vec0, const StringRef str, ColumnInt8& res) {

size_t size = vec0.size();

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

res.get_data()[i] = vec0.get_data_at(i).compare(str);

}

}

static void vector_vector(const ColumnString& vec0, const ColumnString& vec1, ColumnInt8& res) {

size_t size = vec0.size();

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

res.get_data()[i] = vec0.get_data_at(i).compare(vec1.get_data_at(i));

}

}

static constexpr auto name = "auto_partition_name";

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

String get_name() const override { return name; }

size_t get_number_of_arguments() const override { return 0; }

bool is_variadic() const override { return true; }

bool use_default_implementation_for_nulls() const override { return false; }

DataTypePtr get_return_type_impl(const DataTypes& arguments) const override {

return std::make_shared<DataTypeString>();

}

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

uint32_t result, size_t input_rows_count) const override {

size_t argument_size = arguments.size();

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

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

std::vector<const ColumnString::Chars*> chars_list(argument_size);

std::vector<const ColumnString::Offsets*> offsets_list(argument_size);

std::vector<bool> is_const_args(argument_size);

std::vector<const ColumnUInt8::Container*> null_list(argument_size);

std::vector<ColumnPtr> argument_null_columns(argument_size);

std::vector<ColumnPtr> argument_columns(argument_size);

for (int i = 0; i < argument_size; ++i) {

argument_columns[i] =

block.get_by_position(arguments[i]).column->convert_to_full_column_if_const();

if (const auto* nullable =

check_and_get_column<const ColumnNullable>(*argument_columns[i])) {

null_list[i] = &nullable->get_null_map_data();

argument_null_columns[i] = nullable->get_null_map_column_ptr();

argument_columns[i] = nullable->get_nested_column_ptr();

} else {

null_list[i] = &const_null_map->get_data();

}

const auto& [col, is_const] =

unpack_if_const(block.get_by_position(arguments[i]).column);

const auto* col_str = assert_cast<const ColumnString*>(argument_columns[i].get());

chars_list[i] = &col_str->get_chars();

offsets_list[i] = &col_str->get_offsets();

is_const_args[i] = is_const;

}

auto res = ColumnString::create();

auto& res_data = res->get_chars();

auto& res_offset = res->get_offsets();

res_offset.resize(input_rows_count);

const char* partition_type = chars_list[0]->raw_data();

// partition type is list|range

if (std::strncmp(partition_type, "list", 4) == 0) {

return _auto_partition_type_of_list(chars_list, offsets_list, is_const_args, null_list,

res_data, res_offset, input_rows_count,

argument_size, block, result, res);

} else {

return _auto_partition_type_of_range(chars_list, offsets_list, is_const_args, res_data,

res_offset, input_rows_count, argument_size, block,

result, res);

}

return Status::OK();

}

std::u16string _string_to_u16string(const std::string& str) const {

return boost::locale::conv::utf_to_utf<char16_t>(str);

}

std::string _string_to_unicode(const std::u16string& s) const {

std::string res_s;

res_s.reserve(s.size());

if (s.length() > 0 && s[0] == '-') {

res_s += '_';

}

for (int i = 0; i < s.length(); i++) {

char ch = s[i];

if (std::isalnum(ch)) {

res_s += ch;

} else {

int unicodeValue = _get_code_point_at(s, i);

res_s += fmt::format("{:02x}", static_cast<uint32_t>(unicodeValue));

}

}

return res_s;

}

int _get_code_point_at(const std::u16string& str, std::size_t index) const {

char16_t first = str[index];

// [0xD800,0xDBFF] is the scope of the first code unit

if ((first >= 0xD800 && first <= 0xDBFF) && (index + 1 < str.size())) {

char16_t second = str[index + 1];

// [0xDC00,0xDFFF] is the scope of the second code unit

if (second >= 0xDC00 && second <= 0xDFFF) {

return ((first - 0xD800) << 10) + (second - 0xDC00) + 0x10000;

}

}

return first;

}

Status _auto_partition_type_of_list(std::vector<const ColumnString::Chars*>& chars_list,

std::vector<const ColumnString::Offsets*>& offsets_list,

std::vector<bool>& is_const_args,

const std::vector<const ColumnUInt8::Container*>& null_list,

auto& res_data, auto& res_offset, size_t input_rows_count,

size_t argument_size, Block& block, uint32_t result,

auto& res) const {

int curr_len = 0;

for (int row = 0; row < input_rows_count; row++) {

std::string res_p;

res_p.reserve(argument_size * 5);

res_p += 'p';

for (int col = 1; col < argument_size; col++) {

const auto& current_offsets = *offsets_list[col];

const auto& current_chars = *chars_list[col];

const auto& current_nullmap = *null_list[col];

if (current_nullmap[row]) {

res_p += 'X';

} else {

auto idx = index_check_const(row, is_const_args[col]);

int size = current_offsets[idx] - current_offsets[idx - 1];

const char* raw_chars =

reinterpret_cast<const char*>(&current_chars[current_offsets[idx - 1]]);

// convert string to u16string in order to convert to unicode strings

const std::string raw_str(raw_chars, size);

auto u16string = _string_to_u16string(raw_str);

res_p += _string_to_unicode(u16string) + std::to_string(u16string.size());

}

}

// check the name of length

int len = res_p.size();

if (len > 50) [[unlikely]] {

return Status::InvalidArgument(

"The list partition name cannot exceed 50 characters");

}

curr_len += len;

res_data.resize(curr_len);

memcpy(&res_data[res_offset[row - 1]], res_p.c_str(), len);

res_offset[row] = res_offset[row - 1] + len;

}

block.get_by_position(result).column = std::move(res);

return Status::OK();

}

size_t _copy_date_str_of_len_to_res_data(auto& res_data, auto& res_offset,

std::vector<std::string>& date_str, size_t row,

size_t len) const {

size_t curr_len = 1;

for (int j = 0; j < len; j++) {

memcpy(&res_data[res_offset[row - 1]] + curr_len, date_str[j].c_str(),

date_str[j].size());

curr_len += date_str[j].size();

}

return curr_len;

}

Status _auto_partition_type_of_range(std::vector<const ColumnString::Chars*>& chars_list,

std::vector<const ColumnString::Offsets*>& offsets_list,

std::vector<bool>& is_const_args, auto& res_data,

auto& res_offset, size_t input_rows_count,

size_t argument_size, Block& block, uint32_t result,

auto& res) const {

const char* range_type = chars_list[1]->raw_data();

res_data.resize(15 * input_rows_count);

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

const auto& current_offsets = *offsets_list[2];

const auto& current_chars = *chars_list[2];

auto idx = index_check_const(i, is_const_args[2]);

int size = current_offsets[idx] - current_offsets[idx - 1];

const char* tmp =

reinterpret_cast<const char*>(&current_chars[current_offsets[idx - 1]]);

std::string to_split_s(tmp, size);

// check the str if it is date|datetime

RE2 date_regex(R"(^\d{4}-\d{2}-\d{2}( \d{2}:\d{2}:\d{2})?$)");

if (!RE2::FullMatch(to_split_s, date_regex)) {

return Status::InvalidArgument("The range partition only support DATE|DATETIME");

}

// split date_str from (yyyy-mm-dd hh:mm:ss) to ([yyyy, mm, dd, hh, mm, ss])

std::vector<std::string> date_str(6);

date_str[0] = to_split_s.substr(0, 4);

for (int i = 5, j = 1; i <= size; i += 3, j++) {

date_str[j] = to_split_s.substr(i, 2);

}

int curr_len = 0;

res_data[res_offset[i - 1]] = 'p';

// raw => 2022-12-12 11:30:20

// year => 2022 01 01 00 00 00

// month => 2022 12 01 00 00 00

// day => 2022 12 12 00 00 00

// hour => 2022 12 12 11 00 00

// minute => 2022 12 11 30 00

// second => 2022 12 12 12 30 20

if (!strncmp(range_type, "year", 4)) {

curr_len += _copy_date_str_of_len_to_res_data(res_data, res_offset, date_str, i, 1);

memcpy(&res_data[res_offset[i - 1]] + curr_len, "0101", 4);

curr_len += 4;

} else if (!strncmp(range_type, "month", 5)) {

curr_len += _copy_date_str_of_len_to_res_data(res_data, res_offset, date_str, i, 2);

memcpy(&res_data[res_offset[i - 1]] + curr_len, "01", 2);

curr_len += 2;

} else if (!strncmp(range_type, "day", 3)) {

curr_len += _copy_date_str_of_len_to_res_data(res_data, res_offset, date_str, i, 3);

} else if (!strncmp(range_type, "hour", 4)) {

curr_len += _copy_date_str_of_len_to_res_data(res_data, res_offset, date_str, i, 4);

} else if (!strncmp(range_type, "minute", 6)) {

curr_len += _copy_date_str_of_len_to_res_data(res_data, res_offset, date_str, i, 5);

} else if (!strncmp(range_type, "second", 6)) {

curr_len += _copy_date_str_of_len_to_res_data(res_data, res_offset, date_str, i, 6);

}

// fill in zero

int zero = 15 - curr_len;

std::fill_n(&res_data[res_offset[i - 1]] + curr_len, zero, '0');

curr_len += zero;

res_offset[i] = res_offset[i - 1] + curr_len;

}

block.get_by_position(result).column = std::move(res);

return Status::OK();

}

static constexpr auto name = SubstringUtil::name;

String get_name() const override { return name; }

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

DataTypePtr get_return_type_impl(const DataTypes& arguments) const override {

return std::make_shared<DataTypeString>();

}

DataTypes get_variadic_argument_types_impl() const override {

return Impl::get_variadic_argument_types();

}

size_t get_number_of_arguments() const override {

return get_variadic_argument_types_impl().size();

}

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

uint32_t result, size_t input_rows_count) const override {

return Impl::execute_impl(context, block, arguments, result, input_rows_count);

}

static DataTypes get_variadic_argument_types() {

return {std::make_shared<DataTypeString>(), std::make_shared<DataTypeInt32>(),

std::make_shared<DataTypeInt32>()};

}

static Status execute_impl(FunctionContext* context, Block& block,

const ColumnNumbers& arguments, uint32_t result,

size_t input_rows_count) {

SubstringUtil::substring_execute(block, arguments, result, input_rows_count);

return Status::OK();

}

static DataTypes get_variadic_argument_types() {

return {std::make_shared<DataTypeString>(), std::make_shared<DataTypeInt32>()};

}

static Status execute_impl(FunctionContext* context, Block& block,

const ColumnNumbers& arguments, uint32_t result,

size_t input_rows_count) {

auto col_len = ColumnInt32::create(input_rows_count);

auto& strlen_data = col_len->get_data();

ColumnPtr str_col;

bool str_const;

std::tie(str_col, str_const) = unpack_if_const(block.get_by_position(arguments[0]).column);

const auto& str_offset = assert_cast<const ColumnString*>(str_col.get())->get_offsets();

if (str_const) {

std::fill(strlen_data.begin(), strlen_data.end(), str_offset[0] - str_offset[-1]);

} else {

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

strlen_data[i] = str_offset[i] - str_offset[i - 1];

}

}

// we complete the column2(strlen) with the default value - each row's strlen.

block.insert({std::move(col_len), std::make_shared<DataTypeInt32>(), "strlen"});

ColumnNumbers temp_arguments = {arguments[0], arguments[1], block.columns() - 1};

SubstringUtil::substring_execute(block, temp_arguments, result, input_rows_count);

return Status::OK();

}

static constexpr auto name = "mask";

static constexpr unsigned char DEFAULT_UPPER_MASK = 'X';

static constexpr unsigned char DEFAULT_LOWER_MASK = 'x';

static constexpr unsigned char DEFAULT_NUMBER_MASK = 'n';

String get_name() const override { return name; }

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

DataTypePtr get_return_type_impl(const DataTypes& arguments) const override {

return std::make_shared<DataTypeString>();

}

size_t get_number_of_arguments() const override { return 0; }

ColumnNumbers get_arguments_that_are_always_constant() const override { return {1, 2, 3}; }

bool is_variadic() const override { return true; }

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

uint32_t result, size_t input_rows_count) const override {

DCHECK_GE(arguments.size(), 1);

DCHECK_LE(arguments.size(), 4);

char upper = DEFAULT_UPPER_MASK, lower = DEFAULT_LOWER_MASK, number = DEFAULT_NUMBER_MASK;

auto res = ColumnString::create();

const auto& source_column =

assert_cast<const ColumnString&>(*block.get_by_position(arguments[0]).column);

if (arguments.size() > 1) {

const auto& col = *block.get_by_position(arguments[1]).column;

auto string_ref = col.get_data_at(0);

if (string_ref.size > 0) {

upper = *string_ref.data;

}

}

if (arguments.size() > 2) {

const auto& col = *block.get_by_position(arguments[2]).column;

auto string_ref = col.get_data_at(0);

if (string_ref.size > 0) {

lower = *string_ref.data;

}

}

if (arguments.size() > 3) {

const auto& col = *block.get_by_position(arguments[3]).column;

auto string_ref = col.get_data_at(0);

if (string_ref.size > 0) {

number = *string_ref.data;

}

}

if (arguments.size() > 4) {

return Status::InvalidArgument(

fmt::format("too many arguments for function {}", get_name()));

}

vector_mask(source_column, *res, upper, lower, number);

block.get_by_position(result).column = std::move(res);

return Status::OK();

}

friend class FunctionMaskPartial<true>;

friend class FunctionMaskPartial<false>;

static void vector_mask(const ColumnString& source, ColumnString& result, const char upper,

const char lower, const char number) {

result.get_chars().resize(source.get_chars().size());

result.get_offsets().resize(source.get_offsets().size());

memcpy_small_allow_read_write_overflow15(

result.get_offsets().data(), source.get_offsets().data(),

source.get_offsets().size() * sizeof(ColumnString::Offset));

const unsigned char* src = source.get_chars().data();

const size_t size = source.get_chars().size();

unsigned char* res = result.get_chars().data();

mask(src, size, upper, lower, number, res);

}

static void mask(const unsigned char* __restrict src, const size_t size,

const unsigned char upper, const unsigned char lower,

const unsigned char number, unsigned char* __restrict res) {

for (size_t i = 0; i != size; ++i) {

auto c = src[i];

if (c >= 'A' && c <= 'Z') {

res[i] = upper;

} else if (c >= 'a' && c <= 'z') {

res[i] = lower;

} else if (c >= '0' && c <= '9') {

res[i] = number;

} else {

res[i] = c;

}

}

}

static constexpr auto name = Reverse ? "mask_last_n" : "mask_first_n";

String get_name() const override { return name; }

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

DataTypePtr get_return_type_impl(const DataTypes& arguments) const override {

return std::make_shared<DataTypeString>();

}

size_t get_number_of_arguments() const override { return 0; }

bool is_variadic() const override { return true; }

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

uint32_t result, size_t input_rows_count) const override {

int n = -1; // means unassigned

auto res = ColumnString::create();

auto col = block.get_by_position(arguments[0]).column->convert_to_full_column_if_const();

const auto& source_column = assert_cast<const ColumnString&>(*col);

if (arguments.size() == 2) {

const auto& col = *block.get_by_position(arguments[1]).column;

// the 2nd arg is const. checked in fe.

if (col.get_int(0) < 0) [[unlikely]] {

return Status::InvalidArgument(

"function {} only accept non-negative input for 2nd argument but got {}",

name, col.get_int(0));

}

n = col.get_int(0);

}

if (n == -1) { // no 2nd arg, just mask all

FunctionMask::vector_mask(source_column, *res, FunctionMask::DEFAULT_UPPER_MASK,

FunctionMask::DEFAULT_LOWER_MASK,

FunctionMask::DEFAULT_NUMBER_MASK);

} else { // n >= 0

vector(source_column, n, *res);

}

block.get_by_position(result).column = std::move(res);

return Status::OK();

}

static void vector(const ColumnString& src, int n, ColumnString& result) {

const auto num_rows = src.size();

const auto* chars = src.get_chars().data();

const auto* offsets = src.get_offsets().data();

result.get_chars().resize(src.get_chars().size());

result.get_offsets().resize(src.get_offsets().size());

memcpy_small_allow_read_write_overflow15(

result.get_offsets().data(), src.get_offsets().data(),

src.get_offsets().size() * sizeof(ColumnString::Offset));

auto* res = result.get_chars().data();

for (ssize_t i = 0; i != num_rows; ++i) {

auto offset = offsets[i - 1];

int len = offsets[i] - offset;

if constexpr (Reverse) {

auto start = std::max(len - n, 0);

if (start > 0) {

memcpy(&res[offset], &chars[offset], start);

}

offset += start;

} else {

if (n < len) {

memcpy(&res[offset + n], &chars[offset + n], len - n);

}

}

len = std::min(n, len);

FunctionMask::mask(&chars[offset], len, FunctionMask::DEFAULT_UPPER_MASK,

FunctionMask::DEFAULT_LOWER_MASK, FunctionMask::DEFAULT_NUMBER_MASK,

&res[offset]);

}

}

static constexpr auto name = "left";

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

String get_name() const override { return name; }

size_t get_number_of_arguments() const override { return 2; }

DataTypePtr get_return_type_impl(const DataTypes& arguments) const override {

return std::make_shared<DataTypeString>();

}

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

uint32_t result, size_t input_rows_count) const override {

auto int_type = std::make_shared<DataTypeInt32>();

size_t num_columns_without_result = block.columns();

block.insert({int_type->create_column_const(input_rows_count, to_field(1)), int_type,

"const 1"});

ColumnNumbers temp_arguments(3);

temp_arguments[0] = arguments[0];

temp_arguments[1] = num_columns_without_result;

temp_arguments[2] = arguments[1];

SubstringUtil::substring_execute(block, temp_arguments, result, input_rows_count);

return Status::OK();

}

static constexpr auto name = "right";

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

String get_name() const override { return name; }

size_t get_number_of_arguments() const override { return 2; }

DataTypePtr get_return_type_impl(const DataTypes& arguments) const override {

return std::make_shared<DataTypeString>();

}

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

uint32_t result, size_t input_rows_count) const override {

auto int_type = std::make_shared<DataTypeInt32>();

auto params1 = ColumnInt32::create(input_rows_count);

auto params2 = ColumnInt32::create(input_rows_count);

size_t num_columns_without_result = block.columns();

// params1 = max(arg[1], -len(arg))

auto& index_data = params1->get_data();

auto& strlen_data = params2->get_data();

auto str_col =

block.get_by_position(arguments[0]).column->convert_to_full_column_if_const();

const auto& str_offset = assert_cast<const ColumnString*>(str_col.get())->get_offsets();

auto pos_col =

block.get_by_position(arguments[1]).column->convert_to_full_column_if_const();

const auto& pos_data = assert_cast<const ColumnInt32*>(pos_col.get())->get_data();

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

strlen_data[i] = str_offset[i] - str_offset[i - 1];

}

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

index_data[i] = std::max(-pos_data[i], -strlen_data[i]);

}

block.insert({std::move(params1), int_type, "index"});

block.insert({std::move(params2), int_type, "strlen"});

ColumnNumbers temp_arguments(3);

temp_arguments[0] = arguments[0];

temp_arguments[1] = num_columns_without_result;

temp_arguments[2] = num_columns_without_result + 1;

SubstringUtil::substring_execute(block, temp_arguments, result, input_rows_count);

return Status::OK();

}

static DataTypes get_variadic_argument_types() { return {std::make_shared<DataTypeUInt8>()}; }

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

uint32_t result, size_t input_rows_count, bool reverse) {

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

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

if (auto* nullable = check_and_get_column<const ColumnNullable>(*column)) {

column = nullable->get_nested_column_ptr();

VectorizedUtils::update_null_map(res_map->get_data(), nullable->get_null_map_data());

}

auto str_col = assert_cast<const ColumnString*>(column.get());

const auto& offsets = str_col->get_offsets();

auto& res_map_data = res_map->get_data();

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

int size = offsets[i] - offsets[i - 1];

res_map_data[i] |= (size == 0);

}

if (reverse) {

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

res_map_data[i] = !res_map_data[i];

}

}

block.replace_by_position(result, std::move(res_map));

return Status::OK();

}

static constexpr auto name = "null_or_empty";

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

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 std::make_shared<DataTypeUInt8>();

}

bool use_default_implementation_for_nulls() const override { return false; }

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

uint32_t result, size_t input_rows_count) const override {

RETURN_IF_ERROR(NullOrEmptyImpl::execute(context, block, arguments, result,

input_rows_count, false));

return Status::OK();

}