thevar1able/ClickHouse
1
0
Fork 0
mirror of https://github.com/ClickHouse/ClickHouse.git synced 2024-09-20 08:40:50 +00:00
Code Issues Packages Projects Releases Wiki Activity

Part 4.

Browse Source
This commit is contained in:
Nikolai Kochetov 2020-10-18 00:41:50 +03:00
parent 142ce5ece0
commit ce2f6a0560
30 changed files with 168 additions and 177 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

14
src/AggregateFunctions/AggregateFunctionMLMethod.cpp
View File

@ -449,15 +449,14 @@ void IWeightsUpdater::addToBatch(
void LogisticRegression::predict( void LogisticRegression::predict(
ColumnVector<Float64>::Container & container, ColumnVector<Float64>::Container & container,
ColumnsWithTypeAndName & columns, ColumnsWithTypeAndName & arguments,
size_t offset, size_t offset,
size_t limit, size_t limit,
const ColumnNumbers & arguments,
const std::vector<Float64> & weights, const std::vector<Float64> & weights,
Float64 bias, Float64 bias,
const Context & /*context*/) const const Context & /*context*/) const
{ {
size_t rows_num = columns[arguments.front()].column->size(); size_t rows_num = arguments.front().column->size();
if (offset > rows_num || offset + limit > rows_num) if (offset > rows_num || offset + limit > rows_num)
throw Exception("Invalid offset and limit for LogisticRegression::predict. " throw Exception("Invalid offset and limit for LogisticRegression::predict. "
@ -468,7 +467,7 @@ void LogisticRegression::predict(
for (size_t i = 1; i < arguments.size(); ++i) for (size_t i = 1; i < arguments.size(); ++i)
{ {
const ColumnWithTypeAndName & cur_col = columns[arguments[i]]; const ColumnWithTypeAndName & cur_col = arguments[i];
if (!isNativeNumber(cur_col.type)) if (!isNativeNumber(cur_col.type))
throw Exception("Prediction arguments must have numeric type", ErrorCodes::BAD_ARGUMENTS); throw Exception("Prediction arguments must have numeric type", ErrorCodes::BAD_ARGUMENTS);
@ -518,10 +517,9 @@ void LogisticRegression::compute(
void LinearRegression::predict( void LinearRegression::predict(
ColumnVector<Float64>::Container & container, ColumnVector<Float64>::Container & container,
ColumnsWithTypeAndName & columns, ColumnsWithTypeAndName & arguments,
size_t offset, size_t offset,
size_t limit, size_t limit,
const ColumnNumbers & arguments,
const std::vector<Float64> & weights, const std::vector<Float64> & weights,
Float64 bias, Float64 bias,
const Context & /*context*/) const const Context & /*context*/) const
@ -531,7 +529,7 @@ void LinearRegression::predict(
throw Exception("In predict function number of arguments differs from the size of weights vector", ErrorCodes::LOGICAL_ERROR); throw Exception("In predict function number of arguments differs from the size of weights vector", ErrorCodes::LOGICAL_ERROR);
} }
size_t rows_num = columns[arguments.front()].column->size(); size_t rows_num = arguments.front().column->size();
if (offset > rows_num || offset + limit > rows_num) if (offset > rows_num || offset + limit > rows_num)
throw Exception("Invalid offset and limit for LogisticRegression::predict. " throw Exception("Invalid offset and limit for LogisticRegression::predict. "
@ -542,7 +540,7 @@ void LinearRegression::predict(
for (size_t i = 1; i < arguments.size(); ++i) for (size_t i = 1; i < arguments.size(); ++i)
{ {
const ColumnWithTypeAndName & cur_col = columns[arguments[i]]; const ColumnWithTypeAndName & cur_col = arguments[i];
if (!isNativeNumber(cur_col.type)) if (!isNativeNumber(cur_col.type))
throw Exception("Prediction arguments must have numeric type", ErrorCodes::BAD_ARGUMENTS); throw Exception("Prediction arguments must have numeric type", ErrorCodes::BAD_ARGUMENTS);

14
src/AggregateFunctions/AggregateFunctionMLMethod.h
View File

@ -39,10 +39,9 @@ public:
virtual void predict( virtual void predict(
ColumnVector<Float64>::Container & container, ColumnVector<Float64>::Container & container,
ColumnsWithTypeAndName & columns, ColumnsWithTypeAndName & arguments,
size_t offset, size_t offset,
size_t limit, size_t limit,
const ColumnNumbers & arguments,
const std::vector<Float64> & weights, const std::vector<Float64> & weights,
Float64 bias, Float64 bias,
const Context & context) const = 0; const Context & context) const = 0;
@ -65,10 +64,9 @@ public:
void predict( void predict(
ColumnVector<Float64>::Container & container, ColumnVector<Float64>::Container & container,
ColumnsWithTypeAndName & columns, ColumnsWithTypeAndName & arguments,
size_t offset, size_t offset,
size_t limit, size_t limit,
const ColumnNumbers & arguments,
const std::vector<Float64> & weights, const std::vector<Float64> & weights,
Float64 bias, Float64 bias,
const Context & context) const override; const Context & context) const override;
@ -91,10 +89,9 @@ public:
void predict( void predict(
ColumnVector<Float64>::Container & container, ColumnVector<Float64>::Container & container,
ColumnsWithTypeAndName & columns, ColumnsWithTypeAndName & arguments,
size_t offset, size_t offset,
size_t limit, size_t limit,
const ColumnNumbers & arguments,
const std::vector<Float64> & weights, const std::vector<Float64> & weights,
Float64 bias, Float64 bias,
const Context & context) const override; const Context & context) const override;
@ -364,10 +361,9 @@ public:
void predictValues( void predictValues(
ConstAggregateDataPtr place, ConstAggregateDataPtr place,
IColumn & to, IColumn & to,
ColumnsWithTypeAndName & columns, ColumnsWithTypeAndName & arguments,
size_t offset, size_t offset,
size_t limit, size_t limit,
const ColumnNumbers & arguments,
const Context & context) const override const Context & context) const override
{ {
if (arguments.size() != param_num + 1) if (arguments.size() != param_num + 1)
@ -382,7 +378,7 @@ public:
throw Exception("Cast of column of predictions is incorrect. getReturnTypeToPredict must return same value as it is casted to", throw Exception("Cast of column of predictions is incorrect. getReturnTypeToPredict must return same value as it is casted to",
ErrorCodes::LOGICAL_ERROR); ErrorCodes::LOGICAL_ERROR);
this->data(place).predict(column->getData(), columns, offset, limit, arguments, context); this->data(place).predict(column->getData(), arguments, offset, limit, context);
} }
/** This function is called if aggregate function without State modifier is selected in a query. /** This function is called if aggregate function without State modifier is selected in a query.

3
src/AggregateFunctions/IAggregateFunction.h
View File

@ -114,10 +114,9 @@ public:
virtual void predictValues( virtual void predictValues(
ConstAggregateDataPtr /* place */, ConstAggregateDataPtr /* place */,
IColumn & /*to*/, IColumn & /*to*/,
ColumnsWithTypeAndName & /*block*/, ColumnsWithTypeAndName & /*arguments*/,
size_t /*offset*/, size_t /*offset*/,
size_t /*limit*/, size_t /*limit*/,
const ColumnNumbers & /*arguments*/,
const Context & /*context*/) const const Context & /*context*/) const
{ {
throw Exception("Method predictValues is not supported for " + getName(), ErrorCodes::NOT_IMPLEMENTED); throw Exception("Method predictValues is not supported for " + getName(), ErrorCodes::NOT_IMPLEMENTED);

6
src/Columns/ColumnAggregateFunction.cpp
View File

@ -161,7 +161,7 @@ MutableColumnPtr ColumnAggregateFunction::convertToValues(MutableColumnPtr colum
return res; return res;
} }
MutableColumnPtr ColumnAggregateFunction::predictValues(ColumnsWithTypeAndName & block, const ColumnNumbers & arguments, const Context & context) const MutableColumnPtr ColumnAggregateFunction::predictValues(ColumnsWithTypeAndName & arguments, const Context & context) const
{ {
MutableColumnPtr res = func->getReturnTypeToPredict()->createColumn(); MutableColumnPtr res = func->getReturnTypeToPredict()->createColumn();
res->reserve(data.size()); res->reserve(data.size());
@ -172,7 +172,7 @@ MutableColumnPtr ColumnAggregateFunction::predictValues(ColumnsWithTypeAndName &
if (data.size() == 1) if (data.size() == 1)
{ {
/// Case for const column. Predict using single model. /// Case for const column. Predict using single model.
machine_learning_function->predictValues(data[0], *res, block, 0, block[arguments.front()].column->size(), arguments, context); machine_learning_function->predictValues(data[0], *res, arguments, 0, arguments.front().column->size(), context);
} }
else else
{ {
@ -180,7 +180,7 @@ MutableColumnPtr ColumnAggregateFunction::predictValues(ColumnsWithTypeAndName &
size_t row_num = 0; size_t row_num = 0;
for (auto * val : data) for (auto * val : data)
{ {
machine_learning_function->predictValues(val, *res, block, row_num, 1, arguments, context); machine_learning_function->predictValues(val, *res, arguments, row_num, 1, context);
++row_num; ++row_num;
} }
} }

2
src/Columns/ColumnAggregateFunction.h
View File

@ -119,7 +119,7 @@ public:
const char * getFamilyName() const override { return "AggregateFunction"; } const char * getFamilyName() const override { return "AggregateFunction"; }
TypeIndex getDataType() const override { return TypeIndex::AggregateFunction; } TypeIndex getDataType() const override { return TypeIndex::AggregateFunction; }
MutableColumnPtr predictValues(ColumnsWithTypeAndName & block, const ColumnNumbers & arguments, const Context & context) const; MutableColumnPtr predictValues(ColumnsWithTypeAndName & arguments, const Context & context) const;
size_t size() const override size_t size() const override
{ {

18
src/Functions/FunctionCustomWeekToSomething.h
View File

@ -96,26 +96,26 @@ public:
bool useDefaultImplementationForConstants() const override { return true; } bool useDefaultImplementationForConstants() const override { return true; }
ColumnNumbers getArgumentsThatAreAlwaysConstant() const override { return {1, 2}; } ColumnNumbers getArgumentsThatAreAlwaysConstant() const override { return {1, 2}; }
void executeImpl(ColumnsWithTypeAndName & columns, const ColumnNumbers & arguments, size_t result, size_t input_rows_count) const override ColumnPtr executeImpl(ColumnsWithTypeAndName & arguments, const DataTypePtr & result_type, size_t input_rows_count) const override
{ {
const IDataType * from_type = columns[arguments[0]].type.get(); const IDataType * from_type = arguments[0].type.get();
WhichDataType which(from_type); WhichDataType which(from_type);
if (which.isDate()) if (which.isDate())
CustomWeekTransformImpl<DataTypeDate, ToDataType>::execute( return CustomWeekTransformImpl<DataTypeDate, ToDataType>::execute(
columns, arguments, result, input_rows_count, Transform{}); arguments, result_type, input_rows_count, Transform{});
else if (which.isDateTime()) else if (which.isDateTime())
CustomWeekTransformImpl<DataTypeDateTime, ToDataType>::execute( return CustomWeekTransformImpl<DataTypeDateTime, ToDataType>::execute(
columns, arguments, result, input_rows_count, Transform{}); arguments, result_type, input_rows_count, Transform{});
else if (which.isDateTime64()) else if (which.isDateTime64())
{ {
CustomWeekTransformImpl<DataTypeDateTime64, ToDataType>::execute( return CustomWeekTransformImpl<DataTypeDateTime64, ToDataType>::execute(
columns, arguments, result, input_rows_count, arguments, result_type, input_rows_count,
TransformDateTime64<Transform>{assert_cast<const DataTypeDateTime64 *>(from_type)->getScale()}); TransformDateTime64<Transform>{assert_cast<const DataTypeDateTime64 *>(from_type)->getScale()});
} }
else else
throw Exception( throw Exception(
"Illegal type " + columns[arguments[0]].type->getName() + " of argument of function " + getName(), "Illegal type " + arguments[0].type->getName() + " of argument of function " + getName(),
ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT); ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT);
} }

12
src/Functions/FunctionDateOrDateTimeToSomething.h
View File

@ -95,23 +95,23 @@ public:
bool useDefaultImplementationForConstants() const override { return true; } bool useDefaultImplementationForConstants() const override { return true; }
ColumnNumbers getArgumentsThatAreAlwaysConstant() const override { return {1}; } ColumnNumbers getArgumentsThatAreAlwaysConstant() const override { return {1}; }
void executeImpl(ColumnsWithTypeAndName & columns, const ColumnNumbers & arguments, size_t result, size_t input_rows_count) const override ColumnPtr executeImpl(ColumnsWithTypeAndName & arguments, const DataTypePtr & result_type, size_t input_rows_count) const override
{ {
const IDataType * from_type = columns[arguments[0]].type.get(); const IDataType * from_type = arguments[0].type.get();
WhichDataType which(from_type); WhichDataType which(from_type);
if (which.isDate()) if (which.isDate())
DateTimeTransformImpl<DataTypeDate, ToDataType, Transform>::execute(columns, arguments, result, input_rows_count); return DateTimeTransformImpl<DataTypeDate, ToDataType, Transform>::execute(arguments, result_type, input_rows_count);
else if (which.isDateTime()) else if (which.isDateTime())
DateTimeTransformImpl<DataTypeDateTime, ToDataType, Transform>::execute(columns, arguments, result, input_rows_count); return DateTimeTransformImpl<DataTypeDateTime, ToDataType, Transform>::execute(arguments, result_type, input_rows_count);
else if (which.isDateTime64()) else if (which.isDateTime64())
{ {
const auto scale = static_cast<const DataTypeDateTime64 *>(from_type)->getScale(); const auto scale = static_cast<const DataTypeDateTime64 *>(from_type)->getScale();
const TransformDateTime64<Transform> transformer(scale); const TransformDateTime64<Transform> transformer(scale);
DateTimeTransformImpl<DataTypeDateTime64, ToDataType, decltype(transformer)>::execute(columns, arguments, result, input_rows_count, transformer); return DateTimeTransformImpl<DataTypeDateTime64, ToDataType, decltype(transformer)>::execute(arguments, result_type, input_rows_count, transformer);
} }
else else
throw Exception("Illegal type " + columns[arguments[0]].type->getName() + " of argument of function " + getName(), throw Exception("Illegal type " + arguments[0].type->getName() + " of argument of function " + getName(),
ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT); ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT);
} }

4
src/Functions/FunctionFQDN.cpp
View File

@ -34,9 +34,9 @@ public:
return std::make_shared<DataTypeString>(); return std::make_shared<DataTypeString>();
} }
void executeImpl(ColumnsWithTypeAndName & columns, const ColumnNumbers &, size_t result, size_t input_rows_count) const override ColumnPtr executeImpl(ColumnsWithTypeAndName &, const DataTypePtr & result_type, size_t input_rows_count) const override
{ {
columns[result].column = columns[result].type->createColumnConst( return result_type->createColumnConst(
input_rows_count, getFQDNOrHostName())->convertToFullColumnIfConst(); input_rows_count, getFQDNOrHostName())->convertToFullColumnIfConst();
} }
}; };

8
src/Functions/FunctionJoinGet.cpp
View File

@ -17,19 +17,19 @@ namespace ErrorCodes
} }
template <bool or_null> template <bool or_null>
void ExecutableFunctionJoinGet<or_null>::execute(ColumnsWithTypeAndName & columns, const ColumnNumbers & arguments, size_t result, size_t) ColumnPtr ExecutableFunctionJoinGet<or_null>::execute(ColumnsWithTypeAndName & arguments, const DataTypePtr &, size_t)
{ {
ColumnsWithTypeAndName keys; ColumnsWithTypeAndName keys;
for (size_t i = 2; i < arguments.size(); ++i) for (size_t i = 2; i < arguments.size(); ++i)
{ {
auto key = columns[arguments[i]]; auto key = arguments[i];
keys.emplace_back(std::move(key)); keys.emplace_back(std::move(key));
} }
columns[result] = join->joinGet(keys, result_columns); return join->joinGet(keys, result_columns).column;
} }
template <bool or_null> template <bool or_null>
ExecutableFunctionImplPtr FunctionJoinGet<or_null>::prepare(const ColumnsWithTypeAndName &, const ColumnNumbers &, size_t) const ExecutableFunctionImplPtr FunctionJoinGet<or_null>::prepare(const ColumnsWithTypeAndName &) const
{ {
return std::make_unique<ExecutableFunctionJoinGet<or_null>>(join, DB::Block{{return_type->createColumn(), return_type, attr_name}}); return std::make_unique<ExecutableFunctionJoinGet<or_null>>(join, DB::Block{{return_type->createColumn(), return_type, attr_name}});
} }

6
src/Functions/FunctionJoinGet.h
View File

@ -24,7 +24,7 @@ public:
bool useDefaultImplementationForLowCardinalityColumns() const override { return true; } bool useDefaultImplementationForLowCardinalityColumns() const override { return true; }
bool useDefaultImplementationForConstants() const override { return true; } bool useDefaultImplementationForConstants() const override { return true; }
void execute(ColumnsWithTypeAndName & columns, const ColumnNumbers & arguments, size_t result, size_t input_rows_count) override; ColumnPtr execute(ColumnsWithTypeAndName & arguments, const DataTypePtr &, size_t input_rows_count) override;
String getName() const override { return name; } String getName() const override { return name; }
@ -54,9 +54,9 @@ public:
String getName() const override { return name; } String getName() const override { return name; }
const DataTypes & getArgumentTypes() const override { return argument_types; } const DataTypes & getArgumentTypes() const override { return argument_types; }
const DataTypePtr & getReturnType() const override { return return_type; } const DataTypePtr & getResultType() const override { return return_type; }
ExecutableFunctionImplPtr prepare(const ColumnsWithTypeAndName & sample_columns, const ColumnNumbers & arguments, size_t result) const override; ExecutableFunctionImplPtr prepare(const ColumnsWithTypeAndName &) const override;
private: private:
TableLockHolder table_lock; TableLockHolder table_lock;

12
src/Functions/FunctionStartsEndsWith.h
View File

@ -63,10 +63,10 @@ public:
return std::make_shared<DataTypeUInt8>(); return std::make_shared<DataTypeUInt8>();
} }
void executeImpl(ColumnsWithTypeAndName & columns, const ColumnNumbers & arguments, size_t result, size_t input_rows_count) const override ColumnPtr executeImpl(ColumnsWithTypeAndName & arguments, const DataTypePtr &, size_t input_rows_count) const override
{ {
const IColumn * haystack_column = columns[arguments[0]].column.get(); const IColumn * haystack_column = arguments[0].column.get();
const IColumn * needle_column = columns[arguments[1]].column.get(); const IColumn * needle_column = arguments[1].column.get();
auto col_res = ColumnVector<UInt8>::create(); auto col_res = ColumnVector<UInt8>::create();
typename ColumnVector<UInt8>::Container & vec_res = col_res->getData(); typename ColumnVector<UInt8>::Container & vec_res = col_res->getData();
@ -84,7 +84,7 @@ public:
else else
throw Exception("Illegal combination of columns as arguments of function " + getName(), ErrorCodes::ILLEGAL_COLUMN); throw Exception("Illegal combination of columns as arguments of function " + getName(), ErrorCodes::ILLEGAL_COLUMN);
columns[result].column = std::move(col_res); return col_res;
} }
private: private:
@ -159,9 +159,9 @@ public:
#endif #endif
} }
void executeImpl(ColumnsWithTypeAndName & columns, const ColumnNumbers & arguments, size_t result, size_t input_rows_count) const override ColumnPtr executeImpl(ColumnsWithTypeAndName & arguments, const DataTypePtr & result_type, size_t input_rows_count) const override
{ {
selector.selectAndExecute(columns, arguments, result, input_rows_count); return selector.selectAndExecute(arguments, result_type, input_rows_count);
} }
static FunctionPtr create(const Context & context) static FunctionPtr create(const Context & context)

15
src/Functions/FunctionUnixTimestamp64.h
View File

@ -65,13 +65,12 @@ public:
} }
} }
void executeImpl(ColumnsWithTypeAndName & columns, const ColumnNumbers & arguments, size_t result, size_t input_rows_count) const override ColumnPtr executeImpl(ColumnsWithTypeAndName & arguments, const DataTypePtr & result_type, size_t input_rows_count) const override
{ {
using SourceColumnType = typename SourceDataType::ColumnType; using SourceColumnType = typename SourceDataType::ColumnType;
using ResultColumnType = typename ResultDataType::ColumnType; using ResultColumnType = typename ResultDataType::ColumnType;
const auto & src = columns[arguments[0]]; const auto & src = arguments[0];
auto & res = columns[result];
const auto & col = *src.column; const auto & col = *src.column;
const SourceColumnType * source_col_typed = checkAndGetColumn<SourceColumnType>(col); const SourceColumnType * source_col_typed = checkAndGetColumn<SourceColumnType>(col);
@ -80,16 +79,16 @@ public:
+ std::string(SourceDataType::family_name), + std::string(SourceDataType::family_name),
ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT); ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT);
res.column = res.type->createColumn(); auto res_column = result_type->createColumn();
if (input_rows_count == 0) if (input_rows_count == 0)
return; return res_column;
auto & result_data = assert_cast<ResultColumnType &>(res.column->assumeMutableRef()).getData(); auto & result_data = assert_cast<ResultColumnType &>(res_column->assumeMutableRef()).getData();
result_data.reserve(source_col_typed->size()); result_data.reserve(source_col_typed->size());
const auto & source_data = source_col_typed->getData(); const auto & source_data = source_col_typed->getData();
const auto scale_diff = getScaleDiff(*checkAndGetDataType<SourceDataType>(src.type.get()), *checkAndGetDataType<ResultDataType>(res.type.get())); const auto scale_diff = getScaleDiff(*checkAndGetDataType<SourceDataType>(src.type.get()), *checkAndGetDataType<ResultDataType>(result_type.get()));
if (scale_diff == 0) if (scale_diff == 0)
{ {
static_assert(sizeof(typename SourceColumnType::Container::value_type) == sizeof(typename ResultColumnType::Container::value_type)); static_assert(sizeof(typename SourceColumnType::Container::value_type) == sizeof(typename ResultColumnType::Container::value_type));
@ -114,6 +113,8 @@ public:
for (const auto & v : source_data) for (const auto & v : source_data)
result_data.push_back(static_cast<Int64>(toDestValue(v) / scale_multiplier)); result_data.push_back(static_cast<Int64>(toDestValue(v) / scale_multiplier));
} }
return res_column;
} }
private: private:

10
src/Functions/FunctionsStringSearchToString.h
View File

@ -58,10 +58,10 @@ public:
return std::make_shared<DataTypeString>(); return std::make_shared<DataTypeString>();
} }
void executeImpl(ColumnsWithTypeAndName & columns, const ColumnNumbers & arguments, size_t result, size_t /*input_rows_count*/) const override ColumnPtr executeImpl(ColumnsWithTypeAndName & arguments, const DataTypePtr &, size_t /*input_rows_count*/) const override
{ {
const ColumnPtr column = columns[arguments[0]].column; const ColumnPtr column = arguments[0].column;
const ColumnPtr column_needle = columns[arguments[1]].column; const ColumnPtr column_needle = arguments[1].column;
const ColumnConst * col_needle = typeid_cast<const ColumnConst *>(&*column_needle); const ColumnConst * col_needle = typeid_cast<const ColumnConst *>(&*column_needle);
if (!col_needle) if (!col_needle)
@ -75,11 +75,11 @@ public:
ColumnString::Offsets & offsets_res = col_res->getOffsets(); ColumnString::Offsets & offsets_res = col_res->getOffsets();
Impl::vector(col->getChars(), col->getOffsets(), col_needle->getValue<String>(), vec_res, offsets_res); Impl::vector(col->getChars(), col->getOffsets(), col_needle->getValue<String>(), vec_res, offsets_res);
columns[result].column = std::move(col_res); return col_res;
} }
else else
throw Exception( throw Exception(
"Illegal column " + columns[arguments[0]].column->getName() + " of argument of function " + getName(), "Illegal column " + arguments[0].column->getName() + " of argument of function " + getName(),
ErrorCodes::ILLEGAL_COLUMN); ErrorCodes::ILLEGAL_COLUMN);
} }
}; };

