{

static constexpr auto name = Mode::name;

static FunctionPtr create(ContextPtr context) { return std::make_shared<FunctionArrayIntersect>(context); }

explicit FunctionArrayIntersect(ContextPtr context_) : context(context_) {}

String getName() const override { return name; }

bool isVariadic() const override { return true; }

size_t getNumberOfArguments() const override { return 0; }

bool isSuitableForShortCircuitArgumentsExecution(const DataTypesWithConstInfo & /*arguments*/) const override { return true; }

DataTypePtr getReturnTypeImpl(const DataTypes & arguments) const override;

ColumnPtr executeImpl(const ColumnsWithTypeAndName & arguments, const DataTypePtr & result_type, size_t input_rows_count) const override;

bool useDefaultImplementationForConstants() const override { return true; }

ContextPtr context;

/// Initially allocate a piece of memory for 64 elements. NOTE: This is just a guess.

static constexpr size_t INITIAL_SIZE_DEGREE = 6;

struct UnpackedArrays

{

size_t base_rows = 0;

struct UnpackedArray

{

bool is_const = false;

const NullMap * null_map = nullptr;

const NullMap * overflow_mask = nullptr;

const ColumnArray::ColumnOffsets::Container * offsets = nullptr;

const IColumn * nested_column = nullptr;

};

std::vector<UnpackedArray> args;

Columns column_holders;

UnpackedArrays() = default;

};

/// Cast column to data_type removing nullable if data_type hasn't.

/// It's expected that column can represent data_type after removing some NullMap's.

ColumnPtr castRemoveNullable(const ColumnPtr & column, const DataTypePtr & data_type) const;

struct CastArgumentsResult

{

ColumnsWithTypeAndName initial;

ColumnsWithTypeAndName cast;

};

static CastArgumentsResult castColumns(const ColumnsWithTypeAndName & arguments,

const DataTypePtr & return_type, const DataTypePtr & return_type_with_nulls);

UnpackedArrays prepareArrays(const ColumnsWithTypeAndName & columns, ColumnsWithTypeAndName & initial_columns) const;

template <typename Map, typename ColumnType, bool is_numeric_column>

static ColumnPtr execute(const UnpackedArrays & arrays, MutableColumnPtr result_data);

template <typename Map, typename ColumnType, bool is_numeric_column>

static void insertElement(typename Map::LookupResult & pair, size_t & result_offset, ColumnType & result_data, NullMap & null_map, const bool & use_null_map);

struct NumberExecutor

{

const UnpackedArrays & arrays;

const DataTypePtr & data_type;

ColumnPtr & result;

NumberExecutor(const UnpackedArrays & arrays_, const DataTypePtr & data_type_, ColumnPtr & result_)

: arrays(arrays_), data_type(data_type_), result(result_) {}

template <class T>

void operator()(TypeList<T>);

};

struct DecimalExecutor

{

const UnpackedArrays & arrays;

const DataTypePtr & data_type;

ColumnPtr & result;

DecimalExecutor(const UnpackedArrays & arrays_, const DataTypePtr & data_type_, ColumnPtr & result_)

: arrays(arrays_), data_type(data_type_), result(result_) {}

template <class T>

void operator()(TypeList<T>);

};

{

ColumnsWithTypeAndName args{first, second};

auto eq_func = FunctionFactory::instance().get("notEquals", context)->build(args);

return eq_func->execute(args, eq_func->getResultType(), args.front().column->size(), /* dry_run = */ false);

{

FunctionDocumentation::Description intersect_description = "Takes multiple arrays and returns an array with elements which are present in all source arrays. The result contains only unique values.";

FunctionDocumentation::Syntax intersect_syntax = "arrayIntersect(arr, arr1, ..., arrN)";

FunctionDocumentation::Arguments intersect_argument = {{"arrN", "N arrays from which to make the new array. [`Array(T)`](/sql-reference/data-types/array)."}};

FunctionDocumentation::ReturnedValue intersect_returned_value = {"Returns an array with distinct elements that are present in all N arrays", {"Array(T)"}}; FunctionDocumentation::Examples intersect_example = {{"Usage example",

)", R"(

)"}};

FunctionDocumentation::IntroducedIn intersect_introduced_in = {1, 1};

FunctionDocumentation::Category intersect_category = FunctionDocumentation::Category::Array;

FunctionDocumentation intersect_documentation = {intersect_description, intersect_syntax, intersect_argument, intersect_returned_value, intersect_example, intersect_introduced_in, intersect_category};

factory.registerFunction<ArrayIntersect>(intersect_documentation);

FunctionDocumentation::Description union_description = "Takes multiple arrays and returns an array which contains all elements that are present in one of the source arrays.The result contains only unique values.";

FunctionDocumentation::Syntax union_syntax = "arrayUnion(arr1, arr2, ..., arrN)";

FunctionDocumentation::Arguments union_argument = {{"arrN", "N arrays from which to make the new array.", {"Array(T)"}}};

FunctionDocumentation::ReturnedValue union_returned_value = {"Returns an array with distinct elements from the source arrays", {"Array(T)"}}; FunctionDocumentation::Examples union_example = {{"Usage example",

)",R"(

)"}};

FunctionDocumentation::IntroducedIn union_introduced_in = {24, 10};

FunctionDocumentation::Category union_category = FunctionDocumentation::Category::Array;

FunctionDocumentation union_documentation = {union_description, union_syntax, union_argument, union_returned_value, union_example, union_introduced_in, union_category};

factory.registerFunction<ArrayUnion>(union_documentation);

FunctionDocumentation::Description symdiff_description = R"(Takes multiple arrays and returns an array with elements that are not present in all source arrays. The result contains only unique values.

)";

FunctionDocumentation::Syntax symdiff_syntax = "arraySymmetricDifference(arr1, arr2, ... , arrN)";

FunctionDocumentation::Arguments symdiff_argument = {{"arrN", "N arrays from which to make the new array. [`Array(T)`](/sql-reference/data-types/array)."}};

FunctionDocumentation::ReturnedValue symdiff_returned_value = {"Returns an array of distinct elements not present in all source arrays", {"Array(T)"}}; FunctionDocumentation::Examples symdiff_example = {{"Usage example", R"(SELECT

)", R"(

)"}};

FunctionDocumentation::IntroducedIn symdiff_introduced_in = {25, 4};

FunctionDocumentation::Category symdiff_category = FunctionDocumentation::Category::Array;

FunctionDocumentation symdiff_documentation = {symdiff_description, symdiff_syntax, symdiff_argument, symdiff_returned_value, symdiff_example, symdiff_introduced_in, symdiff_category};

factory.registerFunction<ArraySymmetricDifference>(symdiff_documentation);