text stringlengths 14 100k | source stringclasses 1
value | repo stringclasses 810
values | language stringclasses 13
values |
|---|---|---|---|
<|fim_suffix|> if (level)
place_offset = place_offsets[level - 1];
true_func->merge(place, places[place_offset + (place_curr >> level)], arena.get());
place_curr += 1 << level;
}
}
... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>Equals(arr, replicated_elem_col)
filter_col = BuildAndExecuteFunction(not_equals_resolver,
{{arr_data_col, arr_data_type, "arr"},
{arguments[1].column->replicate(arr_offsets), elem_type, "elem"}}, arr_elements_count);
}
else
{
// Filter = NOT if(
... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>Nulls() const override { return false; }
bool useDefaultImplementationForConstants() const override { return true; }
bool isSuitableForShortCircuitArgumentsExecution(const DataTypesWithConstInfo & /*arguments*/) const override { return true; }
DataTypePtr getReturnTypeImpl(const DataTypes & a... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|> appended_column = arguments[2].column;
if (!arguments[2].type->equals(*return_nested_type))
appended_column = castColumn(arguments[2], return_nested_type);
}
else
{
auto default_column = result_array.getData().cloneEmpty();
default_column->insertDefault()... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <Functions/IFunction.h>
#include <Interpreters/Context_fwd.h>
namespace DB
{
class FunctionArrayResize final : public IFunction
{
public:
static constexpr auto name = "arrayResize";
static FunctionPtr createImpl() { return std::make_shared<FunctionArrayResize>(); }
stat... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Functions/IFunction.h>
#include <Functions/FunctionFactory.h>
#include <Functions/FunctionHelpers.h>
#include <DataTypes/DataTypeArray.h>
#include <Columns/ColumnArray.h>
#include <Columns/ColumnNullable.h>
#include <Columns/ColumnString.h>
#include <Columns/ColumnFixedString.h>
#include <Common... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <limits>
#include <Columns/ColumnArray.h>
#include <DataTypes/DataTypeArray.h>
#include <DataTypes/getLeastSupertype.h>
#include <Functions/FunctionFactory.h>
#include <Functions/FunctionHelpers.h>
#include <Functions/IFunction.h>
#include <Interpreters/castColumn.h>
namespace DB
{
namespace Er... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>s();
const auto & arr_values = col_array->getData();
auto col_res_data = arr_values.cloneEmpty();
auto col_res_inner_offsets = ColumnArray::ColumnOffsets::create();
auto col_res_outer_offsets = ColumnArray::ColumnOffsets::create();
IColumn::Offsets & out_offsets_2 ... | fim | ClickHouse/ClickHouse | cpp |
#include <Columns/ColumnArray.h>
#include <Columns/ColumnString.h>
#include <DataTypes/DataTypeArray.h>
#include <Functions/FunctionFactory.h>
#include <Functions/FunctionHelpers.h>
#include <Functions/IFunction.h>
#include <Common/iota.h>
#include <Common/randomSeed.h>
#include <Common/shuffle.h>
#include <Common/type... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>nput_rows_count);
auto array_column = arguments[0].column;
const auto & offset_column = arguments[1].column;
const auto & length_column = arguments.size() > 2 ? arguments[2].column : nullptr;
std::unique_ptr<GatherUtils::IArraySource> source;
size_t size = array_... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>rray in ascending order.
If a lambda function `f` is specified, sorting order is determined by the result of
the lambda applied to each element of the array.
If the lambda accepts multiple arguments, the `arraySort` function is passed several
arrays that the arguments of `f` will correspond to.
If the ar... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>Name(),
name);
}
static ColumnPtr execute(
const ColumnArray & array,
ColumnPtr mapped,
const ColumnWithTypeAndName * fixed_arguments [[maybe_unused]] = nullptr);
};
struct NameArraySort
{
static constexpr auto name = "arraySort";
};
struct NameArrayRe... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Columns/ColumnsNumber.h>
#include <DataTypes/DataTypesNumber.h>
#include <Functions/FunctionFactory.h>
#include <Functions/array/FunctionArrayMapped.h>
namespace DB
{
namespace ErrorCodes
{
extern const int ILLEGAL_COLUMN;
}
template <bool reverse>
struct ArraySplitImpl
{
static bool... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|> returned_value, examples, introduced_in, category};
factory.registerFunction<FunctionArrayBottomK>(documentation);
}
}
<|fim_prefix|>#include <Functions/array/arrayTopK.h>
#include <Columns/ColumnArray.h>
#include <Columns/ColumnDecimal.h>
#include <Columns/ColumnFixedString.h>
#include <Columns/C... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>/ `LowCardinality` is already stripped recursively by IFunctionOverloadResolver::getReturnType()
/// (via the default `useDefaultImplementationForLowCardinalityColumns`), so only `Nullable` is left to handle.
chassert(!array_element->lowCardinality());
return std::make_shared<DataT... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Functions/IFunction.h>
#include <Functions/FunctionFactory.h>
#include <Functions/FunctionHelpers.h>
#include <DataTypes/DataTypeArray.h>
#include <Columns/ColumnArray.h>
#include <Columns/ColumnDecimal.h>
#include <Columns/ColumnNullable.h>
#include <Columns/ColumnTuple.h>
#include <Columns/Col... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <Functions/IFunction.h>
#include <Functions/FunctionFactory.h>
#include <Functions/FunctionHelpers.h>
#include <DataTypes/DataTypeArray.h>
#include <DataTypes/DataTypesNumber.h>
#include <Columns/ColumnArray.h>
#include <Columns/ColumnConst.h>
#include <Columns/ColumnNullable.h>
#include <Columns... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <Functions/IFunction.h>
#include <Functions/FunctionFactory.h>
#include <DataTypes/DataTypeArray.h>
#include <DataTypes/DataTypesNumber.h>
#include <Columns/ColumnArray.h>
#include <base/arithmeticOverflow.h>
namespace DB
{
namespace ErrorCodes
{
extern const int ILLEGAL_TYPE_OF_ARGUMENT;
... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>st override { return function_name; }
bool isVariadic() const override { return true; }
size_t getNumberOfArguments() const override { return 0; }
bool useDefaultImplementationForConstants() const override { return true; }
bool isSuitableForShortCircuitArgumentsExecution(const DataTypesW... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>s in the array equal to `x`", {"UInt64"}};
FunctionDocumentation::Examples example = {{"Usage example", "SELECT countEqual([1, 2, NULL, NULL], NULL)", "2"}};
FunctionDocumentation::IntroducedIn introduced_in = {1, 1};
FunctionDocumentation::Category category = FunctionDocumentation::Category::... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>tr context_);
FunctionPtr createFunctionArrayL2DistanceTransposed(ContextPtr context_)
{
return FunctionArrayDistance<L2DistanceTransposed>::create(context_);
}
FunctionPtr createFunctionArrayCosineDistanceTransposed(ContextPtr context_)
{
return FunctionArrayDistance<CosineDistanceTransposed>::... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>ctionDocumentation::Category category = FunctionDocumentation::Category::Array;
FunctionDocumentation documentation = {description, syntax, arguments, {}, returned_value, examples, introduced_in, category};
factory.registerFunction(
FunctionEmptyArray::getNameImpl(element_type),
[... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>ctionEmptyArrayToSingle::executeImpl(const ColumnsWithTypeAndName & arguments, const DataTypePtr & result_type, size_t input_rows_count) const
{
if (auto res = FunctionEmptyArrayToSingleImpl::executeConst(arguments, result_type, input_rows_count))
return res;
const ColumnArray * array = c... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <Functions/IFunction.h>
#include <Interpreters/Context_fwd.h>
namespace DB
{
/** emptyArrayToSingle(arr) - replace empty arrays with arrays of one element with a default value.
*/
class FunctionEmptyArrayToSingle final : public IFunction
{
public:
static constexpr auto name =... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>path", R"(SELECT has('{"a": {"b": 1}}'::JSON, 'a.b'))", "1"}
};
FunctionDocumentation::IntroducedIn introduced_in = {1, 1};
FunctionDocumentation::Category category = FunctionDocumentation::Category::Array;
FunctionDocumentation documentation = {description, syntax, arguments, {}, returned... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>dResolver();
}
<|fim_prefix|>#pragma once
#include <memory>
namespace DB
{
class IFunctionOverloadResolver;
using FunctionOverloadResolverPtr = std::shared_ptr<IFunctionOverloadResolver>;
FunctionOverloadResolverPtr cr<|fim_middle|>eateInternalFunctionHasOverloa<|endoftext|> | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Functions/array/hasAllAny.h>
#include <Functions/FunctionFactory.h>
#include <Functions/GatherUtils/GatherUtils.h>
namespace DB
{
class FunctionArrayHasAll final : public FunctionArrayHasAllAny
{
public:
static constexpr auto name = "hasAll";
static FunctionPtr create(ContextPtr) { re... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <base/range.h>
#include <Functions/IFunction.h>
#include <Functions/FunctionFactory.h>
#include <Functions/GatherUtils/GatherUtils.h>
#include <DataTypes/DataTypeArray.h>
#include <DataTypes/DataTypesNumber.h>
#include <DataTypes/DataTypeNothing.h>
#include <DataTypes/getLeastSuper... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Functions/array/hasAllAny.h>
#include <Functions/FunctionFactory.h>
#include <Functions/GatherUtils/GatherUtils.h>
namespace DB
{
class FunctionArrayHasAny final : public FunctionArrayHasAllAny
{
public:
static constexpr auto name = "hasAny";
static FunctionPtr create(ContextPtr) { re... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <Functions/array/hasAllAny.h>
#include <Functions/FunctionFactory.h>
#include <Functions/GatherUtils/GatherUtils.h>
namespace DB
{
class FunctionArrayHasSubstr final : public FunctionArrayHasAllAny
{
public:
static constexpr auto name = "hasSubstr";
static FunctionPtr create(ContextPtr... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <Functions/array/arrayIndex.h>
#include <Functions/FunctionFactory.h>
namespace DB
{
struct NameIndexOf { static constexpr auto name = "indexOf"; };
using FunctionIndexOf = FunctionArrayIndex<IndexOfAction, NameIndexOf>;
REGISTER_FUNCTION(IndexOf)
{
FunctionDocumentation::Description descr... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>:::note
Unlike the `indexOf` function, this function assumes that the array is sorted in
ascending order. If the array is not sorted, results are undefined.
:::
)";
FunctionDocumentation::Syntax syntax = "indexOfAssumeSorted(arr, x)";
FunctionDocumentation::Arguments arguments = {
{"ar... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>T_LENGTH", "length", FunctionFactory::Case::Insensitive);
/// `CARDINALITY` is a SQL-standard / PostgreSQL spelling for the array-length operator.
/// In ClickHouse it is a full alias of `length`, so it inherits `length`'s behavior for non-array arguments too
/// (e.g. it returns the byte leng... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <Functions/FunctionFactory.h>
#include <Functions/FunctionStringOrArrayToT.h>
<|fim_suffix|>ic void vectorFixedToVector(const ColumnString::Chars & /*data*/, size_t /*n*/, PaddedPODArray<UInt64> & /*res*/, size_t)
{
}
static void array(const ColumnString::Offsets & of... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Columns/ColumnFixedString.h>
#include <Columns/ColumnMap.h>
#include <Columns/ColumnString.h>
#include <Columns/ColumnTuple.h>
#include <Columns/ColumnVector.h>
#include <Columns/IColumn.h>
#include <Core/ColumnWithTypeAndName.h>
#include <DataTypes/DataTypeArray.h>
#include <DataTypes/DataTypeM... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <base/sort.h>
#include <Core/ColumnWithTypeAndName.h>
#include <Core/callOnTypeIndex.h>
#include <Columns/ColumnArray.h>
#include <Columns/ColumnMap.h>
#include <Columns/ColumnTuple.h>
#include <Columns/ColumnVector.h>
#include <DataTypes/IDataType.h>
#include <DataTypes/DataTypeArray.h>
#includ... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>col = ColumnVector<T>::create(total_values);
auto offsets_col = ColumnArray::ColumnOffsets::create(end_column->size());
auto & out_data = data_col->getData();
auto & out_offsets = offsets_col->getData();
IColumn::Offset offset{};
for (size_t row_idx = 0; row_idx <... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>an empty string by default.
)";
FunctionDocumentation::Syntax syntax = "arrayStringConcat(arr[, separator])";
FunctionDocumentation::Arguments arguments = {
{"arr", "The array to concatenate.", {"Array(T)"}},
{"separator", "Optional. Separator string. By default an empty string.", ... | fim | ClickHouse/ClickHouse | cpp |
#include <DataTypes/DataTypeString.h>
#include <Functions/FunctionFactory.h>
#include <Functions/FunctionStringOrArrayToT.h>
namespace DB
{
namespace ErrorCodes
{
extern const int ILLEGAL_TYPE_OF_ARGUMENT;
extern const int NOT_IMPLEMENTED;
}
struct AsciiName
{
static constexpr auto name = "ascii";
};
s... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <Functions/Funct<|fim_suffix|>t returns the value in the range of `[-pi() / 2, pi() / 2]`.
)";
FunctionDocumentation::Syntax syntax = "asin(x)";
FunctionDocumentation::Arguments argument = {
{"x", "Argument for which to calculate arcsine of.", {"(U)Int*", "Float*", "Decimal"}}... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include<|fim_suffix|>alue = {"Returns the angle, in radians. Values from the interval: `-β < asinh(x) < +β`.", {"Float64"}};
FunctionDocumentation::Examples examples = {
{"Basic usage", "SELECT asinh(0)", "0"}
};
FunctionDocumentation::IntroducedIn introduced_in = {20, 12};
Functi... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|> a value of type [`Nullable`](../data-types/nullable.md).
If the original value is `NULL`, an arbitrary result can be returned.
See also: functions [`ifNull`](#ifNull) and [`coalesce`](#coalesce).
)";
FunctionDocumentation::Syntax syntax = "assumeNotNull(x)";
FunctionDocumentation::Arguments ... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|> FunctionDocumentation::ReturnedValue returned_value = {"Returns the arc tangent of `x`.", {"Float*"}};
FunctionDocumentation::Examples examples = {{"Usage example", "SELECT atan(1);", "0.7853981633974483"}};
FunctionDocumentation::IntroducedIn introduced_in = {1, 1};
FunctionDocumentation::C... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <Functions/FunctionFactory.h>
#include <Functions/FunctionMathBi<|fim_suffix|>, "x-coordinate of the point through which the ray passes.", {"(U)Int*", "Float*", "Decimal*"}}
};
FunctionDocumentation::ReturnedValue returned_value = {"Returns the angle `ΞΈ` such that `-Ο < ΞΈ β€ Ο`, in radians... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <Functions/FunctionFactory.h>
#include <Functions/FunctionMathUnary.h>
namespace DB
{
namespace
{
struct AtanhName
{
static constexpr auto name = "atanh";
};
using FunctionAtanh = FunctionMathUnary<UnaryFunctionVectorized<AtanhName, atanh>>;
}
REGISTER_FUNCTION(Atanh)
{
FunctionDocume... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <Columns/ColumnConst.h>
#include <Functions/IFunction.h>
#include <Functions/FunctionFactory.h>
#include <Interpreters/Context.h>
#include <DataTypes/DataTypeString.h>
#include <Core/Field.h>
namespace DB
{
namespace
{
class FunctionAuthenticatedUser final : public IFunction
{
const String... | fim | ClickHouse/ClickHouse | cpp |
#include <Functions/FunctionBinaryArithmetic.h>
#include <Functions/FunctionFactory.h>
#include <Functions/midpoint.h>
namespace DB
{
struct NameMidpoint
{
static constexpr auto name = "midpoint";
};
using FunctionMidpointBinary = FunctionBinaryArithmetic<MidpointImpl, NameMidpoint>;
template <typename Specializ... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <Functions/IFunction.h>
#include <Functions/FunctionFactory.h>
#include <DataTypes/DataTypeString.h>
#include <Columns/ColumnString.h>
#include <Common/UnicodeBar.h>
#include <IO/WriteHelpers.h>
namespace DB
{
namespace ErrorCodes
{
extern const int NUMBER_OF_ARGUMENTS_DOESNT_MATCH;
ex... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>yntax, arguments, {}, returned_value, examples, introduced_in, category};
factory.registerFunction<FunctionBase32Decode>(documentation);
}
}
<|fim_prefix|>#include <Functions/FunctionBase32Conversion.h>
#include <Functions/FunctionFactory.h>
namespace DB
{
namespace
{
struct NameBase32Decode
{
s... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <Functions/FunctionBase32Conversion.h>
#include <Functions/FunctionFactory.h>
namespace DB
{
namespace
{
struct NameBase32Encode
{
static constexpr auto name = "base32Encode";
};
using Base32EncodeImpl = BaseXXEncode<Base32Encod<|fim_suffix|>n, syntax, arguments, {}, returned_value, example... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>ption, syntax, arguments, {}, returned_value, examples, introduced_in, category};
factory.registerFunction<FunctionBase58Decode>(documentation);
}
}
<|fim_prefix|>#include <Functions/FunctionBase<|fim_middle|>58Conversion.h>
#include <Functions/FunctionFactory.h>
namespace DB
{
namespace
{
struct N... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <Functions/FunctionBase58Conversion.h>
#include <Functions/FunctionFactory.h>
namespace DB
{
namespace
{
struct NameBase58Encode
{
static constexpr auto name = "base58Encode";
};
using Base58EncodeImpl = BaseXXEncode<Base58EncodeTraits, NameBase58Encode>;
using FunctionBase58Encode = Functi... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|> or constant to decode. If the string is not valid Base64-encoded, an exception is thrown.", {"String"}}
};
FunctionDocumentation::ReturnedValue returned_value = {"Returns the decoded string.", {"String"}};
FunctionDocumentation::Examples examples = {
{
"Usage example",
"SE... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <Functions/FunctionBase64Conversion.h>
#if USE_BASE64
#include <Functions/FunctionFactory.h>
namespace DB
{
namespace
{
struct NameBase64Encode
{
static constexpr auto name = "base64Encode";
};
using Base64EncodeImpl = BaseXXEncode<Base64EncodeTraits<Base64Variant::Normal>, NameBase64Encode>;
... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>ctionDocumentation::Category category = FunctionDocumentation::Category::String;
FunctionDocumentation documentation = {description, syntax, arguments, {}, returned_value, examples, introduced_in, category};
factory.registerFunction<FunctionBase64Decode>(documentation);
}
}
#endif
<|fim_prefix|... | fim | ClickHouse/ClickHouse | cpp |
#include <Functions/FunctionBase64Conversion.h>
#if USE_BASE64
#include <Functions/FunctionFactory.h>
namespace DB
{
namespace
{
struct NameBase64Encode
{
static constexpr auto name = "base64URLEncode";
};
using Base64EncodeImpl = BaseXXEncode<Base64EncodeTraits<Base64Variant::URL>, NameBase64Encode>;
using Function... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>mpty())
{
finalizeRow(human_readable_part_offsets, human_readable_part_pos, human_readable_part_begin, i);
finalizeRow(data_offsets, data_pos, data_begin, i);
updatePrevOffset(prev_offset, new_offset, col_width);
continue;
... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <Functions/FunctionFactory.h>
#include <Functions/FunctionBinaryArithmetic.h>
namespace DB
{
namespace ErrorCodes
{
extern const int LOGICAL_ERROR;
}
namespace
{
template <typename A, typename B>
struct BitAndImpl
{
using ResultType = typename NumberTraits::ResultOfBit<A, B>::Type;
... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <Functions/FunctionFactory.h>
#include <Functions/FunctionBinaryArithmetic.h>
#include <DataTypes/NumberTraits.h>
namespace DB
{
namespace ErrorCodes
{
extern const int BAD_ARGUMENTS;
}
namespace
{
/// Working with UInt8: last bit = can be true, previous = can be false (Like src/Storages/... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>)
{
factory.registerFunction<FunctionBitBoolMaskOr>(FunctionDocumentation::INTERNAL_FUNCTION_DOCS);
}
}
<|fim_prefix|>#include <Functions/FunctionFactory.h>
#include <Functions/FunctionBinaryArithmetic.h>
#include <DataTypes/Nu<|fim_middle|>mberTraits.h>
#include <Common/FunctionDocumentation.h>
na... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>ation::Arguments arguments = {
{"x", "An integer or float value.", {"(U)Int*", "Float*"}},
};
FunctionDocumentation::ReturnedValue returned_value = {R"(
Returns the number of bits set to one in `x`. [`UInt8`](../data-types/int-uint.md).
:::note
The function does not convert the input valu... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <Functions/FunctionBinaryArithmetic.h>
#include <Functions/FunctionFactory.h>
#include <bit>
namespace DB
{
namespace ErrorCodes
{
extern const int ILLEGAL_COLUMN;
}
template <typename A, typename B>
struct BitHammingDistanceImpl
{
using ResultType = std::conditional_t<(sizeof(A) * 8 ... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|> 11111010 β
ββββββββββββ΄ββββββββββββββββββ΄βββββββββ΄ββββββββββββββββ
)"}};
FunctionDocumentation::IntroducedIn introduced_in = {1, 1};
FunctionDocumentation::Category category = FunctionDocumentation::Category::Bit;
FunctionDocumentation documentation = {description, syntax, argume... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <Functions/FunctionFactory.h>
#include <Functions/FunctionBinaryArithmetic.h>
namespace DB
{
namespace ErrorCodes
{
extern const int LOGICAL_ERROR;
}
namespace
{
template <typename A, typename B>
struct BitOrImpl
{
using ResultType = typename NumberTraits::ResultOfBit<A, B>::Type;
... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>STER_FUNCTION(BitRotateLeft)
{
FunctionDocumentation::Description description = "Rotate bits left by a certain number of positions. Bits that fall off wrap around to the right.";
FunctionDocumentation::Syntax syntax = "bitRotateLeft(a, N)";
FunctionDocumentation::Arguments arguments = {
... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|> β 216 β 11011000 β
ββββββ΄βββββββββββ΄ββββββββββββ΄βββββββββββββββββ
)"}
};
FunctionDocumentation::IntroducedIn introduced_in = {1, 1};
FunctionDocumentation::Category category = FunctionDocumentation::Category::Bit;
FunctionDocumentation documentation = {description, syn... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <Functions/FunctionFactory.h>
#include <Functions/FunctionBinaryArithmetic.h>
namespace DB
{
namespace ErrorCodes
{
extern const int ARGUMENT_OUT_OF_BOUND;
extern const int NOT_IMPLEMENTED;
extern const int LOGICAL_ERROR;
}
namespace
{
template <typename A, typename B>
struct BitSh... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <Functions/FunctionFactory.h>
#include <Functions/FunctionBinaryArithmetic.h>
namespace DB
{
namespace ErrorCodes
{
extern const int ARGUMENT_OUT_OF_BOUND;
extern const int NOT_IMPLEMENTED;
extern const int LOGICAL_ERROR;
}
namespace
{
template <typename A, typename B>
struct BitS... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>ys padded to byte boundaries (multiples of 8 bits)", {"String"}};
FunctionDocumentation::Examples examples = {{"Usage example",
R"(
SELECT bin('Hello'), bin(bitSlice('Hello', 1, 8));
SELECT bin('Hello'), bin(bitSlice('Hello', 1, 2));
SELECT bin('Hello'), bin(bitSlice('Hello', 1, 9));
SELECT bi... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <Functions/FunctionFactory.h>
#include <Functions/FunctionUnaryArithmetic.h>
#include <DataTypes/DataTypesNumber.h>
#include <DataTypes/NumberTraits.h>
namespace DB
{
namespace ErrorCodes
{
extern const int LOGICAL_ERROR;
extern const int BAD_ARGUMENTS;
}
namespace
{
/// Working with U... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|> }
#if USE_EMBEDDED_COMPILER
static constexpr bool compilable = false; /// TODO
#endif
};
struct NameBitTest { static constexpr auto name = "bitTest"; };
using FunctionBitTest = BinaryArithmeticOverloadResolver<BitTestImpl, NameBitTest, true, false>;
}
REGISTER_FUNCTION(BitTest)
{
FunctionDoc... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <Functions/FunctionFactory.h>
#include <Functions/FunctionBitTestMany.h>
namespace DB
{
namespace
{
struct BitTestAllImpl
{
template <typename A, typename B>
static UInt8 apply(A a, B b) { return (a & b) == b; }<|fim_suffix|> of all bits at the given positions.
Counts right-to-left, sta... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <Functions/FunctionFactory.h>
#include <Functions/FunctionBitTestMany.h>
namespace DB
{
namespace
{
struct BitTestAnyImpl
{
template <typename A, typename B>
static UInt8 apply(A a, B b) { return (a & b) != 0; }
};
struct NameBitTestAny { static constexpr auto name = "bitTestAny"; };
u... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>is function is always UInt8 regardless of the argument type.
/// Override `getReturnTypeForDefaultImplementationForDynamic` so that Dynamic arguments
/// produce Nullable(UInt8) instead of Dynamic. This is needed for set index evaluation
/// where the result column must be UInt8.
class FunctionBitWrapperF... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>aryArithmeticOverloadResolver<BitXorImpl, NameBitXor, true, false>;
}
REGISTER_FUNCTION(BitXor)
{
FunctionDocumentation::Description description = "Performs bitwise ""exclusive or"" (XOR) operation between two values.";
FunctionDocumentation::Syntax syntax = "bitXor(a, b)";
FunctionDocumenta... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <Functions/IFunction.h>
#include <Functions/FunctionFactory.h>
#include <DataTypes/DataTypesNumber.h>
#include <Columns/ColumnsNumber.h>
#include <atomic>
namespace DB
{
namespace
{
/** Incremental columns number among calls of this function. */
class FunctionBlockNumber final : public IFuncti... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <Columns/ColumnConst.h>
#include <Columns/IColumn.h>
#include <Functions/IFunction.h>
#include <Functions/FunctionFactory.h>
#include <DataTypes/DataTypesNumber.h>
#include <IO/NullWriteBuffer.h>
namespace DB
{
namespace
{
/// Returns size on disk for *columns* (without taking into account com... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <Functions/IFunction.h>
#include <Functions/FunctionFactory.h>
#include <DataT<|fim_suffix|>umentation::Examples examples = {
{
"Usage example",
R"(
SELECT blockSize()
FROM system.numbers LIMIT 5
)",
R"(
ββblockSize()ββ
β 5 β
β 5 β
β ... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|> '')
)",
R"(
ββbyteSize(NULL, 1, 0.3, '')ββ
β 19 β
ββββββββββββββββββββββββββββββ
)"
}
};
FunctionDocumentation::IntroducedIn introduced_in = {21, 1};
FunctionDocumentation::Category category = FunctionDocumentation::Category::Other;
Func... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <Functions/FunctionFactory.h>
#include <Functions/FunctionUnaryArithmetic.h>
namespace DB
{
namespace ErrorCodes
{
extern const int NOT_IMPLEMENTED;
}
namespace
{
template <typename T>
requires std::is_integral_v<T>
T byteSwap(T x)
{
return std::byteswap(x);
}
template <typename T>
requir... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>n into multiIf(expr = when1, then1, expr = when2, then2, ..., else)
for (size_t i = 1; i < args.size() - 1; i += 2)
{
// use CASE WHEN equality semantics (NULL = NULL is true)
auto condition = caseWhenEquals(args.front(), args[i], input_rows_count);
mul... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <Core/Settings.h>
#include <DataTypes/DataTypeFactory.h>
#include <DataTypes/DataTypeNullable.h>
#include <DataTypes/DataTypeString.h>
#include <DataTypes/DataTypesNumber.h>
#include <DataTypes/DataTypesDecimal.h>
#include <DataTypes/DataTypeDate.h>
#include <DataTypes/DataTypeDate32.h>
#include ... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <Common/typeid_cast.h>
#include <base/TypeList.h>
namespace DB
{
template <typename... Ts, typename T, typename F>
static bool castTypeToEither(const T * type, F && f)
{
return ((typeid_cast<const Ts *>(type) && f(*t<|fim_suffix|> != nullptr && f(*typeid_cast<const Args *>(typ... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>].column.get());
if (!name_col)
throw Exception(ErrorCodes::ILLEGAL_COLUMN, "First argument of function {} must be a constant string", getName());
initBridge(name_col);
auto type = getReturnTypeFromLibraryBridge();
bool has_nullable = false;
for (size... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>es, introduced_in, category};
factory.registerFunction<FunctionCbrt>(documentation);
}
}
<|fim_prefix|>#include <Functions/FunctionMathUnary.h>
#include <Functions/FunctionFactory.h>
namespace DB
{
namespace
{
struct CbrtName { static constexpr auto name = "cbrt"; };
using FunctionCbrt = FunctionM... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>tionDocumentation::IntroducedIn introduced_in = {24, 7};
FunctionDocumentation::Category category = FunctionDocumentation::Category::DateAndTime;
FunctionDocumentation function_documentation = {description, syntax, arguments, {}, returned_value, example, introduced_in, category};
f... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>s are disabled, because setting 'allow_hyperscan' is set to 0");
checkHyperscanRegexp(regexps, max_hyperscan_regexp_length, max_hyperscan_regexp_total_length);
if (reject_expensive_hyperscan_regexps)
{
SlowWithHyperscanChecker checker;
for (auto regexp : regexps)
{
... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <Common/re2.h>
#include <Common/VectorWithMemoryTracking.h>
#include <string_view>
#include <vector>
namespace DB
{
void checkHyperscanRegexp(const VectorWithMemoryTracking<std::string_view> & regexps, size_t max_hyperscan_regexp_length, size_t max_hyperscan_regexp_total_length);
... | fim | ClickHouse/ClickHouse | c |
#include <Functions/IFunction.h>
#include <Functions/FunctionFactory.h>
#include <Functions/FunctionHelpers.h>
#include <DataTypes/getLeastSupertype.h>
#include <Interpreters/castColumn.h>
#include <Interpreters/Context.h>
namespace DB
{
namespace ErrorCodes
{
extern const int NUMBER_OF_ARGUMENTS_DOESNT_MATCH;
... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>NCTION(Coalesce)
{
FunctionDocumentation::Description description = R"(
Returns the leftmost non-`NULL` argument.
)";
FunctionDocumentation::Syntax syntax = "coalesce(x[, y, ...])";
FunctionDocumentation::Arguments arguments = {
{"x[, y, ...]", "Any number of parameters of non-comp... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <Columns/ColumnVector.h>
#include <Columns/ColumnsNumber.h>
#include <Core/Field.h>
#include <DataTypes/DataTypesNumber.h>
#include <Functions/ColorConversion.h>
#include <Functions/FunctionFactory.h>
#include <Functions/ITupleFunction.h>
namespace DB
{
/** Function that converts color from OKL... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>RGB by applying `(x ^ (1 / gamma)) * 255` for each channel `x`. Defaults to `2.2`.", {"Float64"}}
};
FunctionDocumentation::ReturnedValue returned_value = {"Returns a tuple (R, G, B) representing sRGB color values.", {"Tuple(Float64, Float64, Float64)"}};
FunctionDocumentation::Examples exampl... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <Functions/ColorConversion.h>
namespace DB
{
/** Function that converts color from sRGB color space to perceptual OKLAB color space.
* Returns a tuple of type Tuple(Float64, Float64, Float64).
*/
namespace
{
class FunctionColorSRGBToOKLAB final : public ColorConversionFromSRGBBase<FunctionC... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>is designed to be perceptually uniform while remaining cheap to compute.
:::
The conversion consists of three stages:
1) sRGB to Linear sRGB
2) Linear sRGB to OKLab
3) OKLab to OKLCH.
For references of colors in the OKLCH space, and how they correspond to ... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <Columns/ColumnFixedString.h>
#include <Columns/ColumnLowCardinality.h>
#include <Columns/ColumnString.h>
#include <Columns/ColumnsNumber.h>
#include <Core/ColumnsWithTypeAndName.h>
#include <DataTypes/DataTypeString.h>
#include <DataTypes/DataTypesNumber.h>
#include <DataTypes/IDataType.h>
#incl... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <Columns/ColumnString.h>
#include <Columns/ColumnStringHelpers.h>
#include <DataTypes/DataTypeString.h>
#include <Functions/FunctionFactory.h>
#include <Functions/FunctionHelpers.h>
#include <Functions/IFunctionAdaptors.h>
#include <Functions/GatherUtils/Algorithms.h>
#include <Functions/GatherUt... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <Columns/ColumnFixedString.h>
#include <Columns/ColumnString.h>
#include <Columns/ColumnStringHelpers.h>
#include <DataTypes/DataTypeString.h>
#include <Functions/FunctionFactory.h>
#include <Functions/FunctionHelpers.h>
#include <Functions/IFunction.h>
#include <Functions/formatString.h>
#includ... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>FunctionDocumentation::Description description = R"(
Returns the connection ID of the client that submitted the current query.
This function is most useful in debugging scenarios.
It was created for compatibility with MySQL's `CONNECTION_ID` function.
It is not typically used in production queries.
)";
... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>ntation::Category::String});
}
}
<|fim_prefix|>#include <Columns/ColumnConst.h>
#include <Columns/ColumnFixedString.h>
#include <Columns/ColumnString.h>
#include <Columns/ColumnVector.h>
#include <DataTypes/DataTypeString.h>
#include <DataTypes/DataTypesNumber.h>
#include <Functions/FunctionFactory.h>
#i... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include "config.h"
#if USE_ICU
# include <Columns/ColumnConst.h>
# include <Columns/ColumnString.h>
# include <DataTypes/DataTypeString.h>
# include <Functions/FunctionFactory.h>
# include <Functions/FunctionHelpers.h>
# include <Functions/IFunction.h>
# include <IO/WriteHelpers.h>
... | fim | ClickHouse/ClickHouse | cpp |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.