9
src/Functions/PerformanceAdaptors.h
View File

@ -204,7 +204,7 @@ public:
* If FunctionInterface is IFunction, then "executeImpl" method of the implementation will be called * If FunctionInterface is IFunction, then "executeImpl" method of the implementation will be called
* and "execute" otherwise. * and "execute" otherwise.
*/ */
void selectAndExecute(ColumnsWithTypeAndName & columns, const ColumnNumbers & arguments, size_t result, size_t input_rows_count) const ColumnPtr selectAndExecute(ColumnsWithTypeAndName & arguments, const DataTypePtr & result_type, size_t input_rows_count) const
{ {
if (implementations.empty()) if (implementations.empty())
throw Exception("There are no available implementations for function " "TODO(dakovalkov): add name", throw Exception("There are no available implementations for function " "TODO(dakovalkov): add name",
@ -212,14 +212,15 @@ public:
/// Statistics shouldn't rely on small columnss. /// Statistics shouldn't rely on small columnss.
bool considerable = (input_rows_count > 1000); bool considerable = (input_rows_count > 1000);
ColumnPtr res;
size_t id = statistics.select(considerable); size_t id = statistics.select(considerable);
Stopwatch watch; Stopwatch watch;
if constexpr (std::is_same_v<FunctionInterface, IFunction>) if constexpr (std::is_same_v<FunctionInterface, IFunction>)
implementations[id]->executeImpl(columns, arguments, result, input_rows_count); res = implementations[id]->executeImpl(arguments, result_type, input_rows_count);
else else
implementations[id]->execute(columns, arguments, result, input_rows_count); res = implementations[id]->execute(arguments, result_type, input_rows_count);
watch.stop(); watch.stop();
@ -228,6 +229,8 @@ public:
// TODO(dakovalkov): Calculate something more informative than rows count. // TODO(dakovalkov): Calculate something more informative than rows count.
statistics.complete(id, watch.elapsedSeconds(), input_rows_count); statistics.complete(id, watch.elapsedSeconds(), input_rows_count);
} }
return res;
} }
/* Register new implementation for function. /* Register new implementation for function.

14
src/Functions/dateDiff.cpp
View File

@ -83,22 +83,22 @@ public:
bool useDefaultImplementationForConstants() const override { return true; } bool useDefaultImplementationForConstants() const override { return true; }
ColumnNumbers getArgumentsThatAreAlwaysConstant() const override { return {0, 3}; } ColumnNumbers getArgumentsThatAreAlwaysConstant() const override { return {0, 3}; }
void executeImpl(ColumnsWithTypeAndName & columns, const ColumnNumbers & arguments, size_t result, size_t input_rows_count) const override ColumnPtr executeImpl(ColumnsWithTypeAndName & arguments, const DataTypePtr &, size_t input_rows_count) const override
{ {
const auto * unit_column = checkAndGetColumnConst<ColumnString>(columns[arguments[0]].column.get()); const auto * unit_column = checkAndGetColumnConst<ColumnString>(arguments[0].column.get());
if (!unit_column) if (!unit_column)
throw Exception("First argument for function " + getName() + " must be constant String", ErrorCodes::ILLEGAL_COLUMN); throw Exception("First argument for function " + getName() + " must be constant String", ErrorCodes::ILLEGAL_COLUMN);
String unit = Poco::toLower(unit_column->getValue<String>()); String unit = Poco::toLower(unit_column->getValue<String>());
const IColumn & x = *columns[arguments[1]].column; const IColumn & x = *arguments[1].column;
const IColumn & y = *columns[arguments[2]].column; const IColumn & y = *arguments[2].column;
size_t rows = input_rows_count; size_t rows = input_rows_count;
auto res = ColumnInt64::create(rows); auto res = ColumnInt64::create(rows);
const DateLUTImpl & timezone_x = extractTimeZoneFromFunctionArguments(columns, arguments, 3, 1); const DateLUTImpl & timezone_x = extractTimeZoneFromFunctionArguments(arguments, 3, 1);
const DateLUTImpl & timezone_y = extractTimeZoneFromFunctionArguments(columns, arguments, 3, 2); const DateLUTImpl & timezone_y = extractTimeZoneFromFunctionArguments(arguments, 3, 2);
if (unit == "year" || unit == "yy" || unit == "yyyy") if (unit == "year" || unit == "yy" || unit == "yyyy")
dispatchForColumns<ToRelativeYearNumImpl>(x, y, timezone_x, timezone_y, res->getData()); dispatchForColumns<ToRelativeYearNumImpl>(x, y, timezone_x, timezone_y, res->getData());
@ -119,7 +119,7 @@ public:
else else
throw Exception("Function " + getName() + " does not support '" + unit + "' unit", ErrorCodes::BAD_ARGUMENTS); throw Exception("Function " + getName() + " does not support '" + unit + "' unit", ErrorCodes::BAD_ARGUMENTS);
columns[result].column = std::move(res); return res;
} }
private: private:

27
src/Functions/date_trunc.cpp
View File

@ -117,33 +117,22 @@ public:
bool useDefaultImplementationForConstants() const override { return true; } bool useDefaultImplementationForConstants() const override { return true; }
ColumnNumbers getArgumentsThatAreAlwaysConstant() const override { return {0, 2}; } ColumnNumbers getArgumentsThatAreAlwaysConstant() const override { return {0, 2}; }
void executeImpl(ColumnsWithTypeAndName & columns, const ColumnNumbers & arguments, size_t result, size_t input_rows_count) const override ColumnPtr executeImpl(ColumnsWithTypeAndName & arguments, const DataTypePtr & result_type, size_t input_rows_count) const override
{ {
ColumnsWithTypeAndName temp_columns = columns; ColumnsWithTypeAndName temp_columns(arguments.size());
temp_columns[0] = arguments[1];
const UInt16 interval_value = 1; const UInt16 interval_value = 1;
const ColumnPtr interval_column = ColumnConst::create(ColumnInt64::create(1, interval_value), input_rows_count); const ColumnPtr interval_column = ColumnConst::create(ColumnInt64::create(1, interval_value), input_rows_count);
temp_columns[1] = {interval_column, std::make_shared<DataTypeInterval>(datepart_kind), ""};
const size_t interval_pos = temp_columns.size(); auto to_start_of_interval = FunctionFactory::instance().get("toStartOfInterval", context);
temp_columns.emplace_back(ColumnWithTypeAndName{interval_column, std::make_shared<DataTypeInterval>(datepart_kind), ""});
if (arguments.size() == 2) if (arguments.size() == 2)
{ return to_start_of_interval->build(temp_columns)->execute(temp_columns, result_type, input_rows_count);
auto to_start_of_interval = FunctionFactory::instance().get("toStartOfInterval", context)->build(
{temp_columns[arguments[1]], temp_columns[interval_pos]});
to_start_of_interval->execute(temp_columns, {arguments[1], interval_pos}, result, input_rows_count); temp_columns[2] = arguments[2];
} return to_start_of_interval->build(temp_columns)->execute(temp_columns, result_type, input_rows_count);
else
{
auto to_start_of_interval = FunctionFactory::instance().get("toStartOfInterval", context)->build(
{temp_columns[arguments[1]], temp_columns[interval_pos],
temp_columns[arguments[2]]});
to_start_of_interval->execute(temp_columns, {arguments[1], interval_pos, arguments[2]}, result, input_rows_count);
}
columns[result].column = std::move(temp_columns[result].column);
} }
bool hasInformationAboutMonotonicity() const override bool hasInformationAboutMonotonicity() const override

6
src/Functions/defaultValueOfArgumentType.cpp
View File

@ -36,10 +36,10 @@ public:
return arguments[0]; return arguments[0];
} }
void executeImpl(ColumnsWithTypeAndName & columns, const ColumnNumbers & arguments, size_t result, size_t input_rows_count) const override ColumnPtr executeImpl(ColumnsWithTypeAndName & arguments, const DataTypePtr &, size_t input_rows_count) const override
{ {
const IDataType & type = *columns[arguments[0]].type; const IDataType & type = *arguments[0].type;
columns[result].column = type.createColumnConst(input_rows_count, type.getDefault()); return type.createColumnConst(input_rows_count, type.getDefault());
} }
ColumnPtr getResultIfAlwaysReturnsConstantAndHasArguments(const ColumnsWithTypeAndName & columns, const ColumnNumbers & arguments) const override ColumnPtr getResultIfAlwaysReturnsConstantAndHasArguments(const ColumnsWithTypeAndName & columns, const ColumnNumbers & arguments) const override

6
src/Functions/defaultValueOfTypeName.cpp
View File

@ -49,10 +49,10 @@ public:
return DataTypeFactory::instance().get(col_type_const->getValue<String>()); return DataTypeFactory::instance().get(col_type_const->getValue<String>());
} }
void executeImpl(ColumnsWithTypeAndName & columns, const ColumnNumbers &, size_t result, size_t input_rows_count) const override ColumnPtr executeImpl(ColumnsWithTypeAndName &, const DataTypePtr & result_type, size_t input_rows_count) const override
{ {
const IDataType & type = *columns[result].type; const IDataType & type = *result_type;
columns[result].column = type.createColumnConst(input_rows_count, type.getDefault()); return type.createColumnConst(input_rows_count, type.getDefault());
} }
}; };

6
src/Functions/demange.cpp
View File

@ -61,9 +61,9 @@ public:
return true; return true;
} }
void executeImpl(ColumnsWithTypeAndName & columns, const ColumnNumbers & arguments, size_t result, size_t input_rows_count) const override ColumnPtr executeImpl(ColumnsWithTypeAndName & arguments, const DataTypePtr &, size_t input_rows_count) const override
{ {
const ColumnPtr & column = columns[arguments[0]].column; const ColumnPtr & column = arguments[0].column;
const ColumnString * column_concrete = checkAndGetColumn<ColumnString>(column.get()); const ColumnString * column_concrete = checkAndGetColumn<ColumnString>(column.get());
if (!column_concrete) if (!column_concrete)
@ -85,7 +85,7 @@ public:
} }
} }
columns[result].column = std::move(result_column); return result_column;
} }
}; };

7
src/Functions/dumpColumnStructure.cpp
View File

@ -36,14 +36,13 @@ public:
return std::make_shared<DataTypeString>(); return std::make_shared<DataTypeString>();
} }
void executeImpl(ColumnsWithTypeAndName & columns, const ColumnNumbers & arguments, size_t result, size_t input_rows_count) const override ColumnPtr executeImpl(ColumnsWithTypeAndName & arguments, const DataTypePtr & result_type, size_t input_rows_count) const override
{ {
const auto & elem = columns[arguments[0]]; const auto & elem = arguments[0];
/// Note that the result is not a constant, because it contains columns size. /// Note that the result is not a constant, because it contains columns size.
columns[result].column return DataTypeString().createColumnConst(input_rows_count,
= DataTypeString().createColumnConst(input_rows_count,
elem.type->getName() + ", " + elem.column->dumpStructure())->convertToFullColumnIfConst(); elem.type->getName() + ", " + elem.column->dumpStructure())->convertToFullColumnIfConst();
} }
}; };

8
src/Functions/evalMLMethod.cpp
View File

@ -62,12 +62,12 @@ public:
return type->getReturnTypeToPredict(); return type->getReturnTypeToPredict();
} }
void executeImpl(ColumnsWithTypeAndName & columns, const ColumnNumbers & arguments, size_t result, size_t /*input_rows_count*/) const override ColumnPtr executeImpl(ColumnsWithTypeAndName & arguments, const DataTypePtr &, size_t /*input_rows_count*/) const override
{ {
if (arguments.empty()) if (arguments.empty())
throw Exception("Function " + getName() + " requires at least one argument", ErrorCodes::BAD_ARGUMENTS); throw Exception("Function " + getName() + " requires at least one argument", ErrorCodes::BAD_ARGUMENTS);
const auto * model = columns[arguments[0]].column.get(); const auto * model = arguments[0].column.get();
if (const auto * column_with_states = typeid_cast<const ColumnConst *>(model)) if (const auto * column_with_states = typeid_cast<const ColumnConst *>(model))
model = column_with_states->getDataColumnPtr().get(); model = column_with_states->getDataColumnPtr().get();
@ -75,10 +75,10 @@ public:
const auto * agg_function = typeid_cast<const ColumnAggregateFunction *>(model); const auto * agg_function = typeid_cast<const ColumnAggregateFunction *>(model);
if (!agg_function) if (!agg_function)
throw Exception("Illegal column " + columns[arguments[0]].column->getName() throw Exception("Illegal column " + arguments[0].column->getName()
+ " of first argument of function " + getName(), ErrorCodes::ILLEGAL_COLUMN); + " of first argument of function " + getName(), ErrorCodes::ILLEGAL_COLUMN);
columns[result].column = agg_function->predictValues(columns, arguments, context); return agg_function->predictValues(arguments, context);
} }
const Context & context; const Context & context;

