text stringlengths 14 100k | source stringclasses 1
value | repo stringclasses 810
values | language stringclasses 13
values |
|---|---|---|---|
<|fim_suffix|> execute<Type>(*col_vec, *result_column, input_rows_count, precision);
return true;
}
throw Exception(ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT, "Illegal column while execute function {}", getName());
};
TypeIndex dec_type_idx = src_column.type->getT... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <Functions/isDistinctFrom.h>
#include <Functions/FunctionFactory.h>
#include <Functions/FunctionsLogical.h>
namespace DB
{
REGISTER_FUNCTION(IsDistinctFrom)
{
FunctionDocumentation::Description description = R"(
Performs a null-safe "not equals" comparison between two values.
... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <Core/AccurateComparison.h>
#incl<|fim_suffix|> DB
{
struct NameFunctionIsDistinctFrom { static constexpr auto name = "isDistinctFrom"; };
using NullSafeNotEqualImpl = DB::FunctionsNullSafeCmp<NameFunctionIsDistinctFrom,
NullSaf... | fim | ClickHouse/ClickHouse | c |
#include <Functions/FunctionNumericPredicate.h>
#include <Functions/FunctionFactory.h>
#include <type_traits>
namespace DB
{
namespace
{
struct IsFiniteImpl
{
/// Better implementation, because isinf, isfinite, isnan are not inlined for unknown reason.
/// Assuming IEEE 754.
/// NOTE gcc 7 doesn't vector... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|> "The first argument of function {} must be one of: String, IPv4, IPv6, Nullable(String), Nullable(IPv4), or "
"Nullable(IPv6) and the second argument must be String. Type of the first argument: {}, type of the second argument: {}",
getName(),
... | fim | ClickHouse/ClickHouse | cpp |
#include <Functions/FunctionNumericPredicate.h>
#include <Functions/FunctionFactory.h>
#include <type_traits>
namespace DB
{
namespace
{
struct IsInfiniteImpl
{
static constexpr auto name = "isInfinite";
template <typename T>
static bool execute(const T t)
{
if constexpr (std::is_same_v<T, fl... | fim | ClickHouse/ClickHouse | cpp |
#include <Functions/FunctionNumericPredicate.h>
#include <Functions/FunctionFactory.h>
namespace DB
{
namespace
{
struct IsNaNImpl
{
static constexpr auto name = "isNaN";
template <typename T>
static bool execute(const T t)
{
return t != t;
}
};
using FunctionIsNaN = FunctionNumericPredi... | fim | ClickHouse/ClickHouse | cpp |
#include <Functions/isNotDistinctFrom.h>
#include <Functions/FunctionFactory.h>
#include <Functions/FunctionsLogical.h>
namespace DB
{
REGISTER_FUNCTION(IsNotDistinctFrom)
{
FunctionDocumentation::Description description = R"(
Performs a null-safe "equals" comparison between two values.
Returns `t... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>DistinctFrom,
NullSafeCmpMode::NullSafeEqual,
EqualsOp,
NameEquals>;
using FunctionIsNotDistinctFrom = NullSafeEqualImpl;
}
<|fim_prefix|>#pragma on<|fim_middle|>ce... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Columns/ColumnDynamic.h>
#include <Columns/ColumnLowCardinality.h>
#include <Columns/ColumnNullable.h>
#include <Columns/ColumnVariant.h>
#include <Core/ColumnNumbers.h>
#include <Core/Settings.h>
#include <DataTypes/DataTypeNullable.h>
#include <DataTypes/DataTypesNumber.h>
#include <Functions/... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>eImpl(const ColumnsWithTypeAndName & arguments, const DataTypePtr &, size_t) const
{
const ColumnWithTypeAndName & elem = arguments[0];
if (isVariant(elem.type) || isDynamic(elem.type))
{
const auto & column_variant = isVariant(elem.type) ? checkAndGetColumn<ColumnVariant>(*elem.colum... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <Functions/IFunction.h>
#include <Core/Settings.h>
#include <DataTypes/DataTypesNumber.h>
#include <Interpreters/Context_fwd.h>
#if USE_EMBEDDED_COMPILER
# include <DataTypes/Native.h>
# include <llvm/IR/IRBuilder.h>
#endif
namespace DB
{
namespace Setting
{
extern const... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>yzer)
return nullptr;
const ColumnWithTypeAndName & elem = arguments[0];
if (elem.type->onlyNull() || canContainNull(*elem.type))
return result_type->createColumnConst(1, UInt8(1));
return result_type->createColumnConst(1, UInt8(0));
}
bool useDef... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <Columns/ColumnsNumber.h>
#include <DataTypes/DataTypesNumber.h>
#include <DataTypes/IDataType.h>
#include <Functions/FunctionFactory.h>
#include <Functions/FunctionHelpers.h>
#include <Functions/IFunction.h>
#include <Functions/castTypeToEither.h>
#include <Common/Primality.h>
namespace DB
{
... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <Columns/ColumnConst.h>
#include <Columns/ColumnsNumber.h>
#include <DataTypes/DataTypesNumber.h>
#include <DataTypes/IDataType.h>
#include <Functions/FunctionFactory.h>
#include <Functions/FunctionHelpers.h>
#include <Functions/IFunction.h>
#include <Functions/castTypeToEither.h>
#include <Commo... | fim | ClickHouse/ClickHouse | cpp |
#include <DataTypes/DataTypeString.h>
#include <DataTypes/DataTypesNumber.h>
#include <Functions/FunctionFactory.h>
#include <Functions/IFunction.h>
#include <Functions/FunctionHelpers.h>
#include <Columns/ColumnString.h>
#include <Columns/ColumnFixedString.h>
#include <Columns/ColumnArray.h>
#include <Columns/ColumnsN... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <Common/isValidUTF8.h>
#include <DataTypes/DataTypeString.h>
#include <Functions/FunctionFactory.h>
#include <Functions/FunctionStringOrArrayToT.h>
namespace DB
{
namespace ErrorCodes
{
extern const int ILLEGAL_TYPE_OF_ARGUMENT;
}
/// inspired by https://github.com/cyb70289/utf8/
struct Vali... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <Functions/IFunction.h>
#include <Functions/castTypeToEither.h>
#include <Functions/FunctionFactory.h>
#include <DataTypes/DataTypesNumber.h>
#include <DataTypes/DataTypeNullable.h>
#include <Core/ColumnNumbers.h>
#include <Columns/ColumnConst.h>
#include <Columns/ColumnNullable.h>
namespace DB... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <Columns/ColumnString.h>
#include <DataTypes/DataTypeString.h>
#include <Functions/FunctionFactory.h>
#include <Functions/FunctionHelpers.h>
#include <Functions/IFunction.h>
#include <Interpreters/Context.h>
#include <IO/ReadBufferFromString.h>
#include <Common/FieldVisitorToString.h>
#include <C... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>pply(UInt64 hash, BucketsType n)
{
return JumpConsistentHash(hash, n);
}
};
using FunctionJumpConsistentHash = FunctionConsistentHashImpl<JumpConsistentHashImpl>;
}
REGISTER_FUNCTION(JumpConsistentHash)
{
FunctionDocumentation::Description description = R"(
Calculates the [jump cons... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <Functions/keyvaluepair/ArgumentExtractor.h>
#include <Functions/FunctionHelpers.h>
#include <DataTypes/DataTypeString.h>
namespace DB
{
namespace ErrorCodes
{
extern const int NUMBER_OF_ARGUMENTS_DOESNT_MATCH;
extern const int BAD_ARGUMENTS;
extern const int ILLEGAL_TYPE_OF_ARGUM... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>olumnPtr unexpected_quoting_character_strategy = nullptr;
};
static ParsedArguments extract(const ColumnsWithTypeAndName & arguments);
static ParsedArguments extract(ColumnsWithTypeAndNameList arguments);
private:
static CharArgument extractSingleCharacter(const ColumnWithTypeAndName & ... | fim | ClickHouse/ClickHouse | c |
#pragma once
#include <Columns/ColumnString.h>
#include <Common/MapWithMemoryTracking.h>
#include <Functions/keyvaluepair/impl/StateHandler.h>
#include <Functions/keyvaluepair/impl/StateHandlerImpl.h>
#include <absl/container/flat_hash_map.h>
namespace DB
{
namespace ErrorCodes
{
extern const int LOGICAL_ERROR;... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|> pair_delimiters.end(), quoting_character) != pair_delimiters.end();
if (is_quoting_character_in_pair_delimiters)
{
throw Exception(ErrorCodes::BAD_ARGUMENTS, "Invalid arguments, quoting_character conflicts with pair delimiters");
}
}
}
}
<|fim_prefix|>#include <Functions/keyvaluepa... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>ected_quoting_character_strategy_
);
};
/*
* Validates (business logic) and creates Configurations for key-value-pair extraction.
* */
struct ConfigurationFactory
{
public:
static Configuration createWithoutEscaping(char key_value_delimiter, char quoting_character, VectorWithMemoryTracking<char... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>) {}
std::string_view key;
};
}
}
<|fim_prefix|>#pragma once
#include <Common/Exception.h>
namespace DB
{
namespace extractKV
{
struct Dupli<|fim_middle|>cateKeyFoundException : Exception
{
explicit DuplicateKeyFoundException(std::string_view key_) : key(key_<|endoftext|> | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Functions/keyvaluepair/impl/KeyValuePairExtractorBuilder.h>
#include <Functions/keyvaluepair<|fim_suffix|>;
}
KeyValuePairExtractorBuilder & KeyValuePairExtractorBuilder::withMaxNumberOfPairs(uint64_t max_number_of_pairs_)
{
max_number_of_pairs = max_number_of_pairs_;
return *this;
}
... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>n, max_number_of_pairs);
}
auto buildWithReferenceMap() const
{
auto configuration = extractKV::ConfigurationFactory::createWithoutEscaping(key_value_delimiter, quoting_character, item_delimiters, unexpected_quoting_character_strategy);
return KeyValuePairExtractorReferenceMa... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#pragma once
#include <Functions/keyvaluepair/impl/Configuration.h>
#include <base/find_symbols.h>
#include <iterator>
#include <vector>
namespace DB
{
namespace extractKV
{
/*
* `StateHandlerImpl` makes use of string search algorithms to find delimiters. This class creates the needles for each stat... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#pragma once
#include <string_view>
namespace <|fim_suffix|>// move from `FLUSH_PAIR` directly to `WAITING_FOR_KEY` because a pair delimiter has not been found. Might jump to WAITING_FOR_PAIR_DELIMITER or END
FLUSH_PAIR_AFTER_QUOTED_VALUE,
// Might jump to WAITING_KEY or END.
WA... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|> throw DuplicateKeyFoundException(key);
}
map[key] = value;
resetValue();
resetKey();
}
std::string_view uncommittedKeyChunk() const
{
return key;
}
std::string_view uncommittedValueChunk() const
... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Functions/keyvaluepair/impl/KeyValuePairExtractorBuilder.h>
#include <Columns/ColumnString.h>
#include <gtest/gtest.h>
#include <string_view>
namespace DB
{
static void assert_byte_equality(std::string_view lhs, const std::vector<uint8_t> & rhs)
{
std::vector<uint8_t> lhs_vector {lhs<|fi... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>e last symbol
KeyValuePairExtractorBuilder(),
R"in(valid_key:valid_value key:invalid_val\)in",
ExpectedValues{
{"valid_key", "valid_value"},
{"key", "invalid_val\\"}
}
},
{
... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>t);
}
void test_read(const auto & handler, std::string_view input, std::string_view expected_element,
std::size_t expected_pos, State expected_state)
{
test_read<false>(handler, input, expected_element, expected_pos, expected_state);
}
void test_read_quoted(const auto & handler, std::... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <Functions/keyvaluepair/impl/StateHandlerImpl.h>
#include <Functions/keyvaluepair/impl/StateHandler.h>
#include <gtest/gtest.h>
namespace
{
using namespace DB;
using namespace DB::extractKV;
using State = extractKV::StateHandler::State;
u<|fim_suffix|>::StateHandler::NextState;
void test_wa... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <Functions/keyvaluepair/impl/StateHandlerImpl.h>
#include <Functions/<|fim_suffix|>xpected_state);
}
}
TEST(extractKVPairNoEscapingKeyStateHandler, Wait)
{
auto pair_delimiters = VectorWithMemoryTracking<char>{',', ' ', '$'};
auto configuration = ConfigurationFactory::createWithEscapin... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>nctionKostikConsistentHash = FunctionConsistentHashImpl<KostikConsistentHashImpl>;
REGISTER_FUNCTION(KostikConsistentHash)
{
FunctionDocumentation::Description description = R"(
An O(1) time and space consistent hash algorithm by Konstantin 'Kostik' Oblakov.
Only efficient with `n <= 32768`.
)";
... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <Functions/FunctionFactory.h>
#include <Functions/FunctionBinaryArithmetic.h>
#include <Functions/GCDLCMImpl.h>
#include <boost/integer/common_factor.hpp>
namespace abs_impl
{
template <typename T>
constexpr T abs(T value) noexcept
{
if constexpr (std::is_signed_v<T>)
{
if (va... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <Functions/FunctionFactory.h>
#include <Functions/FunctionBinaryArithmetic.h>
#include <Core/AccurateComparison.h>
#include <Functions/LeastGreatestGeneric.h>
namespace DB
{
template <typename A, typename B>
struct LeastBaseImpl
{
using ResultType = NumberTraits::ResultOfLeast<A, B>;
s... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <Functions/FunctionFactory.h>
#include <Functions/LeftRight.h>
namespace DB
{
REGISTER_FUNCTION(Left)
{
FunctionDocumentation::Description description = R"(
Returns a substring of string `s` with a specified `offset` starting from the left.
)";
FunctionDocumentation::Syntax syntax = "le... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>tionLemmatize(Lemmatizers & lemmatizers_)
: lemmatizers(lemmatizers_) {}
String getName() const override { return name; }
size_t getNumberOfArguments() const override { return 2; }
bool isSuitableForShortCircuitArgumentsExecution(const DataTypesWithConstInfo & /*arguments*/) const o... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>escription description = R"(
Returns the length of a string in Unicode code points rather than in bytes or characters.
It assumes that the string contains valid UTF-8 encoded text.
If this assumption is violated, no exception is thrown and the result is undefined.
)";
FunctionDocumentation::Syntax sy... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <Functions/FunctionFactory.h>
#include <Functions<|fim_suffix|> 1 │ 0 │
└────────────┴────────────┘
)"}
};
FunctionDocumentation::IntroducedIn introduced_in = {1, 1};
FunctionDocumentation::Category category = FunctionDocumentation::Category::Comparison;
FunctionD... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>ss,
less_or_equals,
func_builder_and,
func_builder_or,
func_builder_equals,
x, y, tuple_size, input_rows_count);
}
}
<|fim_prefix|>#include <Functions/FunctionFactory.h>
#include <Functions/FunctionsComparison.h>
#include <Functions/FunctionsLogical.h>
namespace ... | fim | ClickHouse/ClickHouse | cpp |
#include <Functions/FunctionMathUnary.h>
#include <Functions/FunctionFactory.h>
#if defined(OS_DARWIN)
extern "C"
{
double lgamma_r(double x, int * signgamp);
}
#endif
namespace DB
{
namespace
{
/// Use wrapper and use lgamma_r version because std::lgamma is not threadsafe.
Float64 lgamma_wrapper(Float64 arg)
{
... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <Functions/like.h>
#include <Functions/FunctionFactory.h>
namespace DB
{
REGISTER_FUNCTION(Like)
{
FunctionDocumentation::Description description = R"(
Returns whether string `haystack` matches the `LIKE` expression `pattern`.
A `LIKE` expression can contain normal characters and the foll... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <Functions/MatchI<|fim_suffix|>ionLike = FunctionsStringSearch<LikeImpl>;
}
<|fim_middle|>mpl.h>
#include <Functions/FunctionsStringSearch.h>
namespace DB
{
struct NameLike
{
static constexpr auto name = "like";
};
using LikeImpl = MatchImpl<NameLike, MatchTraits::Syntax::Li... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Functions/FunctionsStringSearch.h>
#include <Functions/FunctionFactory.h>
#include <Functions/PositionImpl.h>
namespace DB
{
namespace
{
struct NameLocate
{
static constexpr auto name = "locate";
};
using FunctionLocate = FunctionsStringSearch<PositionImpl<NameLocate, PositionCaseSensiti... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <Functions/FunctionMathUnary.h>
#include <Functions/FunctionFactory.h>
namespace DB
{
namespace ErrorCodes
{
extern const int NOT_IMPLEMENTED;
}
namespace
{
struct LogName { static constexpr auto name = "log"; };
#if USE_FASTOPS
struct Impl
{
static constexpr auto name = Log... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <Functions/FunctionMathUnary.h>
#include <Functions/FunctionFactory.h>
namespace DB
{
namespace
{
struct Log10Name { static constexpr auto name = "log10"; };
using Functio<|fim_suffix|>n<FunctionLog10>(documentation, FunctionFactory::Case::Insensitive);
}
}
<|fim_middle|>nLog10 = FunctionMathU... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>", "Values from the interval: `-1 < x < +∞`.", {"(U)Int*", "Float*", "Decimal*"}}
};
FunctionDocumentation::ReturnedValue returned_value = {"Returns values from the interval: -∞ < log1p(x) < +∞", {"Float64"}};
FunctionDocumentation::Examples examples = {{"Usage example", "SELECT log1p(0)", "0"... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <Functions/FunctionMathUnary.h>
#include <Functions/FunctionFactory.h>
namespace DB
{
namespace
{
struct Log2Name { static constexpr auto name = "log2"; };
using FunctionLog2 = FunctionMathUnary<UnaryFunctionVectorized<Log2Name, log2>>;
}
REGISTER_FUNCTION(Log2)
{
FunctionDocumentation::D... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <Columns/ColumnConst.h>
#include <Columns/ColumnString.h>
#include <DataTypes/DataTypeString.h>
#include <DataTypes/DataTypesNumber.h>
#include <Functions/FunctionFactory.h>
#include <Functions/FunctionHelpers.h>
#include <Functions/IFunction.h>
#include <Common/logger_useful.h>
namespace DB
{
... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>esolverPtr createInternalFunctionOrOverloadResolver();
FunctionOverloadResolverPtr createInternalFunctionAndOverloadResolver();
FunctionOverloadResolverPtr createInternalFunctionXorOverloadResolver();
FunctionOverloadResolverPtr createInternalFunctionNotOverloadResolver();
}
<|fim_prefix|>#pragma once
#i... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Functions/IFunction.h>
#include <Functions/FunctionFactory.h>
#include <Functions/FunctionHelpers.h>
#include <DataTypes/DataTypesNumber.h>
#include <DataTypes/DataTypeLowCardinality.h>
#include <Columns/ColumnsNumber.h>
#include <Columns/ColumnLowCardinality.h>
#include <Common/typeid_cast.h>
... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>_column->cutAndCompact(0, input_rows_count)->getDictionary().getNestedColumn()->cloneResized(arg.column->size());
}
};
}
REGISTER_FUNCTION(LowCardinalityKeys)
{
FunctionDocumentation::Description description = R"(
Returns the dictionary values of a [LowCardinality](../data-types/lowcardinality.m... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>tionDocumentation documentation = {description, syntax, arguments, {}, returned_value, examples, introduced_in, category};
factory.registerFunction<FunctionLower>(documentation, FunctionFactory::Case::Insensitive);
factory.registerAlias("lcase", NameLower::name, FunctionFactory::Case::Insensitive... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>ns a lowercase string.", {"String"}};
FunctionDocumentation::Examples examples = { {"first", "SELECT lowerUTF8('München') as Lowerutf8;", "münchen"}, };
FunctionDocumentation::IntroducedIn introduced_in = {1, 1};
FunctionDocumentation::Category category = FunctionDocumentation::Category::Strin... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>ments_makeDateTime64, {}, returned_value_makeDateTime64, examples_makeDateTime64, introduced_in_makeDateTime64, category_makeDateTime64};
factory.registerFunction<FunctionMakeDateTime64>(documentation_makeDateTime64, FunctionFactory::Case::Insensitive);
FunctionDocumentation::Description descrip... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <Columns/ColumnLowCardinality.h>
#include <Columns/ColumnMap.h>
#include <Columns/ColumnNullable.h>
#include <Columns/ColumnsCommon.h>
#include <Columns/ColumnsNumber.h>
#include <Columns/ColumnTuple.h>
#include <Core/Settings.h>
#include <DataTypes/DataTypeArray.h>
#include <DataTypes/DataTypeNu... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <Functions/FunctionsStringSearch.h>
#include <Functions/FunctionFactory.h>
#include <Functions/MatchImpl.h>
namespace DB
{
namespace
{
struct NameMatch
{
static constexpr auto name = "match";
};
using FunctionMatch = FunctionsStringSearch<MatchImpl<NameMatch, MatchTraits::Syntax::Re2, Mat... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <Functions/FunctionFactory.h>
#include <Functions/materialize.h>
namespace DB
{
REGISTER_FUNCTION(Materialize)
{
FunctionDocumentation::Description description = R"(
Turns a constant into a full column containing a single value.
Full columns and constants are represented differently in mem... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <Functions/IFunction.h>
#include <Functions/FunctionFactory.h>
#include <Columns/ColumnLowCardinality.h>
#include <Columns/ColumnSparse.h>
namespace DB
{
/** materialize(x) - materialize the constant
*/
template <bool remove_special_representations>
class FunctionMaterialize fina... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Functions/FunctionConstantBase.h>
#include <DataTypes/DataTypesNumber.h>
#include <numbers>
namespace DB
{
namespace
{
template <typename Impl>
class FunctionMathConstFloat64 final : public FunctionConstantBase<FunctionMathConstFloat64<Impl>, Float64, DataTypeFloat64>
{
publi... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <Functions/FunctionFactory.h>
#include <Functions/FunctionMathBinaryFloat64.h>
namespace DB
{
namespace
{
struct Max2Name
{
static constexpr auto name = "max2";
};
template <typename T>
T max(T a, T b)
{
return a > b ? a : b;
}
using FunctionMax2... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>─result─┬─type──────┐
│ 13:00:00 │ Time64(0) │
└──────────┴───────────┘
)"}};
FunctionDocumentation::IntroducedIn introduced_in = {25, 11};
FunctionDocumentation::Category category = FunctionDocumentation::Category::Arithmetic;
FunctionDocumentation documentation = {description, syntax... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>e;
using SumType = WiderInt<Native>;
result_data.resize(input_rows_count);
for (size_t row = 0; row < input_rows_count; ++row)
{
SumType sum{};
for (const auto & column : input_columns)
{
const auto * column_vec = asser... | fim | ClickHouse/ClickHouse | c |
#include <Functions/FunctionFactory.h>
#include <Functions/FunctionMathBinaryFloat64.h>
namespace DB
{
namespace
{
struct Min2Name
{
static constexpr auto name = "min2";
};
template <typename T>
T min(T a, T b)
{
return a < b ? a : b;
}
using FunctionMin2 = FunctionMa... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>late getValue<Float64>();
return process<true>(arguments, &left_value, input_rows_count);
}
if (const ColumnVector<Float64> * const col_p1 = checkAndGetColumn<ColumnVector<Float64>>(first_argument_column.get()))
{
return process<false>(arguments, col_p1->get... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>f overflowed, false otherwise.
template <typename Result = ResultType>
static bool apply(A a, B b, Result & c)
{
return common::subOverflow(static_cast<Result>(a), b, c);
}
#if USE_EMBEDDED_COMPILER
static constexpr bool compilable = true;
static llvm::Value * compile(llv... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>std::is_signed_v<B>)
{
if (b < std::numeric_limits<A>::lowest()) [[unlikely]]
{
for (size_t i = 0; i < size; ++i)
dst[i] = static_cast<ResultType>(src[i]);
return;
}
}
... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>unctionFactory::Case::Insensitive);
factory.registerAlias("pmodOrNull", "positiveModuloOrNull", FunctionFactory::Case::Insensitive);
}
}
<|fim_prefix|>#include <Functions/FunctionFactory.h>
#include <Functions/FunctionBinaryArithmetic.h>
namespace DB
{
struct NameModuloOrNull { static constexpr aut... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>ntroducedIn introduced_in = {20, 3};
FunctionDocumentation::Category category = FunctionDocumentation::Category::Arithmetic;
FunctionDocumentation documentation = {description, syntax, arguments, {}, returned_value, examples, introduced_in, category};
factory.registerFunction<FunctionModuloOr... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>ame from date", R"(
WITH toDateTime('2021-04-14 11:22:33') AS date_value
SELECT monthName(date_value)
)",
R"(
┌─monthName(date_value)─┐
│ April │
└───────────────────────┘
)"}
};
FunctionDocumentation::IntroducedIn introduced_in = {22, 1};
FunctionDocume... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>, n6, n7, n8))) FROM morton_numbers;
)",
"1 2 3 4 5 6 7 8"
}
};
FunctionDocumentation::IntroducedIn introduced_in = {24, 6};
FunctionDocumentation::Category category = FunctionDocumentation::Category::Encoding;
FunctionDocumentation documentation = {description, s... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <Functions/IFunction.h>
#include <Functions/FunctionFactory.h>
#include <Columns/ColumnsNumber.h>
#include <Columns/ColumnConst.h>
#include <Columns/ColumnTuple.h>
#include <Functions/FunctionSpaceFillingCurve.h>
#include <Functions/PerformanceAdaptors.h>
#include <morton-nd/mortonND_LUT.h>
#if ... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <Functions/FunctionsMultiStringFuzzySear<|fim_suffix|>s://en.wikipedia.org/wiki/Edit_distance).";
FunctionDocumentation::Syntax syntax = "multiFuzzyMatchAllIndices(haystack, distance, [pattern1, pattern2, ..., patternN])";
FunctionDocumentation::Arguments arguments = {
{"haystack"... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <Functions/FunctionsMultiS<|fim_suffix|>lickHose']);",
R"(
┌─multiFuzzyMa⋯lickHose'])─┐
│ 1 │
└──────────────────────────┘
)"
}
};
FunctionDocumentation::IntroducedIn introduced_in = {20, 1};
FunctionDocumentation::Category category = Functio... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <Functions/FunctionsMultiStringFuzzySearch.h>
#include <Functions/FunctionFactory.h>
#include <Functions/MultiMatchAnyImpl.h>
namespace DB
{
namespace
{
struct N<|fim_suffix|>tchAnyIndex)
{
FunctionDocumentation::Description description = "Like [`multiFuzzyMatchAny`](#multiFuzzyMatchAny) b... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>xample usage", R"(
CREATE TABLE LEFT_RIGHT (left Nullable(UInt8), right Nullable(UInt8)) ENGINE = Memory;
INSERT INTO LEFT_RIGHT VALUES (NULL, 4), (1, 3), (2, 2), (3, 1), (4, NULL);
SELECT
left,
right,
multiIf(left < right, 'left is smaller', left > right, 'left is greater', left = right, 'Bo... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>ver>;
FunctionOverloadResolverPtr createInternalMultiIfOverloadResolver(bool allow_execute_multiif_columnar, bool use_variant_as_common_type);
}
<|fim_prefix|>#pragma once
#include <memory>
namespace DB
{
class IFunctionOverloadResolv<|fim_middle|>er;
using FunctionOverloadResolverPtr = std::shared_pt... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Functions/FunctionsMultiStringSearch.h>
#include <Functions/FunctionFactory.h>
#include <Functions/MultiMatchAllIndicesImpl.h>
namespace DB
{
namespace
{
struct NameMultiMatchAllIndices
{
static constexpr auto name = "multiMatchAllIndices";
};
using FunctionMultiMatchAllIndices = Functio... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <Functions/multiMatchAny.h>
#include <Functions/FunctionsMultiStringSearch.h>
#include <Functions/FunctionFactory.h>
#include <Functions/MultiMatchAnyImpl.h>
#include <Functions/IFunctionAdaptors.h>
namespace DB
{
namespace
{
struct NameMultiMatchAny
{
static constexpr auto name = "multiMa... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <memory>
namespace DB
{
class IFunctionOverloadResolver;
using FunctionOverloadResolverPtr = std::shared_ptr<IFunctionOverloadResolver>;
<|fim_suffix|>s);
}
<|fim_middle|>
FunctionOverloadResolverPtr createInternalMultiMatchAnyOverloadResolver(bool allow_hyperscan, size_t max_hype... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Functions/FunctionsMultiStringSearch.h>
#include <Functions/Func<|fim_suffix|>arch is performed.", {"String"}},
{"pattern", "Regular expressions to match against.", {"Array(String)"}}
};
FunctionDocumentation::ReturnedValue returned_value = {"Returns the index (starting from 1) o... | fim | ClickHouse/ClickHouse | cpp |
#include <Functions/FunctionsMultiStringPosition.h>
#include <Functions/FunctionFactory.h>
#include <Functions/MultiSearchAllPositionsImpl.h>
#include <Functions/PositionImpl.h>
namespace DB
{
namespace
{
struct NameMultiSearchAllPositions
{
static constexpr auto name = "multiSearchAllPositions";
};
using Funct... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>ocumentation::Category::StringSearch;
FunctionDocumentation documentation = {description, syntax, arguments, {}, returned_value, examples, introduced_in, category};
factory.registerFunction<FunctionMultiSearchAllPositionsCaseInsensitive>(documentation);
}
}
<|fim_prefix|>#include <Functions/Func... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>llPositionsCaseInsensitiveUTF8)
{
FunctionDocumentation::Description description = "Like [`multiSearchAllPositionsUTF8`](#multiSearchAllPositionsUTF8) but ignores case.";
FunctionDocumentation::Syntax syntax = "multiSearchAllPositionsCaseInsensitiveUTF8(haystack, [needle1, needle2, ..., needleN])"... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <Functions/FunctionsMultiStringPosition.h>
#include <Functions/FunctionFactory.h>
#include <Functions/MultiSearchAllPositionsImpl.h>
#include <Functions/PositionImpl.h>
namespace DB
{
namespace
{
struct NameMultiSearchAllPositionsUTF8
{
static constexpr auto name = "multiSearchAllPositions... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <Functions/FunctionsMultiStringSearch.h>
#include <Functions/FunctionFactory.h>
#include <Functions/MultiSearchImpl.h>
#include <Functions/PositionImpl.h>
namespace DB
{
namespace
{
struct NameMultiSearchAny
{
static constexpr auto name = "multiSearchAny";
};
using FunctionMultiSearch = F... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>───────────────────────────────────────┘
)"
}
};
FunctionDocumentation::IntroducedIn introduced_in = {20, 1};
FunctionDocumentation::Category category = FunctionDocumentation::Category::StringSearch;
FunctionDocumentation documentation = {description, syntax, arguments, {}, ret... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>"UTF-8 substrings to be searched.", {"Array(String)"}}
};
FunctionDocumentation::ReturnedValue returned_value = {"Returns `1`, if there was at least one case-insensitive match, otherwise `0`, if there was not at least one case-insensitive match.", {"UInt8"}};
FunctionDocumentation::Examples ex... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <Functions/FunctionsMultiStringSearch.h>
#include <Functions/FunctionFactory.h>
#include <Functions/MultiSearchImpl.h>
#include <Functions/PositionImpl.h>
namespace DB
{
namespace
{
struct NameMultiSearchAnyUTF8
{
stat<|fim_suffix|>tiSearchAnyUTF8)
{
FunctionDocumentation::Description ... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <Functions/FunctionsMultiStringSearch.h>
#include <Functions/FunctionFactory.h>
#include <Functions/MultiSearchFirstIndexImpl.h>
#include <Functions/PositionImpl.h>
namespace DB
{
namespace
{
struct NameMultiSearchFirstIndex
{
<|fim_suffix|>turns the 1-based index (position in the needles ar... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <Functions/FunctionsMultiStringSearch.h>
#include <Functions/FunctionFactory.h>
#include <Functions/<|fim_suffix|>s = {
{"haystack", "String in which the search is performed.", {"String"}},
{"needle", "Substrings to be searched.", {"Array(String)"}}
};
FunctionDocumentatio... | fim | ClickHouse/ClickHouse | cpp |
#include <Functions/FunctionsMultiStringSearch.h>
#include <Functions/FunctionFactory.h>
#include <Functions/MultiSearchFirstIndexImpl.h>
#include <Functions/PositionImpl.h>
namespace DB
{
namespace
{
struct NameMultiSearchFirstIndexCaseInsensitiveUTF8
{
static constexpr auto name = "multiSearchFirstIndexCaseIns... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>he search is performed.", {"String"}},
{"needle", "Array of UTF-8 substrings to be searched.", {"Array(String)"}}
};
FunctionDocumentation::ReturnedValue returned_value = {"Returns the index (starting from 1) of the leftmost found needle. Otherwise 0, if there was no match.", {"UInt8"}};
... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <Functions/FunctionsMultiStringSearch.h>
#include <Functions/FunctionFactory.h>
#include <Function<|fim_suffix|>iStringSearch<MultiSearchFirstPositionImpl<NameMultiSearchFirstPosition, PositionCaseSensitiveASCII>>;
}
REGISTER_FUNCTION(MultiSearchFirstPosition)
{
FunctionDocumentation::Descr... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <Functions/FunctionsMultiStringSearch.h>
#include <Functions/FunctionFactory.h>
#include <Functions/MultiSearchFirstPositionImpl.h>
#include <Functions/PositionImpl.h>
namespace DB
{
namespace
{
struct NameMultiSearchFirstPositionCaseInsensitive
{
static constexpr auto name = "multiSearchF... | fim | ClickHouse/ClickHouse | cpp |
#include <Functions/FunctionsMultiStringSearch.h>
#include <Functions/FunctionFactory.h>
#include <Functions/MultiSearchFirstPositionImpl.h>
#include <Functions/PositionImpl.h>
namespace DB
{
namespace
{
struct NameMultiSearchFirstPositionCaseInsensitiveUTF8
{
static constexpr auto name = "multiSearchFirstPositi... | fim | ClickHouse/ClickHouse | cpp |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.