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(
ColumnVector<Float64>::Container & container,
ColumnsWithTypeAndName & columns,
ColumnsWithTypeAndName & arguments,
size_t offset,
size_t limit,
const ColumnNumbers & arguments,
const std::vector<Float64> & weights,
Float64 bias,
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)
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)
{
const ColumnWithTypeAndName & cur_col = columns[arguments[i]];
const ColumnWithTypeAndName & cur_col = arguments[i];
if (!isNativeNumber(cur_col.type))
throw Exception("Prediction arguments must have numeric type", ErrorCodes::BAD_ARGUMENTS);
@ -518,10 +517,9 @@ void LogisticRegression::compute(
void LinearRegression::predict(
ColumnVector<Float64>::Container & container,
ColumnsWithTypeAndName & columns,
ColumnsWithTypeAndName & arguments,
size_t offset,
size_t limit,
const ColumnNumbers & arguments,
const std::vector<Float64> & weights,
Float64 bias,
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);
}
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)
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)
{
const ColumnWithTypeAndName & cur_col = columns[arguments[i]];
const ColumnWithTypeAndName & cur_col = arguments[i];
if (!isNativeNumber(cur_col.type))
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(
ColumnVector<Float64>::Container & container,
ColumnsWithTypeAndName & columns,
ColumnsWithTypeAndName & arguments,
size_t offset,
size_t limit,
const ColumnNumbers & arguments,
const std::vector<Float64> & weights,
Float64 bias,
const Context & context) const = 0;
@ -65,10 +64,9 @@ public:
void predict(
ColumnVector<Float64>::Container & container,
ColumnsWithTypeAndName & columns,
ColumnsWithTypeAndName & arguments,
size_t offset,
size_t limit,
const ColumnNumbers & arguments,
const std::vector<Float64> & weights,
Float64 bias,
const Context & context) const override;
@ -91,10 +89,9 @@ public:
void predict(
ColumnVector<Float64>::Container & container,
ColumnsWithTypeAndName & columns,
ColumnsWithTypeAndName & arguments,
size_t offset,
size_t limit,
const ColumnNumbers & arguments,
const std::vector<Float64> & weights,
Float64 bias,
const Context & context) const override;
@ -364,10 +361,9 @@ public:
void predictValues(
ConstAggregateDataPtr place,
IColumn & to,
ColumnsWithTypeAndName & columns,
ColumnsWithTypeAndName & arguments,
size_t offset,
size_t limit,
const ColumnNumbers & arguments,
const Context & context) const override
{
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",
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.

3
src/AggregateFunctions/IAggregateFunction.h
View File

@ -114,10 +114,9 @@ public:
virtual void predictValues(
ConstAggregateDataPtr /* place */,
IColumn & /*to*/,
ColumnsWithTypeAndName & /*block*/,
ColumnsWithTypeAndName & /*arguments*/,
size_t /*offset*/,
size_t /*limit*/,
const ColumnNumbers & /*arguments*/,
const Context & /*context*/) const
{
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;
}
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();
res->reserve(data.size());
@ -172,7 +172,7 @@ MutableColumnPtr ColumnAggregateFunction::predictValues(ColumnsWithTypeAndName &
if (data.size() == 1)
{
/// 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
{
@ -180,7 +180,7 @@ MutableColumnPtr ColumnAggregateFunction::predictValues(ColumnsWithTypeAndName &
size_t row_num = 0;
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;
}
}

2
src/Columns/ColumnAggregateFunction.h
View File

@ -119,7 +119,7 @@ public:
const char * getFamilyName() const override { return "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
{

18
src/Functions/FunctionCustomWeekToSomething.h
View File

@ -96,26 +96,26 @@ public:
bool useDefaultImplementationForConstants() const override { return true; }
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);
if (which.isDate())
CustomWeekTransformImpl<DataTypeDate, ToDataType>::execute(
columns, arguments, result, input_rows_count, Transform{});
return CustomWeekTransformImpl<DataTypeDate, ToDataType>::execute(
arguments, result_type, input_rows_count, Transform{});
else if (which.isDateTime())
CustomWeekTransformImpl<DataTypeDateTime, ToDataType>::execute(
columns, arguments, result, input_rows_count, Transform{});
return CustomWeekTransformImpl<DataTypeDateTime, ToDataType>::execute(
arguments, result_type, input_rows_count, Transform{});
else if (which.isDateTime64())
{
CustomWeekTransformImpl<DataTypeDateTime64, ToDataType>::execute(
columns, arguments, result, input_rows_count,
return CustomWeekTransformImpl<DataTypeDateTime64, ToDataType>::execute(
arguments, result_type, input_rows_count,
TransformDateTime64<Transform>{assert_cast<const DataTypeDateTime64 *>(from_type)->getScale()});
}
else
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);
}

12
src/Functions/FunctionDateOrDateTimeToSomething.h
View File

@ -95,23 +95,23 @@ public:
bool useDefaultImplementationForConstants() const override { return true; }
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);
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())
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())
{
const auto scale = static_cast<const DataTypeDateTime64 *>(from_type)->getScale();
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
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);
}