8
src/Functions/extractAllGroups.h
View File

@ -70,12 +70,12 @@ public:
return std::make_shared<DataTypeArray>(std::make_shared<DataTypeArray>(std::make_shared<DataTypeString>())); return std::make_shared<DataTypeArray>(std::make_shared<DataTypeArray>(std::make_shared<DataTypeString>()));
} }
void executeImpl(ColumnsWithTypeAndName & columns, const ColumnNumbers & arguments, size_t result, size_t input_rows_count) const override ColumnPtr executeImpl(ColumnsWithTypeAndName & arguments, const DataTypePtr & result_type, size_t input_rows_count) const override
{ {
static const auto MAX_GROUPS_COUNT = 128; static const auto MAX_GROUPS_COUNT = 128;
const ColumnPtr column_haystack = columns[arguments[0]].column; const ColumnPtr column_haystack = arguments[0].column;
const ColumnPtr column_needle = columns[arguments[1]].column; const ColumnPtr column_needle = arguments[1].column;
const auto needle = typeid_cast<const ColumnConst &>(*column_needle).getValue<String>(); const auto needle = typeid_cast<const ColumnConst &>(*column_needle).getValue<String>();
@ -234,7 +234,7 @@ public:
ColumnArray::MutablePtr nested_array_col = ColumnArray::create(std::move(data_col), std::move(nested_offsets_col)); ColumnArray::MutablePtr nested_array_col = ColumnArray::create(std::move(data_col), std::move(nested_offsets_col));
ColumnArray::MutablePtr root_array_col = ColumnArray::create(std::move(nested_array_col), std::move(root_offsets_col)); ColumnArray::MutablePtr root_array_col = ColumnArray::create(std::move(nested_array_col), std::move(root_offsets_col));
columns[result].column = std::move(root_array_col); return root_array_col;
} }
}; };

