diff --git a/dbms/src/Functions/registerFunctionsString.cpp b/dbms/src/Functions/registerFunctionsString.cpp index e55e43ba2f9..1f4219b18f2 100644 --- a/dbms/src/Functions/registerFunctionsString.cpp +++ b/dbms/src/Functions/registerFunctionsString.cpp @@ -4,6 +4,7 @@ namespace DB { class FunctionFactory; +void registerFunctionRepeat(FunctionFactory &); void registerFunctionEmpty(FunctionFactory &); void registerFunctionNotEmpty(FunctionFactory &); void registerFunctionLength(FunctionFactory &); @@ -34,6 +35,7 @@ void registerFunctionTryBase64Decode(FunctionFactory &); void registerFunctionsString(FunctionFactory & factory) { + registerFunctionRepeat(factory); registerFunctionEmpty(factory); registerFunctionNotEmpty(factory); registerFunctionLength(factory); diff --git a/dbms/src/Functions/repeat.cpp b/dbms/src/Functions/repeat.cpp new file mode 100644 index 00000000000..741af698452 --- /dev/null +++ b/dbms/src/Functions/repeat.cpp @@ -0,0 +1,211 @@ +#include +#include +#include +#include +#include +#include +#include +#include +#include + +namespace DB +{ +namespace ErrorCodes +{ + extern const int ILLEGAL_COLUMN; + extern const int ILLEGAL_TYPE_OF_ARGUMENT; +} + +struct RepeatImpl +{ + static void vectorNonConstStr( + const ColumnString::Chars & data, + const ColumnString::Offsets & offsets, + ColumnString::Chars & res_data, + ColumnString::Offsets & res_offsets, + const UInt64 & repeat_time) + { + UInt64 data_size = 0; + res_offsets.assign(offsets); + for (UInt64 i = 0; i < offsets.size(); ++i) + { + data_size += (offsets[i] - offsets[i - 1] - 1) * repeat_time + 1; + res_offsets[i] = data_size; + } + res_data.resize(data_size); + for (UInt64 i = 0; i < res_offsets.size(); ++i) + { + array(data.data() + offsets[i - 1], res_data.data() + res_offsets[i - 1], offsets[i] - offsets[i - 1], repeat_time); + } + } + + static void + vectorConst(const String & copy_str, const UInt64 & repeat_time, ColumnString::Chars & res_data, ColumnString::Offsets & res_offsets) + { + UInt64 data_size = copy_str.size() * repeat_time + 1; + res_data.resize(data_size); + res_offsets.resize_fill(1, data_size); + array(reinterpret_cast(const_cast(copy_str.data())), res_data.data(), copy_str.size() + 1, repeat_time); + } + + template + static void vectorNonConst( + const ColumnString::Chars & data, + const ColumnString::Offsets & offsets, + ColumnString::Chars & res_data, + ColumnString::Offsets & res_offsets, + const PaddedPODArray & col_num) + { + UInt64 data_size = 0; + res_offsets.assign(offsets); + for (UInt64 i = 0; i < col_num.size(); ++i) + { + data_size += (offsets[i] - offsets[i - 1] - 1) * col_num[i] + 1; + res_offsets[i] = data_size; + } + res_data.resize(data_size); + for (UInt64 i = 0; i < col_num.size(); ++i) + { + array(data.data() + offsets[i - 1], res_data.data() + res_offsets[i - 1], offsets[i] - offsets[i - 1], col_num[i]); + } + } + + template + static void vectorNonConstInteger( + const String & copy_str, ColumnString::Chars & res_data, ColumnString::Offsets & res_offsets, const PaddedPODArray & col_num) + { + UInt64 data_size = 0; + res_offsets.resize(col_num.size()); + UInt64 str_size = copy_str.size(); + UInt64 col_size = col_num.size(); + for (UInt64 i = 0; i < col_size; ++i) + { + data_size += str_size * col_num[i] + 1; + res_offsets[i] = data_size; + } + res_data.resize(data_size); + for (UInt64 i = 0; i < col_size; ++i) + { + array( + reinterpret_cast(const_cast(copy_str.data())), + res_data.data() + res_offsets[i - 1], + str_size + 1, + col_num[i]); + } + } + +private: + static void array(const UInt8 * src, UInt8 * dst, const UInt64 & size, const UInt64 & repeat_time) + { + for (UInt64 i = 0; i < repeat_time; ++i) + { + memcpy(dst, src, size - 1); + dst += size - 1; + } + *dst = 0; + } +}; + +template +class FunctionRepeatImpl : public IFunction +{ + template + static bool castType(const IDataType * type, F && f) + { + return castTypeToEither(type, std::forward(f)); + } + +public: + static constexpr auto name = "repeat"; + static FunctionPtr create(const Context &) { return std::make_shared(); } + + String getName() const override { return name; } + + size_t getNumberOfArguments() const override { return 2; } + + DataTypePtr getReturnTypeImpl(const DataTypes & arguments) const override + { + if (!isString(arguments[0])) + throw Exception( + "Illegal type " + arguments[0]->getName() + " of argument of function " + getName(), ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT); + if (!isUnsignedInteger(arguments[1])) + throw Exception( + "Illegal type " + arguments[1]->getName() + " of argument of function " + getName(), ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT); + return arguments[0]; + } + + bool useDefaultImplementationForConstants() const override { return true; } + + void executeImpl(Block & block, const ColumnNumbers & arguments, size_t result, size_t) override + { + auto & strcolumn = block.getByPosition(arguments[0]).column; + auto & numcolumn = block.getByPosition(arguments[1]).column; + + if (const ColumnString * col = checkAndGetColumn(strcolumn.get())) + { + if (const ColumnConst * scale_column_num = checkAndGetColumn(numcolumn.get())) + { + Field scale_field_num = scale_column_num->getField(); + UInt64 repeat_time = scale_field_num.get(); + auto col_res = ColumnString::create(); + Impl::vectorNonConstStr(col->getChars(), col->getOffsets(), col_res->getChars(), col_res->getOffsets(), repeat_time); + block.getByPosition(result).column = std::move(col_res); + } + else if (!castType(block.getByPosition(arguments[1]).type.get(), [&](const auto & type) + { + using DataType = std::decay_t; + using T0 = typename DataType::FieldType; + const ColumnVector * colnum = checkAndGetColumn>(numcolumn.get()); + auto col_res = ColumnString::create(); + Impl::vectorNonConst(col->getChars(), col->getOffsets(), col_res->getChars(), col_res->getOffsets(), colnum->getData()); + block.getByPosition(result).column = std::move(col_res); + return 0; + })); + else + throw Exception( + "Illegal column " + block.getByPosition(arguments[1]).column->getName() + " of argument of function " + getName(), + ErrorCodes::ILLEGAL_COLUMN); + } + else if (const ColumnConst * scale_column_str = checkAndGetColumn(strcolumn.get())) + { + Field scale_field_str = scale_column_str->getField(); + String copy_str = scale_field_str.get(); + if (const ColumnConst * scale_column_num = checkAndGetColumn(numcolumn.get())) + { + Field scale_field_num = scale_column_num->getField(); + UInt64 repeat_time = scale_field_num.get(); + auto col_res = ColumnString::create(); + Impl::vectorConst(copy_str, repeat_time, col_res->getChars(), col_res->getOffsets()); + block.getByPosition(result).column = std::move(col_res); + } + else if (!castType(block.getByPosition(arguments[1]).type.get(), [&](const auto & type) + { + using DataType = std::decay_t; + using T0 = typename DataType::FieldType; + const ColumnVector * colnum = checkAndGetColumn>(numcolumn.get()); + auto col_res = ColumnString::create(); + Impl::vectorNonConstInteger(copy_str, col_res->getChars(), col_res->getOffsets(), colnum->getData()); + block.getByPosition(result).column = std::move(col_res); + return 0; + })) + { + } + else + throw Exception( + "Illegal column " + block.getByPosition(arguments[1]).column->getName() + " of argument of function " + getName(), + ErrorCodes::ILLEGAL_COLUMN); + } + else + throw Exception( + "Illegal column " + block.getByPosition(arguments[0]).column->getName() + " of argument of function " + getName(), + ErrorCodes::ILLEGAL_COLUMN); + } +}; + +using FunctionRepeat = FunctionRepeatImpl; + +void registerFunctionRepeat(FunctionFactory & factory) +{ + factory.registerFunction(); +} +} diff --git a/dbms/tests/queries/0_stateless/01013_repeat_function.reference b/dbms/tests/queries/0_stateless/01013_repeat_function.reference new file mode 100644 index 00000000000..7841bbd52f9 --- /dev/null +++ b/dbms/tests/queries/0_stateless/01013_repeat_function.reference @@ -0,0 +1,37 @@ +abcabcabcabcabcabcabcabcabcabc +abcabcabc +sdfggsdfgg +xywq + +abcabcabcabcabcabcabcabcabcabcabcabc +sdfggsdfggsdfggsdfggsdfggsdfggsdfggsdfggsdfggsdfgg +xywqxywqxywqxywq +plkfplkfplkfplkfplkf +abcabcabcabc +sdfggsdfggsdfggsdfggsdfggsdfggsdfggsdfggsdfggsdfggsdfggsdfggsdfggsdfggsdfggsdfggsdfggsdfggsdfggsdfggsdfgg +xywqxywqxywqxywqxywqxywqxywqxywqxywq +plkfplkfplkfplkfplkfplkfplkf +abcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabc +sdfggsdfggsdfggsdfggsdfggsdfggsdfggsdfggsdfggsdfggsdfggsdfggsdfggsdfggsdfggsdfggsdfggsdfggsdfggsdfggsdfggsdfggsdfggsdfggsdfggsdfggsdfggsdfggsdfggsdfggsdfggsdfggsdfggsdfggsdfggsdfggsdfggsdfggsdfggsdfggsdfggsdfggsdfggsdfggsdfggsdfggsdfggsdfggsdfggsdfggsdfggsdfggsdfggsdfggsdfggsdfggsdfggsdfggsdfggsdfggsdfggsdfggsdfggsdfggsdfggsdfggsdfggsdfggsdfggsdfggsdfggsdfggsdfggsdfggsdfggsdfggsdfggsdfggsdfggsdfggsdfggsdfggsdfggsdfggsdfggsdfggsdfggsdfggsdfggsdfggsdfggsdfggsdfggsdfggsdfggsdfggsdfggsdfggsdfggsdfggsdfggsdfggsdfggsdfggsdfggsdfggsdfggsdfggsdfggsdfggsdfggsdfggsdfggsdfggsdfggsdfggsdfggsdfggsdfggsdfggsdfggsdfggsdfggsdfggsdfggsdfggsdfggsdfggsdfggsdfggsdfggsdfggsdfggsdfggsdfggsdfggsdfggsdfggsdfggsdfggsdfggsdfggsdfggsdfggsdfggsdfggsdfggsdfggsdfggsdfggsdfggsdfggsdfggsdfggsdfggsdfggsdfggsdfggsdfggsdfggsdfggsdfggsdfggsdfggsdfggsdfggsdfggsdfggsdfggsdfggsdfggsdfggsdfggsdfggsdfggsdfggsdfggsdfggsdfggsdfggsdfggsdfggsdfggsdfggsdfggsdfggsdfggsdfggsdfggsdfggsdfggsdfggsdfggsdfggsdfggsdfggsdfggsdfggsdfggsdfgg +xywqxywqxywqxywqxywq +plkfplkfplkfplkfplkfplkfplkfplkfplkfplkfplkfplkfplkfplkfplkfplkfplkfplkfplkfplkfplkfplkfplkfplkfplkfplkfplkfplkfplkfplkfplkfplkfplkfplkfplkfplkfplkfplkfplkfplkfplkfplkfplkfplkfplkfplkfplkfplkfplkfplkfplkfplkfplkfplkfplkfplkfplkfplkfplkfplkfplkfplkfplkfplkfplkfplkfplkfplkfplkfplkfplkfplkfplkfplkfplkfplkfplkf +abcabcabcabcabcabcabcabcabcabc +sdfggsdfggsdfggsdfggsdfggsdfggsdfggsdfggsdfggsdfgg +xywqxywqxywqxywqxywqxywqxywqxywqxywqxywq +plkfplkfplkfplkfplkfplkfplkfplkfplkfplkf +abcabcabc +abcabc +abc + +abcabcabcabcabcabcabcabcabcabcabcabc +abcabcabcabcabcabcabcabcabcabc +abcabcabcabc +abcabcabcabcabc +abcabcabcabc +abcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabc +abcabcabcabcabcabcabcabcabc +abcabcabcabcabcabcabc +abcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabc +abcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabc +abcabcabcabcabc +abcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabc diff --git a/dbms/tests/queries/0_stateless/01013_repeat_function.sql b/dbms/tests/queries/0_stateless/01013_repeat_function.sql new file mode 100644 index 00000000000..5de0e7a64e5 --- /dev/null +++ b/dbms/tests/queries/0_stateless/01013_repeat_function.sql @@ -0,0 +1,24 @@ +SELECT repeat('abc', 10); +DROP TABLE IF EXISTS defaults; +CREATE TABLE defaults +( + strings String, + u8 UInt8, + u16 UInt16, + u32 UInt32, + u64 UInt64 +)ENGINE = Memory(); + +INSERT INTO defaults values ('abc', 3, 12, 4, 56) ('sdfgg', 2, 10, 21, 200) ('xywq', 1, 4, 9, 5) ('plkf', 0, 5, 7,77); + +SELECT repeat(strings, u8) FROM defaults; +SELECT repeat(strings, u16) FROM defaults; +SELECT repeat(strings, u32) from defaults; +SELECT repeat(strings, u64) FROM defaults; +SELECT repeat(strings, 10) FROM defaults; +SELECT repeat('abc', u8) FROM defaults; +SELECT repeat('abc', u16) FROM defaults; +SELECT repeat('abc', u32) FROM defaults; +SELECT repeat('abc', u64) FROM defaults; + +DROP TABLE defaults;