4
src/Functions/FunctionFQDN.cpp
View File

@ -34,9 +34,9 @@ public:
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();
}
};

8
src/Functions/FunctionJoinGet.cpp
View File

@ -17,19 +17,19 @@ namespace ErrorCodes
}
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;
for (size_t i = 2; i < arguments.size(); ++i)
{
auto key = columns[arguments[i]];
auto key = arguments[i];
keys.emplace_back(std::move(key));
}
columns[result] = join->joinGet(keys, result_columns);
return join->joinGet(keys, result_columns).column;
}
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}});
}

6
src/Functions/FunctionJoinGet.h
View File

@ -24,7 +24,7 @@ public:
bool useDefaultImplementationForLowCardinalityColumns() 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; }
@ -54,9 +54,9 @@ public:
String getName() const override { return name; }
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:
TableLockHolder table_lock;

12
src/Functions/FunctionStartsEndsWith.h
View File

@ -63,10 +63,10 @@ public:
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 * needle_column = columns[arguments[1]].column.get();
const IColumn * haystack_column = arguments[0].column.get();
const IColumn * needle_column = arguments[1].column.get();
auto col_res = ColumnVector<UInt8>::create();
typename ColumnVector<UInt8>::Container & vec_res = col_res->getData();
@ -84,7 +84,7 @@ public:
else
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:
@ -159,9 +159,9 @@ public:
#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)

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 ResultColumnType = typename ResultDataType::ColumnType;
const auto & src = columns[arguments[0]];
auto & res = columns[result];
const auto & src = arguments[0];
const auto & col = *src.column;
const SourceColumnType * source_col_typed = checkAndGetColumn<SourceColumnType>(col);
@ -80,16 +79,16 @@ public:
+ std::string(SourceDataType::family_name),
ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT);
res.column = res.type->createColumn();
auto res_column = result_type->createColumn();
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());
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)
{
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)
result_data.push_back(static_cast<Int64>(toDestValue(v) / scale_multiplier));
}
return res_column;
}
private:

10
src/Functions/FunctionsStringSearchToString.h
View File