8
src/Functions/extractGroups.cpp
View File

@ -51,10 +51,10 @@ public:
return std::make_shared<DataTypeArray>(std::make_shared<DataTypeString>()); return std::make_shared<DataTypeArray>(std::make_shared<DataTypeString>());
} }
void executeImpl(ColumnsWithTypeAndName & columns, const ColumnNumbers & arguments, size_t result, size_t input_rows_count) const override ColumnPtr executeImpl(ColumnsWithTypeAndName & arguments, const DataTypePtr &, size_t input_rows_count) const override
{ {
const ColumnPtr column_haystack = columns[arguments[0]].column; const ColumnPtr column_haystack = arguments[0].column;
const ColumnPtr column_needle = columns[arguments[1]].column; const ColumnPtr column_needle = arguments[1].column;
const auto needle = typeid_cast<const ColumnConst &>(*column_needle).getValue<String>(); const auto needle = typeid_cast<const ColumnConst &>(*column_needle).getValue<String>();
@ -100,7 +100,7 @@ public:
offsets_data[i] = current_offset; offsets_data[i] = current_offset;
} }
columns[result].column = ColumnArray::create(std::move(data_col), std::move(offsets_col)); return ColumnArray::create(std::move(data_col), std::move(offsets_col));
} }
}; };

