{

Zero, /// Fill with zero or default if array index out of range or map key not found.

Null /// Return ColumnNullable with NULLs if array index out of range or map key not found.

{

static constexpr bool is_null_mode = (mode == ArrayElementExceptionMode::Null);

static constexpr auto name = (mode == ArrayElementExceptionMode::Zero) ? "arrayElement" : "arrayElementOrNull";

explicit FunctionArrayElement(ContextPtr context_)

: escape_dots_in_json_keys(context_ && context_->getSettingsRef()[Setting::json_type_escape_dots_in_keys])

{

}

String getName() const override;

bool useDefaultImplementationForConstants() const override { return true; }

/// A lazily replicated array argument is consumed by gathering from the compact nested column.

/// When true it materializes the compacted representation to a full column.

bool useDefaultImplementationForReplicatedColumns() const override { return false; }

/// `Nullable(QBit)` with an array of indices must produce `Array(Nullable(T))`,

/// which cannot be represented by the default nullable wrapper around the result.

bool useDefaultImplementationForNulls() const override { return false; }

bool useDefaultImplementationForDynamic() const override { return true; }

bool useDefaultImplementationForVariant() const override { return true; }

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

size_t getNumberOfArguments() const override { return 2; }

/// Keep the inherited getReturnTypeImpl(ColumnsWithTypeAndName) visible alongside the

/// overload declared below; FunctionWithLowCardinalityFastPath calls it by qualified name.

using IFunction::getReturnTypeImpl;

DataTypePtr getReturnTypeImpl(const DataTypes & arguments) const override;

DataTypePtr getReturnTypeImpl(const ColumnsWithTypeAndName & arguments) const override;

ColumnPtr

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

/// Fast path hook for FunctionWithLowCardinalityFastPath (see FunctionLowCardinalityFastPath.h):

/// element access over Array(LowCardinality(String)) and Map with LowCardinality string keys

/// without materializing the dictionary into full columns. Returns nullptr to decline.

ColumnPtr tryExecuteLowCardinality(

const ColumnsWithTypeAndName & arguments, const DataTypePtr & result_type, size_t input_rows_count) const;

ColumnPtr perform(

const ColumnsWithTypeAndName & arguments,

const DataTypePtr & result_type,

ArrayImpl::NullMapBuilder<mode> & builder,

size_t input_rows_count) const;

/// Element access over a lazily replicated array (Replicated(Array)) without materializing it.

ColumnPtr executeReplicated(

const ColumnsWithTypeAndName & arguments, const DataTypePtr & result_type, size_t input_rows_count) const;

template <typename IndexType>

static bool gatherReplicated(

const IColumn & index_column,

const ColumnIndex & replication_indexes,

const ColumnArray::Offsets & offsets,

const IColumn & data,

IColumn & result,

ArrayImpl::NullMapBuilder<mode> & builder);

template <typename DataType>

static ColumnPtr executeNumberConst(

const ColumnsWithTypeAndName & arguments,

const DataTypePtr & result_type,

const Field & index,

ArrayImpl::NullMapBuilder<mode> & builder);

template <typename IndexType, typename DataType>

static ColumnPtr executeNumber(

const ColumnsWithTypeAndName & arguments,

const DataTypePtr & result_type,

const PaddedPODArray<IndexType> & indices,

ArrayImpl::NullMapBuilder<mode> & builder);

/// Optimize arrayElement when first argument has type Array(T) or Array(Nullable(T)) in which T is number type

template <typename DataType>

static ColumnPtr executeArrayNumberConst(

const ColumnsWithTypeAndName & arguments,

const DataTypePtr & result_type,

const Field & index,

ArrayImpl::NullMapBuilder<mode> & builder);

/// Optimize arrayElement when first argument has type Array(T) or Array(Nullable(T)) in which T is number type

template <typename IndexType, typename DataType>

static ColumnPtr executeArrayNumber(

const ColumnsWithTypeAndName & arguments,

const DataTypePtr & result_type,

const PaddedPODArray<IndexType> & indices,

ArrayImpl::NullMapBuilder<mode> & builder);

static ColumnPtr

executeStringConst(const ColumnsWithTypeAndName & arguments, const Field & index, ArrayImpl::NullMapBuilder<mode> & builder);

template <typename IndexType>

static ColumnPtr executeString(

const ColumnsWithTypeAndName & arguments, const PaddedPODArray<IndexType> & indices, ArrayImpl::NullMapBuilder<mode> & builder);

/// Optimize arrayElement when first argument has type Array(String) or Array(Nullable(String))

static ColumnPtr

executeArrayStringConst(const ColumnsWithTypeAndName & arguments, const Field & index, ArrayImpl::NullMapBuilder<mode> & builder);

/// Optimize arrayElement when first argument has type Array(String) or Array(Nullable(String))

template <typename IndexType>

static ColumnPtr executeArrayString(

const ColumnsWithTypeAndName & arguments, const PaddedPODArray<IndexType> & indices, ArrayImpl::NullMapBuilder<mode> & builder);

static ColumnPtr

executeGenericConst(const ColumnsWithTypeAndName & arguments, const Field & index, ArrayImpl::NullMapBuilder<mode> & builder);

static ColumnPtr removeNullableIfNeeded(const ColumnPtr & column, const DataTypePtr & expect_type);

template <typename IndexType>

static ColumnPtr executeGeneric(

const ColumnsWithTypeAndName & arguments, const PaddedPODArray<IndexType> & indices, ArrayImpl::NullMapBuilder<mode> & builder);

template <typename IndexType>

static ColumnPtr executeConst(

const ColumnsWithTypeAndName & arguments,

const DataTypePtr & result_type,

const PaddedPODArray<IndexType> & indices,

ArrayImpl::NullMapBuilder<mode> & builder,

size_t input_rows_count);

template <typename IndexType>

ColumnPtr executeArgument(

const ColumnsWithTypeAndName & arguments,

const DataTypePtr & result_type,

ArrayImpl::NullMapBuilder<mode> & builder,

size_t input_rows_count) const;

/** For a tuple array, the function is evaluated component-wise for each element of the tuple.

ColumnPtr executeTuple(const ColumnsWithTypeAndName & arguments, ArrayImpl::NullMapBuilder<mode> &, size_t input_rows_count) const;

/** For a map array, the function is evaluated component-wise for its keys and values

ColumnPtr executeMap2(const ColumnsWithTypeAndName & arguments, size_t input_rows_count) const;

/** For a map the function finds the matched value for a key.

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

/** For a JSON (Object) column, extract the combined subcolumn for the given key.

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

ColumnPtr executeWithArrayIndex(

const ColumnsWithTypeAndName & arguments, const DataTypePtr & result_type, size_t input_rows_count) const;

/** For a QBit, reconstructs the n-th vector element from its bit planes. Only the planes of the single

ColumnPtr executeQBit(const ColumnsWithTypeAndName & arguments, size_t input_rows_count) const;

template <typename T>

ColumnPtr executeQBitImpl(const ColumnsWithTypeAndName & arguments, size_t input_rows_count) const;

template <typename T>

ColumnPtr executeQBitWithArrayIndex(const ColumnsWithTypeAndName & arguments, size_t input_rows_count) const;

using Offsets = ColumnArray::Offsets;

static bool matchKeyToIndexNumber(

const IColumn & data, const Offsets & offsets, bool is_key_const, const IColumn & index, PaddedPODArray<UInt64> & matched_idxs);

static bool

matchKeyToIndexNumberConst(const IColumn & data, const Offsets & offsets, const Field & index, PaddedPODArray<UInt64> & matched_idxs);

static bool matchKeyToIndexString(

const IColumn & data, const Offsets & offsets, bool is_key_const, const IColumn & index, PaddedPODArray<UInt64> & matched_idxs);

static bool

matchKeyToIndexStringConst(const IColumn & data, const Offsets & offsets, const Field & index, PaddedPODArray<UInt64> & matched_idxs);

template <typename Matcher>

static void executeMatchKeyToIndex(const Offsets & offsets, PaddedPODArray<UInt64> & matched_idxs, const Matcher & matcher);

template <typename Matcher>

static void

executeMatchConstKeyToIndex(size_t num_rows, size_t num_values, PaddedPODArray<UInt64> & matched_idxs, const Matcher & matcher);

/// Escape dots in JSON key if json_type_escape_dots_in_keys setting is enabled.

String escapeJSONKeyIfNeeded(const String & key) const;

/// True for `Nullable(JSON)`, which supports the bracket syntax exactly like bare `JSON`.

static bool isNullableJSON(const DataTypePtr & type);

/// Fold the null map of a `Nullable(JSON)` first argument into the path extracted from its nested

/// column, so that the outer NULLs are visible in the result.

static ColumnPtr applyOuterNullMap(

const ColumnPtr & element_column, const DataTypePtr & element_type, const ColumnPtr & null_map_column);

bool escape_dots_in_json_keys = false;

{

static constexpr bool is_null_mode = (mode == ArrayElementExceptionMode::Null);

explicit operator bool() const { return src_null_map || is_null_mode; }

void initSource(const UInt8 * src_null_map_) { src_null_map = src_null_map_; }

void initSink(size_t size)

{

auto sink = ColumnUInt8::create(size);

sink_null_map = sink->getData().data();

sink_null_map_holder = std::move(sink);

}

void update(size_t from)

{

if (sink_null_map)

{

sink_null_map[index] = src_null_map && src_null_map[from];

++index;

}

}

void update()

{

if (sink_null_map)

{

sink_null_map[index] = 1;

++index;

}

}

ColumnPtr getNullMapColumnPtr() && { return std::move(sink_null_map_holder); }

const UInt8 * src_null_map = nullptr;

UInt8 * sink_null_map = nullptr;

MutableColumnPtr sink_null_map_holder;

size_t index = 0;

{

/** Implementation for constant index.

template <bool negative>

static void vectorConst(

const PaddedPODArray<T> & data,

const ColumnArray::Offsets & offsets,

const ColumnArray::Offset index,

PaddedPODArray<T> & result,

ArrayImpl::NullMapBuilder<mode> & builder)

{

size_t size = offsets.size();

result.resize(size);

ColumnArray::Offset current_offset = 0;

for (size_t i = 0; i < size; ++i)

{

size_t array_size = offsets[i] - current_offset;

if (index < array_size)

{

size_t j = 0;

if constexpr (negative)

j = offsets[i] - index - 1;

else

j = current_offset + index;

result[i] = data[j];

builder.update(j);

}

else

{

result[i] = T();

builder.update();

}

current_offset = offsets[i];

}

}

/** Implementation for non-constant index.

template <typename TIndex>

static void vector(

const PaddedPODArray<T> & data,

const ColumnArray::Offsets & offsets,

const PaddedPODArray<TIndex> & indices,

PaddedPODArray<T> & result,

ArrayImpl::NullMapBuilder<mode> & builder)

{

size_t size = offsets.size();

result.resize(size);

ColumnArray::Offset current_offset = 0;

for (size_t i = 0; i < size; ++i)

{

size_t array_size = offsets[i] - current_offset;

TIndex index = indices[i];

if (index > 0 && static_cast<size_t>(index) <= array_size)

{

size_t j = current_offset + index - 1;

result[i] = data[j];

builder.update(j);

}

else if (index < 0 && -static_cast<size_t>(index) <= array_size)

{

size_t j = offsets[i] + index;

result[i] = data[j];

builder.update(j);

}

else

{

result[i] = T();

builder.update();

}

current_offset = offsets[i];

}

}

{

/** Implementation for constant index.

template <bool negative, bool nullable_number>

static void vectorConst(

const PaddedPODArray<T> & data,

const ColumnArray::Offsets & offsets,

const ColumnArray::Offsets & nested_offsets,

const NullMap * number_null_map,

const ColumnArray::Offset index,

PaddedPODArray<T> & result_data,

ColumnArray::Offsets & result_offsets,

NullMap * result_number_null_map,

ArrayImpl::NullMapBuilder<mode> & builder)

{

size_t size = offsets.size();

/// First calculate the size of result_data or result_number_null_map

size_t result_data_size = 0;

for (size_t i = 0; i < size; ++i)

{

size_t array_size = offsets[i] - offsets[i - 1];

if (index < array_size)

{

size_t j = !negative ? (offsets[i - 1] + index) : (offsets[i] - index - 1);

ColumnArray::Offset nested_array_size = nested_offsets[j] - nested_offsets[j - 1];

result_data_size += nested_array_size;

}

}

/// Allocate enough memory in advance

result_data.resize(result_data_size);

result_offsets.resize(size);

if constexpr (nullable_number)

result_number_null_map->resize(result_data_size);

ColumnArray::Offset current_offset = 0;

for (size_t i = 0; i < size; ++i)

{

size_t array_size = offsets[i] - offsets[i - 1];

if (index < array_size)

{

size_t j = !negative ? (offsets[i - 1] + index) : (offsets[i] - index - 1);

builder.update(j);

ColumnArray::Offset nested_array_size = nested_offsets[j] - nested_offsets[j - 1];

ColumnArray::Offset nested_array_pos = nested_offsets[j - 1];

memcpy(&result_data[current_offset], &data[nested_array_pos], nested_array_size * sizeof(T));

if constexpr (nullable_number)

memcpy(&(*result_number_null_map)[current_offset], &(*number_null_map)[nested_array_pos], nested_array_size);

current_offset += nested_array_size;

}

else

{

/// Empty Array(T), no need to copy anything

builder.update();

}

result_offsets[i] = current_offset;

}

}

/** Implementation for non-constant index.

template <typename TIndex, bool nullable_number>

static void vector(

const PaddedPODArray<T> & data,

const ColumnArray::Offsets & offsets,

const ColumnArray::Offsets & nested_offsets,

const NullMap * number_null_map,

const PaddedPODArray<TIndex> & indices,

PaddedPODArray<T> & result_data,

ColumnArray::Offsets & result_offsets,

NullMap * result_number_null_map,

ArrayImpl::NullMapBuilder<mode> & builder)

{

size_t size = offsets.size();

/// First calculate the size of result_data or result_number_null_map

size_t result_data_size = 0;

for (size_t i = 0; i < size; ++i)

{

size_t array_size = offsets[i] - offsets[i - 1];

TIndex index = indices[i];

if (index > 0 && static_cast<size_t>(index) <= array_size)

{

size_t j = offsets[i - 1] + index - 1;

ColumnArray::Offset nested_array_size = nested_offsets[j] - nested_offsets[j - 1];

result_data_size += nested_array_size;

}

else if (index < 0 && -static_cast<size_t>(index) <= array_size)

{

size_t j = offsets[i] + index;

ColumnArray::Offset nested_array_size = nested_offsets[j] - nested_offsets[j - 1];

result_data_size += nested_array_size;

}

}

/// Allocate enough memory in advance

result_data.resize(result_data_size);

result_offsets.resize(size);

if constexpr (nullable_number)

result_number_null_map->resize(result_data_size);

ColumnArray::Offset current_offset = 0;

for (size_t i = 0; i < size; ++i)

{

size_t array_size = offsets[i] - offsets[i - 1];

TIndex index = indices[i];

if (index > 0 && static_cast<size_t>(index) <= array_size)

{

size_t j = offsets[i - 1] + index - 1;

builder.update(j);

ColumnArray::Offset nested_array_size = nested_offsets[j] - nested_offsets[j - 1];

ColumnArray::Offset nested_array_pos = nested_offsets[j - 1];

memcpy(&result_data[current_offset], &data[nested_array_pos], nested_array_size * sizeof(T));

if constexpr (nullable_number)

memcpy(&(*result_number_null_map)[current_offset], &(*number_null_map)[nested_array_pos], nested_array_size);

current_offset += nested_array_size;

}

else if (index < 0 && -static_cast<size_t>(index) <= array_size)

{

size_t j = offsets[i] + index;

builder.update(j);

ColumnArray::Offset nested_array_size = nested_offsets[j] - nested_offsets[j - 1];

ColumnArray::Offset nested_array_pos = nested_offsets[j - 1];

memcpy(&result_data[current_offset], &data[nested_array_pos], nested_array_size * sizeof(T));

if constexpr (nullable_number)

memcpy(&(*result_number_null_map)[current_offset], &(*number_null_map)[nested_array_pos], nested_array_size);

current_offset += nested_array_size;

}

else

{

/// Empty Array(T), no need to copy anything

builder.update();

}

result_offsets[i] = current_offset;

}

}

{

/// nullable_string is true when process input with type Array(Array(Nullable(String)))

template <bool negative, bool nullable_string>

static void vectorConst(

const ColumnString::Chars & data,

const ColumnArray::Offsets & offsets,

const ColumnArray::Offsets & nested_offsets,

const ColumnString::Offsets & string_offsets,

const NullMap * string_null_map,

const ColumnArray::Offset index,

ColumnString::Chars & result_data,

ColumnArray::Offsets & result_offsets,

ColumnArray::Offsets & result_string_offsets,

NullMap * result_string_null_map,

ArrayImpl::NullMapBuilder<mode> & builder)

{

size_t size = offsets.size();

/// First calculate size of result_data(total count of strings) and result_string_offsets(total size of strings)

size_t result_data_size = 0;

size_t result_strings_size = 0;

for (size_t i = 0; i < size; ++i)

{

size_t array_size = offsets[i] - offsets[i - 1];

if (index < array_size)

{

size_t adjusted_index = !negative ? index : (array_size - index - 1);

size_t j = offsets[i - 1] + adjusted_index;

auto nested_array_start = nested_offsets[j - 1];

auto nested_array_size = nested_offsets[j] - nested_array_start;

result_data_size += string_offsets[nested_array_start + nested_array_size - 1] - string_offsets[nested_array_start - 1];

result_strings_size += nested_array_size;

}

}

/// Allocate enough memory in advance

result_data.resize(result_data_size);

result_offsets.resize(size);

result_string_offsets.reserve(result_strings_size);

if constexpr (nullable_string)

result_string_null_map->reserve(result_strings_size);

ColumnArray::Offset current_offset = 0;

ColumnArray::Offset current_string_offset = 0;

for (size_t i = 0; i < size; ++i)

{

size_t array_size = offsets[i] - offsets[i - 1];

if (index < array_size)

{

size_t adjusted_index = !negative ? index : (array_size - index - 1);

size_t j = offsets[i - 1] + adjusted_index;

builder.update(j);

auto nested_array_start = nested_offsets[j - 1];

auto nested_array_size = nested_offsets[j] - nested_array_start;

/// For each String in Array(String), append it to result_data and update result_offsets and result_string_offsets

for (size_t k = 0; k < nested_array_size; ++k)

{

auto string_start = string_offsets[nested_array_start + k - 1];

auto string_size = string_offsets[nested_array_start + k] - string_start;

memcpySmallAllowReadWriteOverflow15(&result_data[current_string_offset], &data[string_start], string_size);

current_string_offset += string_size;

result_string_offsets.push_back(current_string_offset);

if constexpr (nullable_string)

result_string_null_map->push_back((*string_null_map)[nested_array_start + k]);

}

current_offset += nested_array_size;

}

else

{

/// Insert empty Array(String) or Array(Nullable(String)), no need to copy anything

builder.update();

}

result_offsets[i] = current_offset;

}

}

/** Implementation for non-constant index.

template <typename TIndex, bool nullable_string>

static void vector(

const ColumnString::Chars & data,

const ColumnArray::Offsets & offsets,

const ColumnArray::Offsets & nested_offsets,

const ColumnString::Offsets & string_offsets,

const NullMap * string_null_map,

const PaddedPODArray<TIndex> & indices,

ColumnString::Chars & result_data,

ColumnArray::Offsets & result_offsets,

ColumnArray::Offsets & result_string_offsets,

NullMap * result_string_null_map,

ArrayImpl::NullMapBuilder<mode> & builder)

{

size_t size = offsets.size();

/// First calculate size of result_data(total count of strings) and result_string_offsets(total size of strings)

size_t result_data_size = 0;

size_t result_strings_size = 0;

for (size_t i = 0; i < size; ++i)

{

size_t array_size = offsets[i] - offsets[i - 1];

size_t adjusted_index = 0; /// index in array from zero

TIndex index = indices[i];

if (index > 0 && static_cast<size_t>(index) <= array_size)

adjusted_index = index - 1;

else if (index < 0 && -static_cast<size_t>(index) <= array_size)

adjusted_index = array_size + index;

else

adjusted_index = array_size; /// means no element should be taken

if (adjusted_index < array_size)

{

size_t j = offsets[i - 1] + adjusted_index;

auto nested_array_start = nested_offsets[j - 1];

auto nested_array_size = nested_offsets[j] - nested_array_start;

result_data_size += string_offsets[nested_array_start + nested_array_size - 1] - string_offsets[nested_array_start - 1];

result_strings_size += nested_array_size;

}

}

/// Allocate enough memory in advance

result_data.resize(result_data_size);

result_offsets.resize(size);

result_string_offsets.reserve(result_strings_size);

if constexpr (nullable_string)

result_string_null_map->reserve(result_strings_size);

ColumnArray::Offset current_offset = 0;

ColumnArray::Offset current_string_offset = 0;

for (size_t i = 0; i < size; ++i)

{

size_t array_size = offsets[i] - offsets[i - 1];

size_t adjusted_index = 0; /// index in array from zero

TIndex index = indices[i];

if (index > 0 && static_cast<size_t>(index) <= array_size)

adjusted_index = index - 1;

else if (index < 0 && -static_cast<size_t>(index) <= array_size)

adjusted_index = array_size + index;

else

adjusted_index = array_size; /// means no element should be taken

if (adjusted_index < array_size)

{

size_t j = offsets[i - 1] + adjusted_index;

builder.update(j);

auto nested_array_start = nested_offsets[j - 1];

auto nested_array_size = nested_offsets[j] - nested_array_start;

/// For each String in Array(String), append it to result_data and update result_offsets and result_string_offsets

for (size_t k = 0; k < nested_array_size; ++k)

{

auto string_start = string_offsets[nested_array_start + k - 1];

auto string_size = string_offsets[nested_array_start + k] - string_start;

memcpySmallAllowReadWriteOverflow15(&result_data[current_string_offset], &data[string_start], string_size);

current_string_offset += string_size;

result_string_offsets.push_back(current_string_offset);

if constexpr (nullable_string)

result_string_null_map->push_back((*string_null_map)[nested_array_start + k]);

}

current_offset += nested_array_size;

}

else

{

/// Insert empty Array(String), no need to copy anything

builder.update();

}

result_offsets[i] = current_offset;

}

}

{

template <bool negative>

static void vectorConst(

const ColumnString::Chars & data,

const ColumnArray::Offsets & offsets,

const ColumnString::Offsets & string_offsets,

const ColumnArray::Offset index,

ColumnString::Chars & result_data,

ColumnArray::Offsets & result_offsets,

ArrayImpl::NullMapBuilder<mode> & builder)

{

size_t size = offsets.size();

result_offsets.resize(size);

ColumnArray::Offset current_offset = 0;

/// get the total result bytes at first, and reduce the cost of result_data.resize.

size_t total_result_bytes = 0;

VectorWithMemoryTracking<std::pair<const ColumnString::Char *, UInt64>> selected_bufs;

selected_bufs.reserve(size);

for (size_t i = 0; i < size; ++i)

{

size_t array_size = offsets[i] - current_offset;

if (index < array_size)

{

size_t adjusted_index = 0;

if constexpr (negative)

adjusted_index = array_size - index - 1;

else

adjusted_index = index;

size_t j = current_offset + adjusted_index;

builder.update(j);

ColumnArray::Offset string_pos

= current_offset == 0 && adjusted_index == 0 ? 0 : string_offsets[current_offset + adjusted_index - 1];

ColumnArray::Offset string_size = string_offsets[current_offset + adjusted_index] - string_pos;

total_result_bytes += string_size;

selected_bufs.emplace_back(&data[string_pos], string_size);

result_offsets[i] = total_result_bytes;

}

else

{

result_offsets[i] = total_result_bytes;

builder.update();

}

current_offset = offsets[i];

}

ColumnArray::Offset current_result_offset = 0;

result_data.resize(total_result_bytes);

for (const auto & buf : selected_bufs)

{

memcpySmallAllowReadWriteOverflow15(&result_data[current_result_offset], buf.first, buf.second);

current_result_offset += buf.second;

}

}

/** Implementation for non-constant index.

template <typename TIndex>

static void vector(

const ColumnString::Chars & data,

const ColumnArray::Offsets & offsets,

const ColumnString::Offsets & string_offsets,

const PaddedPODArray<TIndex> & indices,

ColumnString::Chars & result_data,

ColumnArray::Offsets & result_offsets,

ArrayImpl::NullMapBuilder<mode> & builder)

{

size_t size = offsets.size();

result_offsets.resize(size);

ColumnArray::Offset current_offset = 0;

/// get the total result bytes at first, and reduce the cost of result_data.resize.

size_t total_result_bytes = 0;

VectorWithMemoryTracking<std::pair<const ColumnString::Char *, UInt64>> selected_bufs;

selected_bufs.reserve(size);

for (size_t i = 0; i < size; ++i)

{

size_t array_size = offsets[i] - current_offset;

size_t adjusted_index = 0; /// index in array from zero

TIndex index = indices[i];

if (index > 0 && static_cast<size_t>(index) <= array_size)

adjusted_index = index - 1;

else if (index < 0 && -static_cast<size_t>(index) <= array_size)

adjusted_index = array_size + index;

else

adjusted_index = array_size; /// means no element should be taken

if (adjusted_index < array_size)

{

size_t j = current_offset + adjusted_index;

builder.update(j);

ColumnArray::Offset string_pos

= current_offset == 0 && adjusted_index == 0 ? 0 : string_offsets[current_offset + adjusted_index - 1];

ColumnArray::Offset string_size = string_offsets[current_offset + adjusted_index] - string_pos;

total_result_bytes += string_size;

selected_bufs.emplace_back(&data[string_pos], string_size);

result_offsets[i] = total_result_bytes;

}

else

{

result_offsets[i] = total_result_bytes;

builder.update();

}

current_offset = offsets[i];

}

ColumnArray::Offset current_result_offset = 0;

result_data.resize(total_result_bytes);

for (const auto & buf : selected_bufs)

{

memcpySmallAllowReadWriteOverflow15(&result_data[current_result_offset], buf.first, buf.second);

current_result_offset += buf.second;

}

}

{

template <bool negative>

static void vectorConst(

const IColumn & data,

const ColumnArray::Offsets & offsets,

const ColumnArray::Offset index,

IColumn & result,

ArrayImpl::NullMapBuilder<mode> & builder)

{

size_t size = offsets.size();

result.reserve(size);

ColumnArray::Offset current_offset = 0;

for (size_t i = 0; i < size; ++i)

{

size_t array_size = offsets[i] - current_offset;

if (index < array_size)

{

size_t j = !negative ? current_offset + index : offsets[i] - index - 1;

result.insertFrom(data, j);

builder.update(j);

}

else

{

result.insertDefault();

builder.update();

}

current_offset = offsets[i];

}

}

/** Implementation for non-constant index.

template <typename TIndex>

static void vector(

const IColumn & data,

const ColumnArray::Offsets & offsets,

const PaddedPODArray<TIndex> & indices,

IColumn & result,

ArrayImpl::NullMapBuilder<mode> & builder)

{

size_t size = offsets.size();

result.reserve(size);

ColumnArray::Offset current_offset = 0;

for (size_t i = 0; i < size; ++i)

{

size_t array_size = offsets[i] - current_offset;

TIndex index = indices[i];

if (index > 0 && static_cast<size_t>(index) <= array_size)

{

size_t j = current_offset + index - 1;

result.insertFrom(data, j);

builder.update(j);

}

else if (index < 0 && -static_cast<size_t>(index) <= array_size)

{

size_t j = offsets[i] + index;

result.insertFrom(data, j);

builder.update(j);

}

else

{

result.insertDefault();

builder.update();

}

current_offset = offsets[i];

}

}