@ -58,10 +58,10 @@ public:
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_needle = columns[arguments[1]].column;
const ColumnPtr column = arguments[0].column;
const ColumnPtr column_needle = arguments[1].column;
const ColumnConst * col_needle = typeid_cast<const ColumnConst *>(&*column_needle);
if (!col_needle)
@ -75,11 +75,11 @@ public:
ColumnString::Offsets & offsets_res = col_res->getOffsets();
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
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);
}
};

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
* 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())
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.
bool considerable = (input_rows_count > 1000);
ColumnPtr res;
size_t id = statistics.select(considerable);
Stopwatch watch;
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
implementations[id]->execute(columns, arguments, result, input_rows_count);
res = implementations[id]->execute(arguments, result_type, input_rows_count);
watch.stop();
@ -228,6 +229,8 @@ public:
// TODO(dakovalkov): Calculate something more informative than rows count.
statistics.complete(id, watch.elapsedSeconds(), input_rows_count);
}
return res;
}
/* Register new implementation for function.

14
src/Functions/dateDiff.cpp
View File

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

27
src/Functions/date_trunc.cpp
View File

@ -117,33 +117,22 @@ public:
bool useDefaultImplementationForConstants() const override { return true; }
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 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();
temp_columns.emplace_back(ColumnWithTypeAndName{interval_column, std::make_shared<DataTypeInterval>(datepart_kind), ""});
auto to_start_of_interval = FunctionFactory::instance().get("toStartOfInterval", context);
if (arguments.size() == 2)
{
auto to_start_of_interval = FunctionFactory::instance().get("toStartOfInterval", context)->build(
{temp_columns[arguments[1]], temp_columns[interval_pos]});
return to_start_of_interval->build(temp_columns)->execute(temp_columns, result_type, input_rows_count);
to_start_of_interval->execute(temp_columns, {arguments[1], interval_pos}, result, 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);
temp_columns[2] = arguments[2];
return to_start_of_interval->build(temp_columns)->execute(temp_columns, result_type, input_rows_count);
}
bool hasInformationAboutMonotonicity() const override

6
src/Functions/defaultValueOfArgumentType.cpp
View File

@ -36,10 +36,10 @@ public:
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;
columns[result].column = type.createColumnConst(input_rows_count, type.getDefault());
const IDataType & type = *arguments[0].type;
return type.createColumnConst(input_rows_count, type.getDefault());
}
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>());
}
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;
columns[result].column = type.createColumnConst(input_rows_count, type.getDefault());
const IDataType & type = *result_type;
return type.createColumnConst(input_rows_count, type.getDefault());
}
};

6
src/Functions/demange.cpp
View File

@ -61,9 +61,9 @@ public:
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());
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>();
}
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.
columns[result].column
= DataTypeString().createColumnConst(input_rows_count,
return DataTypeString().createColumnConst(input_rows_count,
elem.type->getName() + ", " + elem.column->dumpStructure())->convertToFullColumnIfConst();
}
};

8
src/Functions/evalMLMethod.cpp
View File

@ -62,12 +62,12 @@ public:
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())
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))
model = column_with_states->getDataColumnPtr().get();
@ -75,10 +75,10 @@ public:
const auto * agg_function = typeid_cast<const ColumnAggregateFunction *>(model);
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);
columns[result].column = agg_function->predictValues(columns, arguments, context);
return agg_function->predictValues(arguments, 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>()));
}
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;
const ColumnPtr column_haystack = columns[arguments[0]].column;
const ColumnPtr column_needle = columns[arguments[1]].column;
const ColumnPtr column_haystack = arguments[0].column;
const ColumnPtr column_needle = arguments[1].column;
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 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>());
}
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_needle = columns[arguments[1]].column;
const ColumnPtr column_haystack = arguments[0].column;
const ColumnPtr column_needle = arguments[1].column;
const auto needle = typeid_cast<const ColumnConst &>(*column_needle).getValue<String>();
@ -100,7 +100,7 @@ public:
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>();
}
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:

8
src/Functions/finalizeAggregation.cpp
View File

@ -54,18 +54,18 @@ public:
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()))
throw Exception("Illegal column " + columns[arguments.at(0)].column->getName()
throw Exception("Illegal column " + arguments.at(0).column->getName()
+ " of first argument of function "
+ getName(),
ErrorCodes::ILLEGAL_COLUMN);
/// Column is copied here, because there is no guarantee that we own it.
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>();
}
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 (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)>;
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;
}))
{
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.",
ErrorCodes::ILLEGAL_COLUMN);
}
}
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)>;
if (!executeType<FromDataType>(columns, arguments, result))
if (!(res = executeType<FromDataType>(arguments, result_type)))
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.",
ErrorCodes::ILLEGAL_COLUMN);
return true;
}))
{
if (!executeType<DataTypeDate>(columns, arguments, result) && !executeType<DataTypeDateTime>(columns, arguments, result)
&& !executeType<DataTypeDateTime64>(columns, arguments, result))
if ( !((res = executeType<DataTypeDate>(arguments, result_type))
|| (res = executeType<DataTypeDateTime>(arguments, result_type)
|| (res = executeType<DataTypeDateTime64>(arguments, result_type)))))
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.",
ErrorCodes::ILLEGAL_COLUMN);
}
@ -383,25 +385,28 @@ public:
}
else
{
if (!executeType<DataTypeDate>(columns, arguments, result) && !executeType<DataTypeDateTime>(columns, arguments, result)
&& !executeType<DataTypeDateTime64>(columns, arguments, result))
if ( !((res = executeType<DataTypeDate>(arguments, result_type)
|| (res = executeType<DataTypeDateTime>(arguments, result_type)
|| (res = executeType<DataTypeDateTime64>(arguments, result_type))))))
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.",
ErrorCodes::ILLEGAL_COLUMN);
}
return res;
}
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)
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)
throw Exception("Illegal column " + columns[arguments[1]].column->getName()
throw Exception("Illegal column " + arguments[1].column->getName()
+ " of second ('format') argument of function " + getName()
+ ". Must be constant string.",
ErrorCodes::ILLEGAL_COLUMN);
@ -414,12 +419,12 @@ public:
size_t result_size = pattern_to_fill.size();
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>)
time_zone_tmp = &extractTimeZoneFromFunctionArguments(columns, arguments, 2, 0);
time_zone_tmp = &extractTimeZoneFromFunctionArguments( arguments, 2, 0);
else
time_zone_tmp = &DateLUT::instance();
@ -485,8 +490,7 @@ public:
}
dst_data.resize(pos - begin);
columns[result].column = std::move(col_res);
return true;
return col_res;
}
template <typename T>

36
src/Functions/formatReadable.h
View File

@ -49,28 +49,31 @@ public:
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)
|| executeType<UInt16>(columns, arguments, result)
|| executeType<UInt32>(columns, arguments, result)
|| executeType<UInt64>(columns, arguments, result)
|| executeType<Int8>(columns, arguments, result)
|| executeType<Int16>(columns, arguments, result)
|| executeType<Int32>(columns, arguments, result)
|| executeType<Int64>(columns, arguments, result)
|| executeType<Float32>(columns, arguments, result)
|| executeType<Float64>(columns, arguments, result)))
throw Exception("Illegal column " + columns[arguments[0]].column->getName()
ColumnPtr res;
if ( !((res = executeType<UInt8>(arguments))
|| (res = executeType<UInt16>(arguments))
|| (res = executeType<UInt32>(arguments))
|| (res = executeType<UInt64>(arguments))
|| (res = executeType<Int8>(arguments))
|| (res = executeType<Int16>(arguments))
|| (res = executeType<Int32>(arguments))
|| (res = executeType<Int64>(arguments))
|| (res = executeType<Float32>(arguments))
|| (res = executeType<Float64>(arguments))))
throw Exception("Illegal column " + arguments[0].column->getName()
+ " of argument of function " + getName(),
ErrorCodes::ILLEGAL_COLUMN);
return res;
}
private:
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();
@ -91,11 +94,10 @@ private:
}
buf_to.finalize();
columns[result].column = std::move(col_to);
return true;
return col_to;
}
return false;
return nullptr;
}
};

8
src/Functions/formatReadableTimeDelta.cpp
View File

@ -89,12 +89,12 @@ public:
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;
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());
if (maximum_unit_const_col)
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)
{
/// 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;
if (is_negative)
@ -159,7 +159,7 @@ public:
}
buf_to.finalize();
columns[result].column = std::move(col_to);
return col_to;
}
static void processUnit(

8
src/Functions/formatRow.cpp
View File

@ -47,16 +47,16 @@ public:
bool useDefaultImplementationForConstants() const override { return true; }
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();
ColumnString::Chars & vec = col_str->getChars();
WriteBufferFromVector buffer(vec);
ColumnString::Offsets & offsets = col_str->getOffsets();
offsets.resize(input_rows_count);
DB::Block arg_columns;
Block arg_columns;
for (auto i = 1u; i < arguments.size(); ++i)
arg_columns.insert(columns[arguments[i]]);
arg_columns.insert(arguments[i]);
materializeBlockInplace(arg_columns);
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();
});
out->write(arg_columns);
columns[result].column = std::move(col_str);
return col_str;
}
private:

8
src/Functions/formatString.cpp
View File

@ -67,9 +67,9 @@ public:
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);
if (!c0_const_string)
@ -88,7 +88,7 @@ public:
bool has_column_fixed_string = false;
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()))
{
has_column_string = true;
@ -122,7 +122,7 @@ public:
col_res->getOffsets(),
input_rows_count);
columns[result].column = std::move(col_res);
return col_res;
}
};