4
src/Functions/filesystem.cpp
View File

@ -50,9 +50,9 @@ public:
return std::make_shared<DataTypeUInt64>(); return std::make_shared<DataTypeUInt64>();
} }
void executeImpl(ColumnsWithTypeAndName & columns, const ColumnNumbers &, size_t result, size_t input_rows_count) const override ColumnPtr executeImpl(ColumnsWithTypeAndName &, const DataTypePtr &, size_t input_rows_count) const override
{ {
columns[result].column = DataTypeUInt64().createColumnConst(input_rows_count, static_cast<UInt64>(Impl::get(spaceinfo))); return DataTypeUInt64().createColumnConst(input_rows_count, static_cast<UInt64>(Impl::get(spaceinfo)));
} }
private: private:

8
src/Functions/finalizeAggregation.cpp
View File

@ -54,18 +54,18 @@ public:
return type->getReturnType(); return type->getReturnType();
} }
void executeImpl(ColumnsWithTypeAndName & columns, const ColumnNumbers & arguments, size_t result, size_t /*input_rows_count*/) const override ColumnPtr executeImpl(ColumnsWithTypeAndName & arguments, const DataTypePtr &, size_t /*input_rows_count*/) const override
{ {
auto column = columns[arguments.at(0)].column; auto column = arguments.at(0).column;
if (!typeid_cast<const ColumnAggregateFunction *>(column.get())) if (!typeid_cast<const ColumnAggregateFunction *>(column.get()))
throw Exception("Illegal column " + columns[arguments.at(0)].column->getName() throw Exception("Illegal column " + arguments.at(0).column->getName()
+ " of first argument of function " + " of first argument of function "
+ getName(), + getName(),
ErrorCodes::ILLEGAL_COLUMN); ErrorCodes::ILLEGAL_COLUMN);
/// Column is copied here, because there is no guarantee that we own it. /// Column is copied here, because there is no guarantee that we own it.
auto mut_column = IColumn::mutate(std::move(column)); auto mut_column = IColumn::mutate(std::move(column));
columns[result].column = ColumnAggregateFunction::convertToValues(std::move(mut_column)); return ColumnAggregateFunction::convertToValues(std::move(mut_column));
} }
}; };

