2012-08-26 06:48:39 +00:00
|
|
|
|
#pragma once
|
|
|
|
|
|
2015-10-12 07:05:54 +00:00
|
|
|
|
#include <DB/Core/FieldVisitors.h>
|
|
|
|
|
|
2012-08-26 06:48:39 +00:00
|
|
|
|
#include <DB/DataTypes/DataTypeArray.h>
|
2012-11-02 19:10:43 +00:00
|
|
|
|
#include <DB/DataTypes/DataTypesNumberFixed.h>
|
2014-10-28 13:43:22 +00:00
|
|
|
|
#include <DB/DataTypes/DataTypeDate.h>
|
|
|
|
|
#include <DB/DataTypes/DataTypeDateTime.h>
|
|
|
|
|
#include <DB/DataTypes/DataTypeString.h>
|
|
|
|
|
|
2012-08-26 06:48:39 +00:00
|
|
|
|
#include <DB/Columns/ColumnArray.h>
|
2012-11-02 19:10:43 +00:00
|
|
|
|
#include <DB/Columns/ColumnString.h>
|
2015-02-01 08:19:11 +00:00
|
|
|
|
#include <DB/Columns/ColumnTuple.h>
|
2012-11-02 19:10:43 +00:00
|
|
|
|
|
2012-08-26 06:48:39 +00:00
|
|
|
|
#include <DB/Functions/IFunction.h>
|
2016-08-04 15:06:27 +00:00
|
|
|
|
#include <DB/Functions/Conditional/CondException.h>
|
2014-04-28 01:48:24 +00:00
|
|
|
|
#include <DB/Common/HashTable/HashMap.h>
|
|
|
|
|
#include <DB/Common/HashTable/ClearableHashMap.h>
|
2016-07-14 05:22:09 +00:00
|
|
|
|
#include <DB/Common/StringUtils.h>
|
2013-10-24 12:53:24 +00:00
|
|
|
|
#include <DB/Interpreters/AggregationCommon.h>
|
2014-04-10 17:28:06 +00:00
|
|
|
|
#include <DB/Functions/FunctionsConditional.h>
|
2016-07-09 06:33:44 +00:00
|
|
|
|
#include <DB/Functions/FunctionsConversion.h>
|
2016-05-03 23:19:14 +00:00
|
|
|
|
#include <DB/Functions/Conditional/getArrayType.h>
|
2015-12-13 10:43:49 +00:00
|
|
|
|
#include <DB/AggregateFunctions/IAggregateFunction.h>
|
|
|
|
|
#include <DB/AggregateFunctions/AggregateFunctionFactory.h>
|
|
|
|
|
#include <DB/Parsers/ExpressionListParsers.h>
|
|
|
|
|
#include <DB/Parsers/parseQuery.h>
|
|
|
|
|
#include <DB/Parsers/ASTExpressionList.h>
|
|
|
|
|
#include <DB/Parsers/ASTLiteral.h>
|
2012-08-26 06:48:39 +00:00
|
|
|
|
|
2015-10-05 00:33:43 +00:00
|
|
|
|
#include <ext/range.hpp>
|
2014-12-02 12:42:20 +00:00
|
|
|
|
|
2014-01-08 16:33:28 +00:00
|
|
|
|
#include <unordered_map>
|
2016-05-23 00:40:28 +00:00
|
|
|
|
#include <numeric>
|
2013-10-11 11:43:50 +00:00
|
|
|
|
|
2012-08-26 06:48:39 +00:00
|
|
|
|
|
|
|
|
|
namespace DB
|
|
|
|
|
{
|
|
|
|
|
|
2016-01-11 21:46:36 +00:00
|
|
|
|
namespace ErrorCodes
|
|
|
|
|
{
|
|
|
|
|
extern const int ZERO_ARRAY_OR_TUPLE_INDEX;
|
|
|
|
|
extern const int SIZES_OF_ARRAYS_DOESNT_MATCH;
|
|
|
|
|
extern const int PARAMETERS_TO_AGGREGATE_FUNCTIONS_MUST_BE_LITERALS;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2012-08-26 06:48:39 +00:00
|
|
|
|
/** Функции по работе с массивами:
|
|
|
|
|
*
|
|
|
|
|
* array(с1, с2, ...) - создать массив из констант.
|
2014-01-29 01:59:01 +00:00
|
|
|
|
* arrayElement(arr, i) - получить элемент массива по индексу.
|
|
|
|
|
* Индекс начинается с 1. Также индекс может быть отрицательным - тогда он считается с конца массива.
|
2012-11-02 19:10:43 +00:00
|
|
|
|
* has(arr, x) - есть ли в массиве элемент x.
|
2012-12-15 20:01:46 +00:00
|
|
|
|
* indexOf(arr, x) - возвращает индекс элемента x (начиная с 1), если он есть в массиве, или 0, если его нет.
|
2013-10-21 11:36:44 +00:00
|
|
|
|
* arrayEnumerate(arr) - возаращает массив [1,2,3,..., length(arr)]
|
2015-07-23 11:11:10 +00:00
|
|
|
|
*
|
|
|
|
|
* arrayUniq(arr) - считает количество разных элементов в массиве,
|
|
|
|
|
* arrayUniq(arr1, arr2, ...) - считает количество разных кортежей из элементов на соответствующих позициях в нескольких массивах.
|
|
|
|
|
*
|
|
|
|
|
* arrayEnumerateUniq(arr)
|
|
|
|
|
* - возаращает массив, параллельный данному, где для каждого элемента указано,
|
|
|
|
|
* какой он по счету среди элементов с таким значением.
|
|
|
|
|
* Например: arrayEnumerateUniq([10, 20, 10, 30]) = [1, 1, 2, 1]
|
|
|
|
|
* arrayEnumerateUniq(arr1, arr2...)
|
|
|
|
|
* - для кортежей из элементов на соответствующих позициях в нескольких массивах.
|
2015-07-26 10:40:32 +00:00
|
|
|
|
*
|
|
|
|
|
* emptyArrayToSingle(arr) - заменить пустые массивы на массивы из одного элемента со значением "по-умолчанию".
|
2015-12-13 10:43:49 +00:00
|
|
|
|
*
|
|
|
|
|
* arrayReduce('agg', arr1, ...) - применить агрегатную функцию agg к массивам arr1...
|
2012-08-26 06:48:39 +00:00
|
|
|
|
*/
|
|
|
|
|
|
2014-04-10 17:28:06 +00:00
|
|
|
|
|
2012-08-26 06:48:39 +00:00
|
|
|
|
class FunctionArray : public IFunction
|
|
|
|
|
{
|
2014-11-12 17:23:26 +00:00
|
|
|
|
public:
|
|
|
|
|
static constexpr auto name = "array";
|
2016-08-11 16:47:28 +00:00
|
|
|
|
static FunctionPtr create(const Context & context);
|
2016-07-09 06:33:44 +00:00
|
|
|
|
|
2016-08-11 16:47:28 +00:00
|
|
|
|
FunctionArray(const Context & context);
|
2014-11-12 17:23:26 +00:00
|
|
|
|
|
2016-08-11 16:47:28 +00:00
|
|
|
|
void setCaseMode();
|
2015-09-08 09:38:35 +00:00
|
|
|
|
|
2016-08-11 16:47:28 +00:00
|
|
|
|
/// Получить тип результата по типам аргументов. Если функция неприменима для данных аргументов - кинуть исключение.
|
|
|
|
|
DataTypePtr getReturnTypeImpl(const DataTypes & arguments) const override;
|
2014-04-17 14:37:59 +00:00
|
|
|
|
|
2016-08-11 16:47:28 +00:00
|
|
|
|
/// Выполнить функцию над блоком.
|
|
|
|
|
void executeImpl(Block & block, const ColumnNumbers & arguments, size_t result) override;
|
2014-04-17 14:37:59 +00:00
|
|
|
|
|
2016-08-11 16:47:28 +00:00
|
|
|
|
private:
|
|
|
|
|
/// Получить имя функции.
|
|
|
|
|
String getName() const override;
|
2014-04-17 14:37:59 +00:00
|
|
|
|
|
2016-08-11 16:47:28 +00:00
|
|
|
|
bool addField(DataTypePtr type_res, const Field & f, Array & arr) const;
|
|
|
|
|
static const DataTypePtr & getScalarType(const DataTypePtr & type);
|
|
|
|
|
DataTypeTraits::EnrichedDataTypePtr getLeastCommonType(const DataTypes & arguments) const;
|
2014-04-17 14:37:59 +00:00
|
|
|
|
|
2016-08-11 16:47:28 +00:00
|
|
|
|
private:
|
|
|
|
|
const Context & context;
|
|
|
|
|
bool is_case_mode = false;
|
|
|
|
|
};
|
2014-04-17 14:37:59 +00:00
|
|
|
|
|
2015-02-01 08:19:11 +00:00
|
|
|
|
|
|
|
|
|
|
2016-08-11 16:47:28 +00:00
|
|
|
|
class FunctionArrayElement : public IFunction
|
|
|
|
|
{
|
|
|
|
|
public:
|
|
|
|
|
static constexpr auto name = "arrayElement";
|
|
|
|
|
static FunctionPtr create(const Context & context);
|
2015-02-01 08:19:11 +00:00
|
|
|
|
|
2016-08-11 16:47:28 +00:00
|
|
|
|
/// Получить имя функции.
|
|
|
|
|
String getName() const override;
|
2015-02-01 08:19:11 +00:00
|
|
|
|
|
2016-08-11 16:47:28 +00:00
|
|
|
|
/// Получить типы результата по типам аргументов. Если функция неприменима для данных аргументов - кинуть исключение.
|
|
|
|
|
DataTypePtr getReturnTypeImpl(const DataTypes & arguments) const override;
|
2015-02-01 08:19:11 +00:00
|
|
|
|
|
2016-08-11 16:47:28 +00:00
|
|
|
|
/// Выполнить функцию над блоком.
|
|
|
|
|
void executeImpl(Block & block, const ColumnNumbers & arguments, size_t result) override;
|
2015-02-01 08:19:11 +00:00
|
|
|
|
|
2016-08-11 16:47:28 +00:00
|
|
|
|
private:
|
|
|
|
|
template <typename DataType>
|
|
|
|
|
bool executeNumberConst(Block & block, const ColumnNumbers & arguments, size_t result, const Field & index);
|
2015-02-01 08:19:11 +00:00
|
|
|
|
|
2016-08-11 16:47:28 +00:00
|
|
|
|
template <typename IndexType, typename DataType>
|
|
|
|
|
bool executeNumber(Block & block, const ColumnNumbers & arguments, size_t result, const PaddedPODArray<IndexType> & indices);
|
2015-02-01 08:19:11 +00:00
|
|
|
|
|
2016-08-11 16:47:28 +00:00
|
|
|
|
bool executeStringConst(Block & block, const ColumnNumbers & arguments, size_t result, const Field & index);
|
2015-02-01 08:19:11 +00:00
|
|
|
|
|
2016-08-11 16:47:28 +00:00
|
|
|
|
template <typename IndexType>
|
|
|
|
|
bool executeString(Block & block, const ColumnNumbers & arguments, size_t result, const PaddedPODArray<IndexType> & indices);
|
2015-02-01 08:19:11 +00:00
|
|
|
|
|
2016-08-11 16:47:28 +00:00
|
|
|
|
bool executeGenericConst(Block & block, const ColumnNumbers & arguments, size_t result, const Field & index);
|
2012-11-02 19:10:43 +00:00
|
|
|
|
|
2016-08-11 16:47:28 +00:00
|
|
|
|
template <typename IndexType>
|
|
|
|
|
bool executeGeneric(Block & block, const ColumnNumbers & arguments, size_t result, const PaddedPODArray<IndexType> & indices);
|
2012-11-02 19:10:43 +00:00
|
|
|
|
|
2016-08-11 16:47:28 +00:00
|
|
|
|
bool executeConstConst(Block & block, const ColumnNumbers & arguments, size_t result, const Field & index);
|
2012-11-02 19:10:43 +00:00
|
|
|
|
|
2016-08-11 16:47:28 +00:00
|
|
|
|
template <typename IndexType>
|
|
|
|
|
bool executeConst(Block & block, const ColumnNumbers & arguments, size_t result, const PaddedPODArray<IndexType> & indices);
|
2012-11-02 19:10:43 +00:00
|
|
|
|
|
2016-08-11 16:47:28 +00:00
|
|
|
|
template <typename IndexType>
|
|
|
|
|
bool executeArgument(Block & block, const ColumnNumbers & arguments, size_t result);
|
2012-11-02 19:10:43 +00:00
|
|
|
|
|
2016-08-11 16:47:28 +00:00
|
|
|
|
/** Для массива кортежей функция вычисляется покомпонентно - для каждого элемента кортежа.
|
|
|
|
|
*/
|
|
|
|
|
bool executeTuple(Block & block, const ColumnNumbers & arguments, size_t result);
|
2012-11-02 19:10:43 +00:00
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
2016-07-09 04:39:57 +00:00
|
|
|
|
/// For has.
|
2012-12-15 20:01:46 +00:00
|
|
|
|
struct IndexToOne
|
|
|
|
|
{
|
2016-05-28 10:35:44 +00:00
|
|
|
|
using ResultType = UInt8;
|
2015-09-18 12:40:42 +00:00
|
|
|
|
static bool apply(size_t j, ResultType & current) { current = 1; return false; }
|
2012-12-15 20:01:46 +00:00
|
|
|
|
};
|
|
|
|
|
|
2016-07-09 04:39:57 +00:00
|
|
|
|
/// For indexOf.
|
2012-12-15 20:01:46 +00:00
|
|
|
|
struct IndexIdentity
|
|
|
|
|
{
|
2016-05-28 10:35:44 +00:00
|
|
|
|
using ResultType = UInt64;
|
2012-12-15 20:01:46 +00:00
|
|
|
|
/// Индекс возвращается начиная с единицы.
|
2015-09-18 12:40:42 +00:00
|
|
|
|
static bool apply(size_t j, ResultType & current) { current = j + 1; return false; }
|
2012-12-26 15:40:37 +00:00
|
|
|
|
};
|
|
|
|
|
|
2016-07-09 04:39:57 +00:00
|
|
|
|
/// For countEqual.
|
2012-12-26 15:40:37 +00:00
|
|
|
|
struct IndexCount
|
|
|
|
|
{
|
2016-05-28 10:35:44 +00:00
|
|
|
|
using ResultType = UInt32;
|
2015-09-18 12:40:42 +00:00
|
|
|
|
static bool apply(size_t j, ResultType & current) { ++current; return true; }
|
2012-12-15 20:01:46 +00:00
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
2015-10-12 07:05:54 +00:00
|
|
|
|
template <typename T, typename U, typename IndexConv>
|
2012-12-15 20:01:46 +00:00
|
|
|
|
struct ArrayIndexNumImpl
|
|
|
|
|
{
|
2015-10-12 07:05:54 +00:00
|
|
|
|
#pragma GCC diagnostic push
|
|
|
|
|
#pragma GCC diagnostic ignored "-Wsign-compare"
|
|
|
|
|
|
2015-09-18 12:40:42 +00:00
|
|
|
|
/// compares `lhs` against `i`-th element of `rhs`
|
2016-04-15 00:33:21 +00:00
|
|
|
|
static bool compare(const T & lhs, const PaddedPODArray<U> & rhs, const std::size_t i ) { return lhs == rhs[i]; }
|
2015-09-18 12:40:42 +00:00
|
|
|
|
/// compares `lhs against `rhs`, third argument unused
|
2015-10-12 07:05:54 +00:00
|
|
|
|
static bool compare(const T & lhs, const U & rhs, std::size_t) { return lhs == rhs; }
|
|
|
|
|
|
|
|
|
|
#pragma GCC diagnostic pop
|
2015-09-18 12:40:42 +00:00
|
|
|
|
|
|
|
|
|
template <typename ScalarOrVector>
|
2012-12-15 20:01:46 +00:00
|
|
|
|
static void vector(
|
2016-04-15 00:33:21 +00:00
|
|
|
|
const PaddedPODArray<T> & data, const ColumnArray::Offsets_t & offsets,
|
2015-09-18 12:40:42 +00:00
|
|
|
|
const ScalarOrVector & value,
|
2016-04-15 00:33:21 +00:00
|
|
|
|
PaddedPODArray<typename IndexConv::ResultType> & result)
|
2012-12-15 20:01:46 +00:00
|
|
|
|
{
|
|
|
|
|
size_t size = offsets.size();
|
|
|
|
|
result.resize(size);
|
|
|
|
|
|
|
|
|
|
ColumnArray::Offset_t current_offset = 0;
|
|
|
|
|
for (size_t i = 0; i < size; ++i)
|
|
|
|
|
{
|
|
|
|
|
size_t array_size = offsets[i] - current_offset;
|
2012-12-26 15:40:37 +00:00
|
|
|
|
typename IndexConv::ResultType current = 0;
|
2014-06-26 00:58:14 +00:00
|
|
|
|
|
2012-12-15 20:01:46 +00:00
|
|
|
|
for (size_t j = 0; j < array_size; ++j)
|
2015-09-18 12:40:42 +00:00
|
|
|
|
if (compare(data[current_offset + j], value, i))
|
2012-12-26 15:40:37 +00:00
|
|
|
|
if (!IndexConv::apply(j, current))
|
|
|
|
|
break;
|
2014-06-26 00:58:14 +00:00
|
|
|
|
|
2012-12-26 15:40:37 +00:00
|
|
|
|
result[i] = current;
|
2012-12-15 20:01:46 +00:00
|
|
|
|
current_offset = offsets[i];
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
template <typename IndexConv>
|
|
|
|
|
struct ArrayIndexStringImpl
|
|
|
|
|
{
|
2015-09-18 12:40:42 +00:00
|
|
|
|
static void vector_const(
|
2013-09-15 05:51:43 +00:00
|
|
|
|
const ColumnString::Chars_t & data, const ColumnArray::Offsets_t & offsets, const ColumnString::Offsets_t & string_offsets,
|
2012-12-15 20:01:46 +00:00
|
|
|
|
const String & value,
|
2016-04-15 00:33:21 +00:00
|
|
|
|
PaddedPODArray<typename IndexConv::ResultType> & result)
|
2012-12-15 20:01:46 +00:00
|
|
|
|
{
|
2015-09-18 12:40:42 +00:00
|
|
|
|
const auto size = offsets.size();
|
|
|
|
|
const auto value_size = value.size();
|
2012-12-15 20:01:46 +00:00
|
|
|
|
result.resize(size);
|
|
|
|
|
|
|
|
|
|
ColumnArray::Offset_t current_offset = 0;
|
|
|
|
|
for (size_t i = 0; i < size; ++i)
|
|
|
|
|
{
|
2015-09-18 12:40:42 +00:00
|
|
|
|
const auto array_size = offsets[i] - current_offset;
|
2012-12-26 15:40:37 +00:00
|
|
|
|
typename IndexConv::ResultType current = 0;
|
2012-12-15 20:01:46 +00:00
|
|
|
|
|
|
|
|
|
for (size_t j = 0; j < array_size; ++j)
|
|
|
|
|
{
|
|
|
|
|
ColumnArray::Offset_t string_pos = current_offset == 0 && j == 0
|
|
|
|
|
? 0
|
|
|
|
|
: string_offsets[current_offset + j - 1];
|
|
|
|
|
|
|
|
|
|
ColumnArray::Offset_t string_size = string_offsets[current_offset + j] - string_pos;
|
|
|
|
|
|
|
|
|
|
if (string_size == value_size + 1 && 0 == memcmp(value.data(), &data[string_pos], value_size))
|
|
|
|
|
{
|
2012-12-26 15:40:37 +00:00
|
|
|
|
if (!IndexConv::apply(j, current))
|
|
|
|
|
break;
|
2012-12-15 20:01:46 +00:00
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2012-12-26 15:40:37 +00:00
|
|
|
|
result[i] = current;
|
2012-12-15 20:01:46 +00:00
|
|
|
|
current_offset = offsets[i];
|
|
|
|
|
}
|
|
|
|
|
}
|
2015-09-18 12:40:42 +00:00
|
|
|
|
|
|
|
|
|
static void vector_vector(
|
|
|
|
|
const ColumnString::Chars_t & data, const ColumnArray::Offsets_t & offsets, const ColumnString::Offsets_t & string_offsets,
|
|
|
|
|
const ColumnString::Chars_t & item_values, const ColumnString::Offsets_t & item_offsets,
|
2016-04-15 00:33:21 +00:00
|
|
|
|
PaddedPODArray<typename IndexConv::ResultType> & result)
|
2015-09-18 12:40:42 +00:00
|
|
|
|
{
|
|
|
|
|
const auto size = offsets.size();
|
|
|
|
|
result.resize(size);
|
|
|
|
|
|
|
|
|
|
ColumnArray::Offset_t current_offset = 0;
|
|
|
|
|
for (size_t i = 0; i < size; ++i)
|
|
|
|
|
{
|
|
|
|
|
const auto array_size = offsets[i] - current_offset;
|
|
|
|
|
typename IndexConv::ResultType current = 0;
|
|
|
|
|
const auto value_pos = 0 == i ? 0 : item_offsets[i - 1];
|
|
|
|
|
const auto value_size = item_offsets[i] - value_pos;
|
|
|
|
|
|
|
|
|
|
for (size_t j = 0; j < array_size; ++j)
|
|
|
|
|
{
|
|
|
|
|
ColumnArray::Offset_t string_pos = current_offset == 0 && j == 0
|
|
|
|
|
? 0
|
|
|
|
|
: string_offsets[current_offset + j - 1];
|
|
|
|
|
|
|
|
|
|
ColumnArray::Offset_t string_size = string_offsets[current_offset + j] - string_pos;
|
|
|
|
|
|
|
|
|
|
if (string_size == value_size && 0 == memcmp(&item_values[value_pos], &data[string_pos], value_size))
|
|
|
|
|
{
|
|
|
|
|
if (!IndexConv::apply(j, current))
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
result[i] = current;
|
|
|
|
|
current_offset = offsets[i];
|
|
|
|
|
}
|
|
|
|
|
}
|
2012-12-15 20:01:46 +00:00
|
|
|
|
};
|
|
|
|
|
|
2016-07-09 04:39:57 +00:00
|
|
|
|
/** Catch-all implementation for arrays of arbitary type.
|
|
|
|
|
*/
|
|
|
|
|
template <typename IndexConv, bool is_value_has_single_element_to_compare>
|
|
|
|
|
struct ArrayIndexGenericImpl
|
|
|
|
|
{
|
|
|
|
|
/** To compare with constant value, create non-constant column with single element,
|
|
|
|
|
* and pass is_value_has_single_element_to_compare = true.
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
static void vector(
|
|
|
|
|
const IColumn & data, const ColumnArray::Offsets_t & offsets,
|
|
|
|
|
const IColumn & value,
|
|
|
|
|
PaddedPODArray<typename IndexConv::ResultType> & result)
|
|
|
|
|
{
|
|
|
|
|
size_t size = offsets.size();
|
|
|
|
|
result.resize(size);
|
|
|
|
|
|
|
|
|
|
ColumnArray::Offset_t current_offset = 0;
|
|
|
|
|
for (size_t i = 0; i < size; ++i)
|
|
|
|
|
{
|
|
|
|
|
size_t array_size = offsets[i] - current_offset;
|
|
|
|
|
typename IndexConv::ResultType current = 0;
|
|
|
|
|
|
|
|
|
|
for (size_t j = 0; j < array_size; ++j)
|
|
|
|
|
if (0 == data.compareAt(current_offset + j, is_value_has_single_element_to_compare ? 0 : i, value, 1))
|
|
|
|
|
if (!IndexConv::apply(j, current))
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
result[i] = current;
|
|
|
|
|
current_offset = offsets[i];
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
};
|
|
|
|
|
|
2012-12-15 20:01:46 +00:00
|
|
|
|
|
|
|
|
|
template <typename IndexConv, typename Name>
|
|
|
|
|
class FunctionArrayIndex : public IFunction
|
2012-11-02 19:10:43 +00:00
|
|
|
|
{
|
2014-11-12 17:23:26 +00:00
|
|
|
|
public:
|
|
|
|
|
static constexpr auto name = Name::name;
|
2016-05-28 15:42:22 +00:00
|
|
|
|
static FunctionPtr create(const Context & context) { return std::make_shared<FunctionArrayIndex>(); }
|
2014-11-12 17:23:26 +00:00
|
|
|
|
|
2012-11-02 19:10:43 +00:00
|
|
|
|
private:
|
2016-05-28 10:35:44 +00:00
|
|
|
|
using ResultColumnType = ColumnVector<typename IndexConv::ResultType>;
|
2014-06-26 00:58:14 +00:00
|
|
|
|
|
2012-11-02 19:10:43 +00:00
|
|
|
|
template <typename T>
|
2015-09-18 12:40:42 +00:00
|
|
|
|
bool executeNumber(Block & block, const ColumnNumbers & arguments, size_t result)
|
2015-10-12 07:05:54 +00:00
|
|
|
|
{
|
|
|
|
|
return executeNumberNumber<T, UInt8>(block, arguments, result)
|
|
|
|
|
|| executeNumberNumber<T, UInt16>(block, arguments, result)
|
|
|
|
|
|| executeNumberNumber<T, UInt32>(block, arguments, result)
|
|
|
|
|
|| executeNumberNumber<T, UInt64>(block, arguments, result)
|
|
|
|
|
|| executeNumberNumber<T, Int8>(block, arguments, result)
|
|
|
|
|
|| executeNumberNumber<T, Int16>(block, arguments, result)
|
|
|
|
|
|| executeNumberNumber<T, Int32>(block, arguments, result)
|
|
|
|
|
|| executeNumberNumber<T, Int64>(block, arguments, result)
|
|
|
|
|
|| executeNumberNumber<T, Float32>(block, arguments, result)
|
|
|
|
|
|| executeNumberNumber<T, Float64>(block, arguments, result);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
template <typename T, typename U>
|
|
|
|
|
bool executeNumberNumber(Block & block, const ColumnNumbers & arguments, size_t result)
|
2012-11-02 19:10:43 +00:00
|
|
|
|
{
|
2016-07-08 04:16:30 +00:00
|
|
|
|
const ColumnArray * col_array = typeid_cast<const ColumnArray *>(block.getByPosition(arguments[0]).column.get());
|
2012-11-02 19:10:43 +00:00
|
|
|
|
|
|
|
|
|
if (!col_array)
|
|
|
|
|
return false;
|
|
|
|
|
|
2014-06-26 00:58:14 +00:00
|
|
|
|
const ColumnVector<T> * col_nested = typeid_cast<const ColumnVector<T> *>(&col_array->getData());
|
2012-11-02 19:10:43 +00:00
|
|
|
|
|
|
|
|
|
if (!col_nested)
|
|
|
|
|
return false;
|
|
|
|
|
|
2015-09-18 12:40:42 +00:00
|
|
|
|
const auto item_arg = block.getByPosition(arguments[1]).column.get();
|
|
|
|
|
|
2015-10-12 07:05:54 +00:00
|
|
|
|
if (const auto item_arg_const = typeid_cast<const ColumnConst<U> *>(item_arg))
|
2015-09-18 12:40:42 +00:00
|
|
|
|
{
|
2016-05-28 05:31:36 +00:00
|
|
|
|
const auto col_res = std::make_shared<ResultColumnType>();
|
2016-05-30 21:41:41 +00:00
|
|
|
|
block.getByPosition(result).column = col_res;
|
2015-09-18 12:40:42 +00:00
|
|
|
|
|
2015-10-12 07:05:54 +00:00
|
|
|
|
ArrayIndexNumImpl<T, U, IndexConv>::vector(col_nested->getData(), col_array->getOffsets(),
|
2015-09-18 12:40:42 +00:00
|
|
|
|
item_arg_const->getData(), col_res->getData());
|
|
|
|
|
}
|
2015-10-12 07:05:54 +00:00
|
|
|
|
else if (const auto item_arg_vector = typeid_cast<const ColumnVector<U> *>(item_arg))
|
2015-09-18 12:40:42 +00:00
|
|
|
|
{
|
2016-05-28 05:31:36 +00:00
|
|
|
|
const auto col_res = std::make_shared<ResultColumnType>();
|
2016-05-30 21:41:41 +00:00
|
|
|
|
block.getByPosition(result).column = col_res;
|
2012-11-02 19:10:43 +00:00
|
|
|
|
|
2015-10-12 07:05:54 +00:00
|
|
|
|
ArrayIndexNumImpl<T, U, IndexConv>::vector(col_nested->getData(), col_array->getOffsets(),
|
2015-09-18 12:40:42 +00:00
|
|
|
|
item_arg_vector->getData(), col_res->getData());
|
|
|
|
|
}
|
2015-10-12 07:05:54 +00:00
|
|
|
|
else
|
|
|
|
|
return false;
|
2012-11-02 19:10:43 +00:00
|
|
|
|
|
|
|
|
|
return true;
|
|
|
|
|
}
|
|
|
|
|
|
2015-09-18 12:40:42 +00:00
|
|
|
|
bool executeString(Block & block, const ColumnNumbers & arguments, size_t result)
|
2012-11-02 19:10:43 +00:00
|
|
|
|
{
|
2016-07-08 04:16:30 +00:00
|
|
|
|
const ColumnArray * col_array = typeid_cast<const ColumnArray *>(block.getByPosition(arguments[0]).column.get());
|
2012-11-02 19:10:43 +00:00
|
|
|
|
|
|
|
|
|
if (!col_array)
|
|
|
|
|
return false;
|
|
|
|
|
|
2014-06-26 00:58:14 +00:00
|
|
|
|
const ColumnString * col_nested = typeid_cast<const ColumnString *>(&col_array->getData());
|
2012-11-02 19:10:43 +00:00
|
|
|
|
|
|
|
|
|
if (!col_nested)
|
|
|
|
|
return false;
|
|
|
|
|
|
2015-09-18 12:40:42 +00:00
|
|
|
|
const auto item_arg = block.getByPosition(arguments[1]).column.get();
|
2012-11-02 19:10:43 +00:00
|
|
|
|
|
2015-09-18 12:40:42 +00:00
|
|
|
|
if (const auto item_arg_const = typeid_cast<const ColumnConst<String> *>(item_arg))
|
|
|
|
|
{
|
2016-05-28 05:31:36 +00:00
|
|
|
|
const auto col_res = std::make_shared<ResultColumnType>();
|
2016-05-30 21:41:41 +00:00
|
|
|
|
block.getByPosition(result).column = col_res;
|
2015-09-18 12:40:42 +00:00
|
|
|
|
|
|
|
|
|
ArrayIndexStringImpl<IndexConv>::vector_const(col_nested->getChars(), col_array->getOffsets(),
|
|
|
|
|
col_nested->getOffsets(), item_arg_const->getData(), col_res->getData());
|
|
|
|
|
}
|
|
|
|
|
else if (const auto item_arg_vector = typeid_cast<const ColumnString *>(item_arg))
|
|
|
|
|
{
|
2016-05-28 05:31:36 +00:00
|
|
|
|
const auto col_res = std::make_shared<ResultColumnType>();
|
2016-05-30 21:41:41 +00:00
|
|
|
|
block.getByPosition(result).column = col_res;
|
2015-09-18 12:40:42 +00:00
|
|
|
|
|
|
|
|
|
ArrayIndexStringImpl<IndexConv>::vector_vector(col_nested->getChars(), col_array->getOffsets(),
|
|
|
|
|
col_nested->getOffsets(), item_arg_vector->getChars(), item_arg_vector->getOffsets(),
|
|
|
|
|
col_res->getData());
|
|
|
|
|
}
|
2016-07-09 04:39:57 +00:00
|
|
|
|
else
|
|
|
|
|
return false;
|
2012-11-02 19:10:43 +00:00
|
|
|
|
|
|
|
|
|
return true;
|
|
|
|
|
}
|
|
|
|
|
|
2015-09-18 12:40:42 +00:00
|
|
|
|
bool executeConst(Block & block, const ColumnNumbers & arguments, size_t result)
|
2012-11-02 19:10:43 +00:00
|
|
|
|
{
|
2016-07-08 04:16:30 +00:00
|
|
|
|
const ColumnConstArray * col_array = typeid_cast<const ColumnConstArray *>(block.getByPosition(arguments[0]).column.get());
|
2012-11-02 19:10:43 +00:00
|
|
|
|
|
|
|
|
|
if (!col_array)
|
|
|
|
|
return false;
|
|
|
|
|
|
|
|
|
|
const Array & arr = col_array->getData();
|
|
|
|
|
|
2015-09-18 12:40:42 +00:00
|
|
|
|
const auto item_arg = block.getByPosition(arguments[1]).column.get();
|
|
|
|
|
if (item_arg->isConst())
|
2012-12-26 15:40:37 +00:00
|
|
|
|
{
|
2016-05-30 23:42:07 +00:00
|
|
|
|
typename IndexConv::ResultType current = 0;
|
2015-09-18 12:40:42 +00:00
|
|
|
|
const auto & value = (*item_arg)[0];
|
|
|
|
|
|
|
|
|
|
for (size_t i = 0, size = arr.size(); i < size; ++i)
|
2012-12-26 15:40:37 +00:00
|
|
|
|
{
|
2015-10-12 07:05:54 +00:00
|
|
|
|
if (apply_visitor(FieldVisitorAccurateEquals(), arr[i], value))
|
2015-09-18 12:40:42 +00:00
|
|
|
|
{
|
|
|
|
|
if (!IndexConv::apply(i, current))
|
|
|
|
|
break;
|
|
|
|
|
}
|
2012-12-26 15:40:37 +00:00
|
|
|
|
}
|
2015-09-18 12:40:42 +00:00
|
|
|
|
|
|
|
|
|
block.getByPosition(result).column = block.getByPosition(result).type->createConstColumn(
|
|
|
|
|
item_arg->size(),
|
|
|
|
|
static_cast<typename NearestFieldType<typename IndexConv::ResultType>::Type>(current));
|
2012-12-26 15:40:37 +00:00
|
|
|
|
}
|
2015-09-18 12:40:42 +00:00
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
const auto size = item_arg->size();
|
2016-05-28 05:31:36 +00:00
|
|
|
|
const auto col_res = std::make_shared<ResultColumnType>(size);
|
|
|
|
|
block.getByPosition(result).column = col_res;
|
2012-11-02 19:10:43 +00:00
|
|
|
|
|
2015-09-18 12:40:42 +00:00
|
|
|
|
auto & data = col_res->getData();
|
|
|
|
|
|
|
|
|
|
for (size_t row = 0; row < size; ++row)
|
|
|
|
|
{
|
|
|
|
|
const auto & value = (*item_arg)[row];
|
2016-05-30 23:42:07 +00:00
|
|
|
|
|
|
|
|
|
data[row] = 0;
|
2015-09-18 12:40:42 +00:00
|
|
|
|
for (size_t i = 0, size = arr.size(); i < size; ++i)
|
2015-10-12 07:05:54 +00:00
|
|
|
|
if (apply_visitor(FieldVisitorAccurateEquals(), arr[i], value))
|
2015-09-18 12:40:42 +00:00
|
|
|
|
if (!IndexConv::apply(i, data[row]))
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
}
|
2012-11-02 19:10:43 +00:00
|
|
|
|
|
|
|
|
|
return true;
|
|
|
|
|
}
|
|
|
|
|
|
2016-07-09 04:39:57 +00:00
|
|
|
|
bool executeGeneric(Block & block, const ColumnNumbers & arguments, size_t result)
|
|
|
|
|
{
|
|
|
|
|
const ColumnArray * col_array = typeid_cast<const ColumnArray *>(block.getByPosition(arguments[0]).column.get());
|
|
|
|
|
|
|
|
|
|
if (!col_array)
|
|
|
|
|
return false;
|
|
|
|
|
|
|
|
|
|
const IColumn & col_nested = col_array->getData();
|
|
|
|
|
const IColumn & item_arg = *block.getByPosition(arguments[1]).column;
|
|
|
|
|
|
|
|
|
|
const auto col_res = std::make_shared<ResultColumnType>();
|
|
|
|
|
block.getByPosition(result).column = col_res;
|
|
|
|
|
|
|
|
|
|
if (item_arg.isConst())
|
|
|
|
|
{
|
|
|
|
|
ArrayIndexGenericImpl<IndexConv, true>::vector(col_nested, col_array->getOffsets(),
|
|
|
|
|
*item_arg.cut(0, 1)->convertToFullColumnIfConst(), col_res->getData());
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
/// If item_arg is tuple and have constants.
|
|
|
|
|
if (auto materialized_tuple = item_arg.convertToFullColumnIfConst())
|
|
|
|
|
{
|
|
|
|
|
ArrayIndexGenericImpl<IndexConv, false>::vector(
|
|
|
|
|
col_nested, col_array->getOffsets(), *materialized_tuple, col_res->getData());
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
ArrayIndexGenericImpl<IndexConv, false>::vector(
|
|
|
|
|
col_nested, col_array->getOffsets(), item_arg, col_res->getData());
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return true;
|
|
|
|
|
}
|
|
|
|
|
|
2012-11-02 19:10:43 +00:00
|
|
|
|
|
|
|
|
|
public:
|
|
|
|
|
/// Получить имя функции.
|
2015-10-11 23:36:45 +00:00
|
|
|
|
String getName() const override
|
2012-11-02 19:10:43 +00:00
|
|
|
|
{
|
2014-11-12 17:23:26 +00:00
|
|
|
|
return name;
|
2012-11-02 19:10:43 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/// Получить типы результата по типам аргументов. Если функция неприменима для данных аргументов - кинуть исключение.
|
2016-07-06 09:47:55 +00:00
|
|
|
|
DataTypePtr getReturnTypeImpl(const DataTypes & arguments) const override
|
2012-11-02 19:10:43 +00:00
|
|
|
|
{
|
|
|
|
|
if (arguments.size() != 2)
|
|
|
|
|
throw Exception("Number of arguments for function " + getName() + " doesn't match: passed "
|
2013-06-21 20:34:19 +00:00
|
|
|
|
+ toString(arguments.size()) + ", should be 2.",
|
2012-11-02 19:10:43 +00:00
|
|
|
|
ErrorCodes::NUMBER_OF_ARGUMENTS_DOESNT_MATCH);
|
|
|
|
|
|
2016-07-08 04:16:30 +00:00
|
|
|
|
const DataTypeArray * array_type = typeid_cast<const DataTypeArray *>(arguments[0].get());
|
2012-11-02 19:10:43 +00:00
|
|
|
|
if (!array_type)
|
|
|
|
|
throw Exception("First argument for function " + getName() + " must be array.", ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT);
|
|
|
|
|
|
2015-10-12 07:05:54 +00:00
|
|
|
|
if (!(array_type->getNestedType()->behavesAsNumber() && arguments[1]->behavesAsNumber())
|
|
|
|
|
&& array_type->getNestedType()->getName() != arguments[1]->getName())
|
2012-11-02 19:10:43 +00:00
|
|
|
|
throw Exception("Type of array elements and second argument for function " + getName() + " must be same."
|
|
|
|
|
" Passed: " + arguments[0]->getName() + " and " + arguments[1]->getName() + ".", ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT);
|
|
|
|
|
|
2016-05-28 07:48:40 +00:00
|
|
|
|
return std::make_shared<typename DataTypeFromFieldType<typename IndexConv::ResultType>::Type>();
|
2012-11-02 19:10:43 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/// Выполнить функцию над блоком.
|
2016-07-06 09:47:55 +00:00
|
|
|
|
void executeImpl(Block & block, const ColumnNumbers & arguments, size_t result) override
|
2012-11-02 19:10:43 +00:00
|
|
|
|
{
|
2015-09-18 12:40:42 +00:00
|
|
|
|
if (!(executeNumber<UInt8>(block, arguments, result)
|
2016-07-09 04:39:57 +00:00
|
|
|
|
|| executeNumber<UInt16>(block, arguments, result)
|
|
|
|
|
|| executeNumber<UInt32>(block, arguments, result)
|
|
|
|
|
|| executeNumber<UInt64>(block, arguments, result)
|
|
|
|
|
|| executeNumber<Int8>(block, arguments, result)
|
|
|
|
|
|| executeNumber<Int16>(block, arguments, result)
|
|
|
|
|
|| executeNumber<Int32>(block, arguments, result)
|
|
|
|
|
|| executeNumber<Int64>(block, arguments, result)
|
|
|
|
|
|| executeNumber<Float32>(block, arguments, result)
|
|
|
|
|
|| executeNumber<Float64>(block, arguments, result)
|
|
|
|
|
|| executeConst(block, arguments, result)
|
|
|
|
|
|| executeString(block, arguments, result)
|
|
|
|
|
|| executeGeneric(block, arguments, result)))
|
2015-09-18 12:40:42 +00:00
|
|
|
|
throw Exception{
|
|
|
|
|
"Illegal column " + block.getByPosition(arguments[0]).column->getName()
|
|
|
|
|
+ " of first argument of function " + getName(),
|
2016-07-09 04:39:57 +00:00
|
|
|
|
ErrorCodes::ILLEGAL_COLUMN};
|
2012-11-02 19:10:43 +00:00
|
|
|
|
}
|
|
|
|
|
};
|
|
|
|
|
|
2016-08-11 16:47:28 +00:00
|
|
|
|
|
2013-10-21 11:36:44 +00:00
|
|
|
|
class FunctionArrayEnumerate : public IFunction
|
|
|
|
|
{
|
|
|
|
|
public:
|
2014-11-12 17:23:26 +00:00
|
|
|
|
static constexpr auto name = "arrayEnumerate";
|
2016-08-11 16:47:28 +00:00
|
|
|
|
static FunctionPtr create(const Context & context);
|
2014-11-12 17:23:26 +00:00
|
|
|
|
|
2013-10-21 11:36:44 +00:00
|
|
|
|
/// Получить имя функции.
|
2016-08-11 16:47:28 +00:00
|
|
|
|
String getName() const override;
|
2013-10-21 11:36:44 +00:00
|
|
|
|
|
|
|
|
|
/// Получить типы результата по типам аргументов. Если функция неприменима для данных аргументов - кинуть исключение.
|
2016-08-11 16:47:28 +00:00
|
|
|
|
DataTypePtr getReturnTypeImpl(const DataTypes & arguments) const override;
|
2013-10-21 11:36:44 +00:00
|
|
|
|
|
|
|
|
|
/// Выполнить функцию над блоком.
|
2016-08-11 16:47:28 +00:00
|
|
|
|
void executeImpl(Block & block, const ColumnNumbers & arguments, size_t result) override;
|
2013-10-21 11:36:44 +00:00
|
|
|
|
};
|
|
|
|
|
|
2015-07-23 11:11:10 +00:00
|
|
|
|
|
|
|
|
|
/// Считает количество разных элементов в массиве, или количество разных кортежей из элементов на соответствующих позициях в нескольких массивах.
|
|
|
|
|
/// NOTE Реализация частично совпадает с arrayEnumerateUniq.
|
|
|
|
|
class FunctionArrayUniq : public IFunction
|
|
|
|
|
{
|
|
|
|
|
public:
|
|
|
|
|
static constexpr auto name = "arrayUniq";
|
2016-08-11 16:47:28 +00:00
|
|
|
|
static FunctionPtr create(const Context & context);
|
2015-07-23 11:11:10 +00:00
|
|
|
|
|
|
|
|
|
/// Получить имя функции.
|
2016-08-11 16:47:28 +00:00
|
|
|
|
String getName() const override;
|
2015-07-23 11:11:10 +00:00
|
|
|
|
|
|
|
|
|
/// Получить типы результата по типам аргументов. Если функция неприменима для данных аргументов - кинуть исключение.
|
2016-08-11 16:47:28 +00:00
|
|
|
|
DataTypePtr getReturnTypeImpl(const DataTypes & arguments) const override;
|
2015-07-23 11:11:10 +00:00
|
|
|
|
|
|
|
|
|
/// Выполнить функцию над блоком.
|
2016-08-11 16:47:28 +00:00
|
|
|
|
void executeImpl(Block & block, const ColumnNumbers & arguments, size_t result) override;
|
2015-07-23 11:11:10 +00:00
|
|
|
|
|
|
|
|
|
private:
|
|
|
|
|
/// Изначально выделить кусок памяти для 512 элементов.
|
|
|
|
|
static constexpr size_t INITIAL_SIZE_DEGREE = 9;
|
|
|
|
|
|
|
|
|
|
template <typename T>
|
2016-08-11 16:47:28 +00:00
|
|
|
|
bool executeNumber(const ColumnArray * array, ColumnUInt32::Container_t & res_values);
|
2015-07-23 11:11:10 +00:00
|
|
|
|
|
2016-08-11 16:47:28 +00:00
|
|
|
|
bool executeString(const ColumnArray * array, ColumnUInt32::Container_t & res_values);
|
2015-07-23 11:11:10 +00:00
|
|
|
|
|
2016-08-11 16:47:28 +00:00
|
|
|
|
bool executeConst(Block & block, const ColumnNumbers & arguments, size_t result);
|
2015-07-23 11:11:10 +00:00
|
|
|
|
|
|
|
|
|
bool execute128bit(
|
|
|
|
|
const ColumnArray::Offsets_t & offsets,
|
|
|
|
|
const ConstColumnPlainPtrs & columns,
|
2016-08-11 16:47:28 +00:00
|
|
|
|
ColumnUInt32::Container_t & res_values);
|
2015-07-23 11:11:10 +00:00
|
|
|
|
|
|
|
|
|
void executeHashed(
|
|
|
|
|
const ColumnArray::Offsets_t & offsets,
|
|
|
|
|
const ConstColumnPlainPtrs & columns,
|
2016-08-11 16:47:28 +00:00
|
|
|
|
ColumnUInt32::Container_t & res_values);
|
2015-07-23 11:11:10 +00:00
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
2013-10-11 11:43:50 +00:00
|
|
|
|
class FunctionArrayEnumerateUniq : public IFunction
|
|
|
|
|
{
|
|
|
|
|
public:
|
2014-11-12 17:23:26 +00:00
|
|
|
|
static constexpr auto name = "arrayEnumerateUniq";
|
2016-08-11 16:47:28 +00:00
|
|
|
|
static FunctionPtr create(const Context & context);
|
2014-11-12 17:23:26 +00:00
|
|
|
|
|
2013-10-11 11:43:50 +00:00
|
|
|
|
/// Получить имя функции.
|
2016-08-11 16:47:28 +00:00
|
|
|
|
String getName() const override;
|
2013-10-11 11:43:50 +00:00
|
|
|
|
|
|
|
|
|
/// Получить типы результата по типам аргументов. Если функция неприменима для данных аргументов - кинуть исключение.
|
2016-08-11 16:47:28 +00:00
|
|
|
|
DataTypePtr getReturnTypeImpl(const DataTypes & arguments) const override;
|
2013-10-11 11:43:50 +00:00
|
|
|
|
|
2013-10-24 12:53:24 +00:00
|
|
|
|
/// Выполнить функцию над блоком.
|
2016-08-11 16:47:28 +00:00
|
|
|
|
void executeImpl(Block & block, const ColumnNumbers & arguments, size_t result) override;
|
2013-10-24 12:53:24 +00:00
|
|
|
|
|
|
|
|
|
private:
|
2014-04-28 02:47:56 +00:00
|
|
|
|
/// Изначально выделить кусок памяти для 512 элементов.
|
2014-05-03 16:03:49 +00:00
|
|
|
|
static constexpr size_t INITIAL_SIZE_DEGREE = 9;
|
2013-10-24 12:53:24 +00:00
|
|
|
|
|
2013-10-11 11:43:50 +00:00
|
|
|
|
template <typename T>
|
2016-08-11 16:47:28 +00:00
|
|
|
|
bool executeNumber(const ColumnArray * array, ColumnUInt32::Container_t & res_values);
|
2013-10-11 11:43:50 +00:00
|
|
|
|
|
2016-08-11 16:47:28 +00:00
|
|
|
|
bool executeString(const ColumnArray * array, ColumnUInt32::Container_t & res_values);
|
2013-10-11 11:43:50 +00:00
|
|
|
|
|
2016-08-11 16:47:28 +00:00
|
|
|
|
bool executeConst(Block & block, const ColumnNumbers & arguments, size_t result);
|
2013-12-24 11:56:38 +00:00
|
|
|
|
|
|
|
|
|
bool execute128bit(
|
|
|
|
|
const ColumnArray::Offsets_t & offsets,
|
|
|
|
|
const ConstColumnPlainPtrs & columns,
|
2016-08-11 16:47:28 +00:00
|
|
|
|
ColumnUInt32::Container_t & res_values);
|
2013-12-24 11:56:38 +00:00
|
|
|
|
|
|
|
|
|
void executeHashed(
|
|
|
|
|
const ColumnArray::Offsets_t & offsets,
|
|
|
|
|
const ConstColumnPlainPtrs & columns,
|
2016-08-11 16:47:28 +00:00
|
|
|
|
ColumnUInt32::Container_t & res_values);
|
2013-10-11 11:43:50 +00:00
|
|
|
|
};
|
|
|
|
|
|
2012-11-02 19:10:43 +00:00
|
|
|
|
|
2014-10-28 13:43:22 +00:00
|
|
|
|
template <typename Type> struct TypeToColumnType { using ColumnType = ColumnVector<Type>; };
|
|
|
|
|
template <> struct TypeToColumnType<String> { using ColumnType = ColumnString; };
|
|
|
|
|
|
|
|
|
|
template <typename DataType> struct DataTypeToName : TypeName<typename DataType::FieldType> { };
|
|
|
|
|
template <> struct DataTypeToName<DataTypeDate> { static std::string get() { return "Date"; } };
|
|
|
|
|
template <> struct DataTypeToName<DataTypeDateTime> { static std::string get() { return "DateTime"; } };
|
|
|
|
|
|
|
|
|
|
template <typename DataType>
|
2014-11-12 17:23:26 +00:00
|
|
|
|
struct FunctionEmptyArray : public IFunction
|
2014-10-28 13:43:22 +00:00
|
|
|
|
{
|
2014-11-12 17:23:26 +00:00
|
|
|
|
static constexpr auto base_name = "emptyArray";
|
|
|
|
|
static const String name;
|
2016-05-28 15:42:22 +00:00
|
|
|
|
static FunctionPtr create(const Context & context) { return std::make_shared<FunctionEmptyArray>(); }
|
2014-11-12 17:23:26 +00:00
|
|
|
|
|
2014-12-02 12:42:20 +00:00
|
|
|
|
private:
|
2015-10-11 23:36:45 +00:00
|
|
|
|
String getName() const override
|
2014-10-28 13:43:22 +00:00
|
|
|
|
{
|
2014-11-12 17:23:26 +00:00
|
|
|
|
return name;
|
2014-10-28 13:43:22 +00:00
|
|
|
|
}
|
|
|
|
|
|
2016-07-06 09:47:55 +00:00
|
|
|
|
DataTypePtr getReturnTypeImpl(const DataTypes & arguments) const override
|
2014-10-28 13:43:22 +00:00
|
|
|
|
{
|
|
|
|
|
if (arguments.size() != 0)
|
|
|
|
|
throw Exception("Number of arguments for function " + getName() + " doesn't match: passed "
|
|
|
|
|
+ toString(arguments.size()) + ", should be 0.",
|
|
|
|
|
ErrorCodes::NUMBER_OF_ARGUMENTS_DOESNT_MATCH);
|
|
|
|
|
|
2016-05-28 07:48:40 +00:00
|
|
|
|
return std::make_shared<DataTypeArray>(std::make_shared<DataType>());
|
2014-10-28 13:43:22 +00:00
|
|
|
|
}
|
|
|
|
|
|
2016-07-06 09:47:55 +00:00
|
|
|
|
void executeImpl(Block & block, const ColumnNumbers & arguments, size_t result) override
|
2014-10-28 13:43:22 +00:00
|
|
|
|
{
|
|
|
|
|
using UnderlyingColumnType = typename TypeToColumnType<typename DataType::FieldType>::ColumnType;
|
|
|
|
|
|
2016-05-28 05:31:36 +00:00
|
|
|
|
block.getByPosition(result).column = std::make_shared<ColumnArray>(
|
|
|
|
|
std::make_shared<UnderlyingColumnType>(),
|
|
|
|
|
std::make_shared<ColumnArray::ColumnOffsets_t>(block.rowsInFirstColumn(), 0));
|
2014-10-28 13:43:22 +00:00
|
|
|
|
}
|
|
|
|
|
};
|
|
|
|
|
|
2014-11-12 17:23:26 +00:00
|
|
|
|
template <typename DataType>
|
|
|
|
|
const String FunctionEmptyArray<DataType>::name = FunctionEmptyArray::base_name + DataTypeToName<DataType>::get();
|
|
|
|
|
|
2014-12-02 12:42:20 +00:00
|
|
|
|
class FunctionRange : public IFunction
|
|
|
|
|
{
|
|
|
|
|
public:
|
2015-01-16 10:16:55 +00:00
|
|
|
|
static constexpr auto max_elements = 100000000;
|
2014-12-02 12:42:20 +00:00
|
|
|
|
static constexpr auto name = "range";
|
2016-05-28 15:42:22 +00:00
|
|
|
|
static FunctionPtr create(const Context &) { return std::make_shared<FunctionRange>(); }
|
2014-12-02 12:42:20 +00:00
|
|
|
|
|
|
|
|
|
private:
|
|
|
|
|
String getName() const override
|
|
|
|
|
{
|
|
|
|
|
return name;
|
|
|
|
|
}
|
|
|
|
|
|
2016-07-06 09:47:55 +00:00
|
|
|
|
DataTypePtr getReturnTypeImpl(const DataTypes & arguments) const override
|
2014-12-02 12:42:20 +00:00
|
|
|
|
{
|
|
|
|
|
if (arguments.size() != 1)
|
|
|
|
|
throw Exception{
|
|
|
|
|
"Number of arguments for function " + getName() + " doesn't match: passed "
|
|
|
|
|
+ toString(arguments.size()) + ", should be 1.",
|
|
|
|
|
ErrorCodes::NUMBER_OF_ARGUMENTS_DOESNT_MATCH
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
const auto arg = arguments.front().get();
|
|
|
|
|
|
|
|
|
|
if (!typeid_cast<const DataTypeUInt8 *>(arg) &&
|
|
|
|
|
!typeid_cast<const DataTypeUInt16 *>(arg) &&
|
|
|
|
|
!typeid_cast<const DataTypeUInt32 *>(arg) &
|
|
|
|
|
!typeid_cast<const DataTypeUInt64 *>(arg))
|
|
|
|
|
{
|
|
|
|
|
throw Exception{
|
|
|
|
|
"Illegal type " + arg->getName() + " of argument of function " + getName(),
|
|
|
|
|
ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT
|
|
|
|
|
};
|
|
|
|
|
}
|
2015-01-22 01:13:13 +00:00
|
|
|
|
|
2016-05-28 07:48:40 +00:00
|
|
|
|
return std::make_shared<DataTypeArray>(arg->clone());
|
2014-12-02 12:42:20 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
template <typename T>
|
2016-07-06 09:47:55 +00:00
|
|
|
|
bool executeInternal(Block & block, const IColumn * const arg, const size_t result)
|
2014-12-02 12:42:20 +00:00
|
|
|
|
{
|
|
|
|
|
if (const auto in = typeid_cast<const ColumnVector<T> *>(arg))
|
|
|
|
|
{
|
|
|
|
|
const auto & in_data = in->getData();
|
|
|
|
|
const auto total_values = std::accumulate(std::begin(in_data), std::end(in_data), std::size_t{},
|
2015-07-20 16:24:37 +00:00
|
|
|
|
[this] (const std::size_t lhs, const std::size_t rhs) {
|
|
|
|
|
const auto sum = lhs + rhs;
|
|
|
|
|
if (sum < lhs)
|
|
|
|
|
throw Exception{
|
|
|
|
|
"A call to function " + getName() + " overflows, investigate the values of arguments you are passing",
|
|
|
|
|
ErrorCodes::ARGUMENT_OUT_OF_BOUND
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
return sum;
|
|
|
|
|
});
|
|
|
|
|
|
2014-12-02 18:23:42 +00:00
|
|
|
|
if (total_values > max_elements)
|
|
|
|
|
throw Exception{
|
2015-01-16 10:16:55 +00:00
|
|
|
|
"A call to function " + getName() + " would produce " + std::to_string(total_values) +
|
|
|
|
|
" array elements, which is greater than the allowed maximum of " + std::to_string(max_elements),
|
2014-12-02 18:23:42 +00:00
|
|
|
|
ErrorCodes::ARGUMENT_OUT_OF_BOUND
|
|
|
|
|
};
|
2014-12-02 12:42:20 +00:00
|
|
|
|
|
2016-05-28 05:31:36 +00:00
|
|
|
|
const auto data_col = std::make_shared<ColumnVector<T>>(total_values);
|
|
|
|
|
const auto out = std::make_shared<ColumnArray>(
|
2014-12-02 12:42:20 +00:00
|
|
|
|
data_col,
|
2016-05-28 05:31:36 +00:00
|
|
|
|
std::make_shared<ColumnArray::ColumnOffsets_t>(in->size()));
|
2014-12-02 12:42:20 +00:00
|
|
|
|
block.getByPosition(result).column = out;
|
|
|
|
|
|
|
|
|
|
auto & out_data = data_col->getData();
|
|
|
|
|
auto & out_offsets = out->getOffsets();
|
|
|
|
|
|
|
|
|
|
IColumn::Offset_t offset{};
|
|
|
|
|
for (const auto i : ext::range(0, in->size()))
|
|
|
|
|
{
|
|
|
|
|
std::copy(ext::make_range_iterator(T{}), ext::make_range_iterator(in_data[i]), &out_data[offset]);
|
|
|
|
|
offset += in_data[i];
|
|
|
|
|
out_offsets[i] = offset;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return true;
|
|
|
|
|
}
|
|
|
|
|
else if (const auto in = typeid_cast<const ColumnConst<T> *>(arg))
|
|
|
|
|
{
|
|
|
|
|
const auto & in_data = in->getData();
|
2015-07-20 16:24:37 +00:00
|
|
|
|
if (in->size() > std::numeric_limits<std::size_t>::max() / in_data)
|
|
|
|
|
throw Exception{
|
|
|
|
|
"A call to function " + getName() + " overflows, investigate the values of arguments you are passing",
|
|
|
|
|
ErrorCodes::ARGUMENT_OUT_OF_BOUND
|
|
|
|
|
};
|
|
|
|
|
|
2014-12-02 12:42:20 +00:00
|
|
|
|
const std::size_t total_values = in->size() * in_data;
|
2014-12-02 18:23:42 +00:00
|
|
|
|
if (total_values > max_elements)
|
|
|
|
|
throw Exception{
|
2015-01-16 10:16:55 +00:00
|
|
|
|
"A call to function " + getName() + " would produce " + std::to_string(total_values) +
|
|
|
|
|
" array elements, which is greater than the allowed maximum of " + std::to_string(max_elements),
|
2014-12-02 18:23:42 +00:00
|
|
|
|
ErrorCodes::ARGUMENT_OUT_OF_BOUND
|
|
|
|
|
};
|
2014-12-02 12:42:20 +00:00
|
|
|
|
|
2016-05-28 05:31:36 +00:00
|
|
|
|
const auto data_col = std::make_shared<ColumnVector<T>>(total_values);
|
|
|
|
|
const auto out = std::make_shared<ColumnArray>(
|
2014-12-02 12:42:20 +00:00
|
|
|
|
data_col,
|
2016-05-28 05:31:36 +00:00
|
|
|
|
std::make_shared<ColumnArray::ColumnOffsets_t>(in->size()));
|
2014-12-02 12:42:20 +00:00
|
|
|
|
block.getByPosition(result).column = out;
|
|
|
|
|
|
|
|
|
|
auto & out_data = data_col->getData();
|
|
|
|
|
auto & out_offsets = out->getOffsets();
|
2015-01-22 01:13:13 +00:00
|
|
|
|
|
2014-12-02 12:42:20 +00:00
|
|
|
|
IColumn::Offset_t offset{};
|
|
|
|
|
for (const auto i : ext::range(0, in->size()))
|
|
|
|
|
{
|
|
|
|
|
std::copy(ext::make_range_iterator(T{}), ext::make_range_iterator(in_data), &out_data[offset]);
|
|
|
|
|
offset += in_data;
|
|
|
|
|
out_offsets[i] = offset;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return true;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return false;
|
|
|
|
|
}
|
|
|
|
|
|
2016-07-06 09:47:55 +00:00
|
|
|
|
void executeImpl(Block & block, const ColumnNumbers & arguments, const size_t result) override
|
2014-12-02 12:42:20 +00:00
|
|
|
|
{
|
|
|
|
|
const auto col = block.getByPosition(arguments[0]).column.get();
|
|
|
|
|
|
2016-07-06 09:47:55 +00:00
|
|
|
|
if (!executeInternal<UInt8>(block, col, result) &&
|
|
|
|
|
!executeInternal<UInt16>(block, col, result) &&
|
|
|
|
|
!executeInternal<UInt32>(block, col, result) &&
|
|
|
|
|
!executeInternal<UInt64>(block, col, result))
|
2014-12-02 12:42:20 +00:00
|
|
|
|
{
|
|
|
|
|
throw Exception{
|
|
|
|
|
"Illegal column " + col->getName() + " of argument of function " + getName(),
|
|
|
|
|
ErrorCodes::ILLEGAL_COLUMN
|
|
|
|
|
};
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
};
|
|
|
|
|
|
2014-10-28 13:43:22 +00:00
|
|
|
|
|
2015-07-26 10:40:32 +00:00
|
|
|
|
class FunctionEmptyArrayToSingle : public IFunction
|
|
|
|
|
{
|
|
|
|
|
public:
|
|
|
|
|
static constexpr auto name = "emptyArrayToSingle";
|
2016-08-11 16:47:28 +00:00
|
|
|
|
static FunctionPtr create(const Context & context);
|
2015-07-26 10:40:32 +00:00
|
|
|
|
|
|
|
|
|
/// Получить имя функции.
|
2016-08-11 16:47:28 +00:00
|
|
|
|
String getName() const override;
|
2015-07-26 10:40:32 +00:00
|
|
|
|
|
|
|
|
|
/// Получить типы результата по типам аргументов. Если функция неприменима для данных аргументов - кинуть исключение.
|
2016-08-11 16:47:28 +00:00
|
|
|
|
DataTypePtr getReturnTypeImpl(const DataTypes & arguments) const override;
|
2015-07-26 10:40:32 +00:00
|
|
|
|
|
|
|
|
|
/// Выполнить функцию над блоком.
|
2016-08-11 16:47:28 +00:00
|
|
|
|
void executeImpl(Block & block, const ColumnNumbers & arguments, size_t result) override;
|
2015-07-26 10:40:32 +00:00
|
|
|
|
|
|
|
|
|
private:
|
2016-08-11 16:47:28 +00:00
|
|
|
|
bool executeConst(Block & block, const ColumnNumbers & arguments, size_t result);
|
2015-07-26 10:40:32 +00:00
|
|
|
|
|
|
|
|
|
template <typename T>
|
|
|
|
|
bool executeNumber(
|
|
|
|
|
const IColumn & src_data, const ColumnArray::Offsets_t & src_offsets,
|
2016-08-11 16:47:28 +00:00
|
|
|
|
IColumn & res_data_col, ColumnArray::Offsets_t & res_offsets);
|
2015-07-26 10:40:32 +00:00
|
|
|
|
|
|
|
|
|
bool executeFixedString(
|
|
|
|
|
const IColumn & src_data, const ColumnArray::Offsets_t & src_offsets,
|
2016-08-11 16:47:28 +00:00
|
|
|
|
IColumn & res_data_col, ColumnArray::Offsets_t & res_offsets);
|
2015-07-26 10:40:32 +00:00
|
|
|
|
|
|
|
|
|
bool executeString(
|
|
|
|
|
const IColumn & src_data, const ColumnArray::Offsets_t & src_array_offsets,
|
2016-08-11 16:47:28 +00:00
|
|
|
|
IColumn & res_data_col, ColumnArray::Offsets_t & res_array_offsets);
|
2015-07-26 10:40:32 +00:00
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
2015-10-19 21:07:24 +00:00
|
|
|
|
class FunctionArrayReverse : public IFunction
|
|
|
|
|
{
|
|
|
|
|
public:
|
|
|
|
|
static constexpr auto name = "reverse";
|
2016-08-11 16:47:28 +00:00
|
|
|
|
static FunctionPtr create(const Context & context);
|
2015-10-19 21:07:24 +00:00
|
|
|
|
|
|
|
|
|
/// Получить имя функции.
|
2016-08-11 16:47:28 +00:00
|
|
|
|
String getName() const override;
|
2015-10-19 21:07:24 +00:00
|
|
|
|
|
|
|
|
|
/// Получить типы результата по типам аргументов. Если функция неприменима для данных аргументов - кинуть исключение.
|
2016-08-11 16:47:28 +00:00
|
|
|
|
DataTypePtr getReturnTypeImpl(const DataTypes & arguments) const override;
|
2015-10-19 21:07:24 +00:00
|
|
|
|
|
|
|
|
|
/// Выполнить функцию над блоком.
|
2016-08-11 16:47:28 +00:00
|
|
|
|
void executeImpl(Block & block, const ColumnNumbers & arguments, size_t result) override;
|
2015-10-19 21:07:24 +00:00
|
|
|
|
|
|
|
|
|
private:
|
2016-08-11 16:47:28 +00:00
|
|
|
|
bool executeConst(Block & block, const ColumnNumbers & arguments, size_t result);
|
2015-10-19 21:07:24 +00:00
|
|
|
|
|
|
|
|
|
template <typename T>
|
|
|
|
|
bool executeNumber(
|
|
|
|
|
const IColumn & src_data, const ColumnArray::Offsets_t & src_offsets,
|
2016-08-11 16:47:28 +00:00
|
|
|
|
IColumn & res_data_col);
|
2015-10-19 21:07:24 +00:00
|
|
|
|
|
|
|
|
|
bool executeFixedString(
|
|
|
|
|
const IColumn & src_data, const ColumnArray::Offsets_t & src_offsets,
|
2016-08-11 16:47:28 +00:00
|
|
|
|
IColumn & res_data_col);
|
2015-10-19 21:07:24 +00:00
|
|
|
|
|
|
|
|
|
bool executeString(
|
|
|
|
|
const IColumn & src_data, const ColumnArray::Offsets_t & src_array_offsets,
|
2016-08-11 16:47:28 +00:00
|
|
|
|
IColumn & res_data_col);
|
2015-10-19 21:07:24 +00:00
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
2015-12-13 10:43:49 +00:00
|
|
|
|
/** Применяет к массиву агрегатную функцию и возвращает её результат.
|
|
|
|
|
* Также может быть применена к нескольким массивам одинаковых размеров, если агрегатная функция принимает несколько аргументов.
|
|
|
|
|
*/
|
|
|
|
|
class FunctionArrayReduce : public IFunction
|
|
|
|
|
{
|
|
|
|
|
public:
|
|
|
|
|
static constexpr auto name = "arrayReduce";
|
2016-08-11 16:47:28 +00:00
|
|
|
|
static FunctionPtr create(const Context & context);
|
2015-12-13 10:43:49 +00:00
|
|
|
|
|
|
|
|
|
/// Получить имя функции.
|
2016-08-11 16:47:28 +00:00
|
|
|
|
String getName() const override;
|
2015-12-13 10:43:49 +00:00
|
|
|
|
|
2016-07-06 09:47:55 +00:00
|
|
|
|
void getReturnTypeAndPrerequisitesImpl(
|
2015-12-13 10:43:49 +00:00
|
|
|
|
const ColumnsWithTypeAndName & arguments,
|
|
|
|
|
DataTypePtr & out_return_type,
|
2016-08-11 16:47:28 +00:00
|
|
|
|
std::vector<ExpressionAction> & out_prerequisites) override;
|
2015-12-13 10:43:49 +00:00
|
|
|
|
|
2016-08-11 16:47:28 +00:00
|
|
|
|
void executeImpl(Block & block, const ColumnNumbers & arguments, size_t result) override;
|
2015-12-13 10:43:49 +00:00
|
|
|
|
private:
|
|
|
|
|
AggregateFunctionPtr aggregate_function;
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
2014-11-12 17:23:26 +00:00
|
|
|
|
struct NameHas { static constexpr auto name = "has"; };
|
|
|
|
|
struct NameIndexOf { static constexpr auto name = "indexOf"; };
|
|
|
|
|
struct NameCountEqual { static constexpr auto name = "countEqual"; };
|
2012-12-15 20:01:46 +00:00
|
|
|
|
|
2016-05-30 21:41:41 +00:00
|
|
|
|
using FunctionHas = FunctionArrayIndex<IndexToOne, NameHas>;
|
|
|
|
|
using FunctionIndexOf = FunctionArrayIndex<IndexIdentity, NameIndexOf>;
|
|
|
|
|
using FunctionCountEqual = FunctionArrayIndex<IndexCount, NameCountEqual>;
|
2012-12-15 20:01:46 +00:00
|
|
|
|
|
2014-11-12 17:23:26 +00:00
|
|
|
|
using FunctionEmptyArrayUInt8 = FunctionEmptyArray<DataTypeUInt8>;
|
|
|
|
|
using FunctionEmptyArrayUInt16 = FunctionEmptyArray<DataTypeUInt16>;
|
|
|
|
|
using FunctionEmptyArrayUInt32 = FunctionEmptyArray<DataTypeUInt32>;
|
|
|
|
|
using FunctionEmptyArrayUInt64 = FunctionEmptyArray<DataTypeUInt64>;
|
|
|
|
|
using FunctionEmptyArrayInt8 = FunctionEmptyArray<DataTypeInt8>;
|
|
|
|
|
using FunctionEmptyArrayInt16 = FunctionEmptyArray<DataTypeInt16>;
|
|
|
|
|
using FunctionEmptyArrayInt32 = FunctionEmptyArray<DataTypeInt32>;
|
|
|
|
|
using FunctionEmptyArrayInt64 = FunctionEmptyArray<DataTypeInt64>;
|
|
|
|
|
using FunctionEmptyArrayFloat32 = FunctionEmptyArray<DataTypeFloat32>;
|
|
|
|
|
using FunctionEmptyArrayFloat64 = FunctionEmptyArray<DataTypeFloat64>;
|
|
|
|
|
using FunctionEmptyArrayDate = FunctionEmptyArray<DataTypeDate>;
|
|
|
|
|
using FunctionEmptyArrayDateTime = FunctionEmptyArray<DataTypeDateTime>;
|
|
|
|
|
using FunctionEmptyArrayString = FunctionEmptyArray<DataTypeString>;
|
2014-10-28 13:43:22 +00:00
|
|
|
|
|
2012-12-15 20:01:46 +00:00
|
|
|
|
|
2012-08-26 06:48:39 +00:00
|
|
|
|
}
|