ClickHouse/dbms/src/Functions/formatString.cpp

139 lines
4.8 KiB
C++
Raw Normal View History

2019-05-18 12:29:10 +00:00
#include <Columns/ColumnFixedString.h>
2019-05-18 13:21:48 +00:00
#include <Columns/ColumnString.h>
#include <DataTypes/DataTypeString.h>
2019-05-18 11:30:36 +00:00
#include <Functions/FunctionFactory.h>
#include <Functions/FunctionHelpers.h>
#include <Functions/IFunction.h>
#include <IO/WriteHelpers.h>
#include <ext/range.h>
#include <memory>
#include <string>
#include <vector>
#include "formatString.h"
2019-05-18 11:30:36 +00:00
namespace DB
{
namespace ErrorCodes
{
extern const int ILLEGAL_COLUMN;
extern const int ILLEGAL_TYPE_OF_ARGUMENT;
extern const int NUMBER_OF_ARGUMENTS_DOESNT_MATCH;
}
template <typename Name>
2019-05-18 11:30:36 +00:00
class FormatFunction : public IFunction
{
public:
static constexpr auto name = Name::name;
static FunctionPtr create(const Context &) { return std::make_shared<FormatFunction>(); }
String getName() const override { return name; }
bool isVariadic() const override { return true; }
size_t getNumberOfArguments() const override { return 0; }
ColumnNumbers getArgumentsThatAreAlwaysConstant() const override { return {0}; }
DataTypePtr getReturnTypeImpl(const DataTypes & arguments) const override
{
if (arguments.empty())
2019-05-18 13:21:48 +00:00
throw Exception(
"Number of arguments for function " + getName() + " doesn't match: passed " + toString(arguments.size())
+ ", should be at least 1",
2019-05-18 11:30:36 +00:00
ErrorCodes::NUMBER_OF_ARGUMENTS_DOESNT_MATCH);
if (arguments.size() > FormatImpl::argument_threshold)
2019-05-18 13:21:48 +00:00
throw Exception(
"Number of arguments for function " + getName() + " doesn't match: passed " + toString(arguments.size())
+ ", should be at most " + std::to_string(FormatImpl::argument_threshold),
2019-05-18 11:30:36 +00:00
ErrorCodes::NUMBER_OF_ARGUMENTS_DOESNT_MATCH);
for (const auto arg_idx : ext::range(0, arguments.size()))
{
const auto arg = arguments[arg_idx].get();
if (!isStringOrFixedString(arg))
2019-05-18 13:21:48 +00:00
throw Exception(
"Illegal type " + arg->getName() + " of argument " + std::to_string(arg_idx + 1) + " of function " + getName(),
2019-05-18 11:30:36 +00:00
ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT);
}
return std::make_shared<DataTypeString>();
}
void executeImpl(Block & block, const ColumnNumbers & arguments, size_t result, size_t input_rows_count) override
{
2019-05-18 15:09:52 +00:00
const ColumnPtr & c0 = block.getByPosition(arguments[0]).column;
2019-05-18 11:30:36 +00:00
const ColumnConst * c0_const_string = typeid_cast<const ColumnConst *>(&*c0);
if (!c0_const_string)
throw Exception("First argument of function " + getName() + " must be constant string", ErrorCodes::ILLEGAL_COLUMN);
String pattern = c0_const_string->getValue<String>();
auto col_res = ColumnString::create();
2019-05-18 11:30:36 +00:00
std::vector<const ColumnString::Chars *> data(arguments.size() - 1);
std::vector<const ColumnString::Offsets *> offsets(arguments.size() - 1);
2019-05-18 12:29:10 +00:00
std::vector<size_t> fixed_string_N(arguments.size() - 1);
2019-05-18 15:09:52 +00:00
std::vector<String> constant_strings(arguments.size() - 1);
2019-05-18 12:52:33 +00:00
bool has_column_string = false;
bool has_column_fixed_string = false;
2019-05-18 11:30:36 +00:00
for (size_t i = 1; i < arguments.size(); ++i)
{
2019-05-18 15:09:52 +00:00
const ColumnPtr & column = block.getByPosition(arguments[i]).column;
2019-05-18 11:30:36 +00:00
if (const ColumnString * col = checkAndGetColumn<ColumnString>(column.get()))
{
2019-05-18 12:56:26 +00:00
has_column_string = true;
data[i - 1] = &col->getChars();
offsets[i - 1] = &col->getOffsets();
2019-05-18 11:30:36 +00:00
}
2019-05-18 12:29:10 +00:00
else if (const ColumnFixedString * fixed_col = checkAndGetColumn<ColumnFixedString>(column.get()))
{
2019-05-18 12:56:26 +00:00
has_column_fixed_string = true;
data[i - 1] = &fixed_col->getChars();
2019-05-18 12:29:10 +00:00
fixed_string_N[i - 1] = fixed_col->getN();
}
2019-05-18 15:09:52 +00:00
else if (const ColumnConst * const_col = checkAndGetColumnConstStringOrFixedString(column.get()))
{
constant_strings[i - 1] = const_col->getValue<String>();
}
2019-05-18 11:30:36 +00:00
else
throw Exception(
2019-05-18 13:21:48 +00:00
"Illegal column " + column->getName() + " of argument of function " + getName(), ErrorCodes::ILLEGAL_COLUMN);
2019-05-18 11:30:36 +00:00
}
2019-05-18 13:21:48 +00:00
FormatImpl::formatExecute(
has_column_string,
has_column_fixed_string,
std::move(pattern),
data,
offsets,
fixed_string_N,
constant_strings,
col_res->getChars(),
col_res->getOffsets(),
input_rows_count);
2019-05-18 11:30:36 +00:00
block.getByPosition(result).column = std::move(col_res);
}
};
struct NameFormat
{
static constexpr auto name = "format";
};
using FunctionFormat = FormatFunction<NameFormat>;
2019-05-18 11:30:36 +00:00
void registerFunctionFormat(FunctionFactory & factory)
{
factory.registerFunction<FunctionFormat>();
}
}