50
src/Functions/formatDateTime.cpp
View File

@ -340,42 +340,44 @@ public:
return std::make_shared<DataTypeString>(); return std::make_shared<DataTypeString>();
} }
void executeImpl(ColumnsWithTypeAndName & columns, const ColumnNumbers & arguments, size_t result, [[maybe_unused]] size_t input_rows_count) const override ColumnPtr executeImpl(ColumnsWithTypeAndName & arguments, const DataTypePtr & result_type, [[maybe_unused]] size_t input_rows_count) const override
{ {
ColumnPtr res;
if constexpr (support_integer) if constexpr (support_integer)
{ {
if (arguments.size() == 1) if (arguments.size() == 1)
{ {
if (!castType(columns[arguments[0]].type.get(), [&](const auto & type) if (!castType(arguments[0].type.get(), [&](const auto & type)
{ {
using FromDataType = std::decay_t<decltype(type)>; using FromDataType = std::decay_t<decltype(type)>;
ConvertImpl<FromDataType, DataTypeDateTime, Name>::execute(columns, arguments, result, input_rows_count); res = ConvertImpl<FromDataType, DataTypeDateTime, Name>::execute(arguments, result_type, input_rows_count);
return true; return true;
})) }))
{ {
throw Exception( throw Exception(
"Illegal column " + columns[arguments[0]].column->getName() + " of function " + getName() "Illegal column " + arguments[0].column->getName() + " of function " + getName()
+ ", must be Integer or DateTime when arguments size is 1.", + ", must be Integer or DateTime when arguments size is 1.",
ErrorCodes::ILLEGAL_COLUMN); ErrorCodes::ILLEGAL_COLUMN);
} }
} }
else else
{ {
if (!castType(columns[arguments[0]].type.get(), [&](const auto & type) if (!castType(arguments[0].type.get(), [&](const auto & type)
{ {
using FromDataType = std::decay_t<decltype(type)>; using FromDataType = std::decay_t<decltype(type)>;
if (!executeType<FromDataType>(columns, arguments, result)) if (!(res = executeType<FromDataType>(arguments, result_type)))
throw Exception( throw Exception(
"Illegal column " + columns[arguments[0]].column->getName() + " of function " + getName() "Illegal column " + arguments[0].column->getName() + " of function " + getName()
+ ", must be Integer or DateTime.", + ", must be Integer or DateTime.",
ErrorCodes::ILLEGAL_COLUMN); ErrorCodes::ILLEGAL_COLUMN);
return true; return true;
})) }))
{ {
if (!executeType<DataTypeDate>(columns, arguments, result) && !executeType<DataTypeDateTime>(columns, arguments, result) if ( !((res = executeType<DataTypeDate>(arguments, result_type))
&& !executeType<DataTypeDateTime64>(columns, arguments, result)) || (res = executeType<DataTypeDateTime>(arguments, result_type)
|| (res = executeType<DataTypeDateTime64>(arguments, result_type)))))
throw Exception( throw Exception(
"Illegal column " + columns[arguments[0]].column->getName() + " of function " + getName() "Illegal column " + arguments[0].column->getName() + " of function " + getName()
+ ", must be Integer or DateTime.", + ", must be Integer or DateTime.",
ErrorCodes::ILLEGAL_COLUMN); ErrorCodes::ILLEGAL_COLUMN);
} }
@ -383,25 +385,28 @@ public:
} }
else else
{ {
if (!executeType<DataTypeDate>(columns, arguments, result) && !executeType<DataTypeDateTime>(columns, arguments, result) if ( !((res = executeType<DataTypeDate>(arguments, result_type)
&& !executeType<DataTypeDateTime64>(columns, arguments, result)) || (res = executeType<DataTypeDateTime>(arguments, result_type)
|| (res = executeType<DataTypeDateTime64>(arguments, result_type))))))
throw Exception( throw Exception(
"Illegal column " + columns[arguments[0]].column->getName() + " of function " + getName() "Illegal column " + arguments[0].column->getName() + " of function " + getName()
+ ", must be Date or DateTime.", + ", must be Date or DateTime.",
ErrorCodes::ILLEGAL_COLUMN); ErrorCodes::ILLEGAL_COLUMN);
} }
return res;
} }
template <typename DataType> template <typename DataType>
bool executeType(ColumnsWithTypeAndName & columns, const ColumnNumbers & arguments, size_t result) const ColumnPtr executeType(ColumnsWithTypeAndName & arguments, const DataTypePtr &) const
{ {
auto * times = checkAndGetColumn<typename DataType::ColumnType>(columns[arguments[0]].column.get()); auto * times = checkAndGetColumn<typename DataType::ColumnType>(arguments[0].column.get());
if (!times) if (!times)
return false; return nullptr;
const ColumnConst * pattern_column = checkAndGetColumnConst<ColumnString>(columns[arguments[1]].column.get()); const ColumnConst * pattern_column = checkAndGetColumnConst<ColumnString>(arguments[1].column.get());
if (!pattern_column) if (!pattern_column)
throw Exception("Illegal column " + columns[arguments[1]].column->getName() throw Exception("Illegal column " + arguments[1].column->getName()
+ " of second ('format') argument of function " + getName() + " of second ('format') argument of function " + getName()
+ ". Must be constant string.", + ". Must be constant string.",
ErrorCodes::ILLEGAL_COLUMN); ErrorCodes::ILLEGAL_COLUMN);
@ -414,12 +419,12 @@ public:
size_t result_size = pattern_to_fill.size(); size_t result_size = pattern_to_fill.size();
const DateLUTImpl * time_zone_tmp = nullptr; const DateLUTImpl * time_zone_tmp = nullptr;
if (castType(columns[arguments[0]].type.get(), [&]([[maybe_unused]] const auto & type) { return true; })) if (castType(arguments[0].type.get(), [&]([[maybe_unused]] const auto & type) { return true; }))
{ {
time_zone_tmp = &extractTimeZoneFromFunctionArguments(columns, arguments, 2, 0); time_zone_tmp = &extractTimeZoneFromFunctionArguments(arguments, 2, 0);
} }
else if (std::is_same_v<DataType, DataTypeDateTime64> || std::is_same_v<DataType, DataTypeDateTime>) else if (std::is_same_v<DataType, DataTypeDateTime64> || std::is_same_v<DataType, DataTypeDateTime>)
time_zone_tmp = &extractTimeZoneFromFunctionArguments(columns, arguments, 2, 0); time_zone_tmp = &extractTimeZoneFromFunctionArguments( arguments, 2, 0);
else else
time_zone_tmp = &DateLUT::instance(); time_zone_tmp = &DateLUT::instance();
@ -485,8 +490,7 @@ public:
} }
dst_data.resize(pos - begin); dst_data.resize(pos - begin);
columns[result].column = std::move(col_res); return col_res;
return true;
} }
template <typename T> template <typename T>

36
src/Functions/formatReadable.h
View File

@ -49,28 +49,31 @@ public:
bool useDefaultImplementationForConstants() const override { return true; } bool useDefaultImplementationForConstants() const override { return true; }
void executeImpl(ColumnsWithTypeAndName & columns, const ColumnNumbers & arguments, size_t result, size_t /*input_rows_count*/) const override ColumnPtr executeImpl(ColumnsWithTypeAndName & arguments, const DataTypePtr &, size_t /*input_rows_count*/) const override
{ {
if (!(executeType<UInt8>(columns, arguments, result) ColumnPtr res;
|| executeType<UInt16>(columns, arguments, result) if ( !((res = executeType<UInt8>(arguments))
|| executeType<UInt32>(columns, arguments, result) || (res = executeType<UInt16>(arguments))
|| executeType<UInt64>(columns, arguments, result) || (res = executeType<UInt32>(arguments))
|| executeType<Int8>(columns, arguments, result) || (res = executeType<UInt64>(arguments))
|| executeType<Int16>(columns, arguments, result) || (res = executeType<Int8>(arguments))
|| executeType<Int32>(columns, arguments, result) || (res = executeType<Int16>(arguments))
|| executeType<Int64>(columns, arguments, result) || (res = executeType<Int32>(arguments))
|| executeType<Float32>(columns, arguments, result) || (res = executeType<Int64>(arguments))
|| executeType<Float64>(columns, arguments, result))) || (res = executeType<Float32>(arguments))
throw Exception("Illegal column " + columns[arguments[0]].column->getName() || (res = executeType<Float64>(arguments))))
throw Exception("Illegal column " + arguments[0].column->getName()
+ " of argument of function " + getName(), + " of argument of function " + getName(),
ErrorCodes::ILLEGAL_COLUMN); ErrorCodes::ILLEGAL_COLUMN);
return res;
} }
private: private:
template <typename T> template <typename T>
bool executeType(ColumnsWithTypeAndName & columns, const ColumnNumbers & arguments, size_t result) const ColumnPtr executeType(ColumnsWithTypeAndName & arguments) const
{ {
if (const ColumnVector<T> * col_from = checkAndGetColumn<ColumnVector<T>>(columns[arguments[0]].column.get())) if (const ColumnVector<T> * col_from = checkAndGetColumn<ColumnVector<T>>(arguments[0].column.get()))
{ {
auto col_to = ColumnString::create(); auto col_to = ColumnString::create();
@ -91,11 +94,10 @@ private:
} }
buf_to.finalize(); buf_to.finalize();
columns[result].column = std::move(col_to); return col_to;
return true;
} }
return false; return nullptr;
} }
}; };

8
src/Functions/formatReadableTimeDelta.cpp
View File

@ -89,12 +89,12 @@ public:
Years Years
}; };
void executeImpl(ColumnsWithTypeAndName & columns, const ColumnNumbers & arguments, size_t result, size_t input_rows_count) const override ColumnPtr executeImpl(ColumnsWithTypeAndName & arguments, const DataTypePtr &, size_t input_rows_count) const override
{ {
StringRef maximum_unit_str; StringRef maximum_unit_str;
if (arguments.size() == 2) if (arguments.size() == 2)
{ {
const ColumnPtr & maximum_unit_column = columns[arguments[1]].column; const ColumnPtr & maximum_unit_column = arguments[1].column;
const ColumnConst * maximum_unit_const_col = checkAndGetColumnConstStringOrFixedString(maximum_unit_column.get()); const ColumnConst * maximum_unit_const_col = checkAndGetColumnConstStringOrFixedString(maximum_unit_column.get());
if (maximum_unit_const_col) if (maximum_unit_const_col)
maximum_unit_str = maximum_unit_const_col->getDataColumn().getDataAt(0); maximum_unit_str = maximum_unit_const_col->getDataColumn().getDataAt(0);
@ -132,7 +132,7 @@ public:
for (size_t i = 0; i < input_rows_count; ++i) for (size_t i = 0; i < input_rows_count; ++i)
{ {
/// Virtual call is Ok (neglible comparing to the rest of calculations). /// Virtual call is Ok (neglible comparing to the rest of calculations).
Float64 value = columns[arguments[0]].column->getFloat64(i); Float64 value = arguments[0].column->getFloat64(i);
bool is_negative = value < 0; bool is_negative = value < 0;
if (is_negative) if (is_negative)
@ -159,7 +159,7 @@ public:
} }
buf_to.finalize(); buf_to.finalize();
columns[result].column = std::move(col_to); return col_to;
} }
static void processUnit( static void processUnit(

8
src/Functions/formatRow.cpp
View File

@ -47,16 +47,16 @@ public:
bool useDefaultImplementationForConstants() const override { return true; } bool useDefaultImplementationForConstants() const override { return true; }
ColumnNumbers getArgumentsThatAreAlwaysConstant() const override { return {0}; } ColumnNumbers getArgumentsThatAreAlwaysConstant() const override { return {0}; }
void executeImpl(ColumnsWithTypeAndName & columns, const ColumnNumbers & arguments, size_t result, size_t input_rows_count) const override ColumnPtr executeImpl(ColumnsWithTypeAndName & arguments, const DataTypePtr &, size_t input_rows_count) const override
{ {
auto col_str = ColumnString::create(); auto col_str = ColumnString::create();
ColumnString::Chars & vec = col_str->getChars(); ColumnString::Chars & vec = col_str->getChars();
WriteBufferFromVector buffer(vec); WriteBufferFromVector buffer(vec);
ColumnString::Offsets & offsets = col_str->getOffsets(); ColumnString::Offsets & offsets = col_str->getOffsets();
offsets.resize(input_rows_count); offsets.resize(input_rows_count);
DB::Block arg_columns; Block arg_columns;
for (auto i = 1u; i < arguments.size(); ++i) for (auto i = 1u; i < arguments.size(); ++i)
arg_columns.insert(columns[arguments[i]]); arg_columns.insert(arguments[i]);
materializeBlockInplace(arg_columns); materializeBlockInplace(arg_columns);
auto out = FormatFactory::instance().getOutputFormat(format_name, buffer, arg_columns, context, [&](const Columns &, size_t row) auto out = FormatFactory::instance().getOutputFormat(format_name, buffer, arg_columns, context, [&](const Columns &, size_t row)
{ {
@ -71,7 +71,7 @@ public:
offsets[row] = buffer.count(); offsets[row] = buffer.count();
}); });
out->write(arg_columns); out->write(arg_columns);
columns[result].column = std::move(col_str); return col_str;
} }
private: private:

8
src/Functions/formatString.cpp
View File

@ -67,9 +67,9 @@ public:
return std::make_shared<DataTypeString>(); return std::make_shared<DataTypeString>();
} }
void executeImpl(ColumnsWithTypeAndName & columns, const ColumnNumbers & arguments, size_t result, size_t input_rows_count) const override ColumnPtr executeImpl(ColumnsWithTypeAndName & arguments, const DataTypePtr &, size_t input_rows_count) const override
{ {
const ColumnPtr & c0 = columns[arguments[0]].column; const ColumnPtr & c0 = arguments[0].column;
const ColumnConst * c0_const_string = typeid_cast<const ColumnConst *>(&*c0); const ColumnConst * c0_const_string = typeid_cast<const ColumnConst *>(&*c0);
if (!c0_const_string) if (!c0_const_string)
@ -88,7 +88,7 @@ public:
bool has_column_fixed_string = false; bool has_column_fixed_string = false;
for (size_t i = 1; i < arguments.size(); ++i) for (size_t i = 1; i < arguments.size(); ++i)
{ {
const ColumnPtr & column = columns[arguments[i]].column; const ColumnPtr & column = arguments[i].column;
if (const ColumnString * col = checkAndGetColumn<ColumnString>(column.get())) if (const ColumnString * col = checkAndGetColumn<ColumnString>(column.get()))
{ {
has_column_string = true; has_column_string = true;
@ -122,7 +122,7 @@ public:
col_res->getOffsets(), col_res->getOffsets(),
input_rows_count); input_rows_count);
columns[result].column = std::move(col_res); return col_res;
} }
}; };