text stringlengths 14 100k | source stringclasses 1
value | repo stringclasses 810
values | language stringclasses 13
values |
|---|---|---|---|
<|fim_prefix|>#include <Functions/FunctionDynamicAdaptor.h>
#include <Common/CurrentThread.h>
#include <Common/UnorderedMapWithMemoryTracking.h>
#include <Common/VectorWithMemoryTracking.h>
#include <Core/Settings.h>
#include <DataTypes/DataTypeDynamic.h>
#include <DataTypes/DataTypeVariant.h>
#include <DataTypes/DataT... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>overload_resolver->isStateful(); }
bool isDeterministic() const override { return function_overload_resolver->isDeterministic(); }
bool isDeterministicInScopeOfQuery() const override { return function_overload_resolver->isDeterministicInScopeOfQuery(); }
bool isServerConstant() const overri... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>nDocumentation::Category category = FunctionDocumentation::Category::Other;
FunctionDocumentation documentation = {description, syntax, arguments, {}, returned_value, examples, introduced_in, category};
factory.registerFunction<FunctionFQDN>(documentation, FunctionFactory::Case::Insensitive);
... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>et(
const std::string & name,
ContextPtr context) const
{
return getImpl(name, context);
}
bool FunctionFactory::has(const std::string & name) const
{
String canonical_name = getAliasToOrName(name);
if (functions.contains(canonical_name))
return true;
canonical_name = Poco... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <Core/Types.h>
#include <Interpreters/Context_fwd.h>
#include <Common/register_objects.h>
#include <Common/IFactoryWithAliases.h>
#include <Common/FunctionDocumentation.h>
#include <Functions/IFunction.h>
#include <functional>
#include <memory>
#include <string>
#include <unordered... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Columns/ColumnNullable.h>
#include <Columns/ColumnString.h>
#include <Columns/ColumnConst.h>
#include <Columns/IColumn.h>
#include <Functions/FunctionFactory.h>
#include <Access/Common/AccessFlags.h>
#include <DataTypes/DataTypeString.h>
#include <DataTypes/DataTypeNullable.h>
#include <IO/ReadB... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>
{
writeString(element_name, buf);
writeChar(' ', buf);
}
writeRandomType(element_name, rng, buf, allow_suspicious_lc_types, depth + 1);
}
writeChar(')', buf);
... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>t_rows_count) const override;
static String generateRandomStructure(size_t seed, const ContextPtr & context);
static String generateRandomDataType(pcg64 & rng, bool allow_suspicious_lc_types, bool allow_complex_types);
private:
bool allow_suspicious_lc_types;
};
}
<|fim_prefix|>#pragma once... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Columns/ColumnFixedString.h>
#include <Columns/ColumnLowCardinality.h>
#include <Columns/ColumnNullable.h>
#include <DataTypes/DataTypeLowCardinality.h>
#include <Columns/ColumnString.h>
#include <Columns/ColumnTuple.h>
#include <Common/assert_cast.h>
#include <DataTypes/DataTypeNullable.h>
#inc... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>nput null map
* Or ColumnConst(ColumnNullable) if the result is always NULL or if the result is constant and always not NULL.
* If null_map is nullptr, it's as if it's all 0.
*/
ColumnPtr wrapInNullable(const ColumnPtr & src, ColumnPtr null_map);
struct NullPresence
{
bool has_nullable = false;... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>/// Plain `nativeCast` reinterprets the integer bits without applying the `10^scale`
/// factor, which silently produces wrong values when the analyzer leaves a non-`Decimal`
/// branch unconverted (e.g. `if(cond, decimal_col, 1)` with `result_type = Decimal(P, S)`).
au... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Columns/ColumnString.h>
#include <Core/Block.h>
#include <Core/Settings.h>
#include <Functions/FunctionFactory.h>
#include <Functions/FunctionHelpers.h>
#include <Functions/IFunction.h>
#include <Interpreters/Context.h>
#include <Interpreters/DatabaseCatalog.h>
#include <Interpreters/HashJoin/Ha... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>/// Multi-buffer MD5 function.
///
/// Processes multiple independent MD5 digests in parallel by interleaving
/// their round computations. On x86-64 with AVX2 or AVX-512, uses SIMD to
/// compute 16 or 32 digests simultaneously. On AArch64, uses ASIMD/NEON to
/// compute 8 digests simultaneously. On othe... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <Core/callOnTypeIndex.h>
#include <DataTypes/DataTypesNumber.h>
#include <DataTypes/DataTypesDecimal.h>
#include <Columns/ColumnConst.h>
#include <Functions/IFunction.h>
#include <Functions/Funct<|fim_suffix|>tic FunctionPtr create(ContextPtr) { return std::make_shared<FunctionMathB... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>size + i] = dst_remaining[i];
else
memcpy(&dst_data[rows_size], dst_remaining, rows_remaining * sizeof(ReturnType));
}
}
}
template <typename T, typename ReturnType>
static ColumnPtr execute(const ColumnVector<T> * col, size_t input_rows... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <mutex>
#include <optional>
#include <ranges>
#include <Columns/ColumnString.h>
#include <Columns/ColumnsNumber.h>
#include <DataTypes/DataTypeString.h>
#include <DataTypes/DataTypesNumber.h>
#include <Functions/FunctionFactory.h>
#include <Functions/FunctionHelpers.h>
#include <Functions/IFuncti... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|> || (res = execute<Int16>(in, input_rows_count))
|| (res = execute<Int32>(in, input_rows_count))
|| (res = execute<Int64>(in, input_rows_count))
|| (res = execute<Float32>(in, input_rows_count))
|| (res = execute<Float64>(in, input_rows_count))
... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>esulting parts,
and joins them back using the same separator. It is useful for parsing domain names,
file paths, or other hierarchical data where you need to reverse the order of components.
Examples:
- reverseBySeparator('www.google.com') returns 'com.google.www'
- reverseBySeparator('a/b/c', '/') retur... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>tationForConstants() const override { return true; }
bool useDefaultImplementationForNulls() const override { return true; }
ColumnNumbers getArgumentsThatAreAlwaysConstant() const override { return {1}; }
bool isSuitableForShortCircuitArgumentsExecution(const DataTypesWithConstInfo & /*argume... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>TypePtr & result_type, size_t input_rows_count) const override
{
return selector.selectAndExecute(arguments, result_type, input_rows_count);
}
static FunctionPtr create(ContextPtr context) { return std::make_shared<FunctionSHA1>(context); }
private:
ImplementationSelector<IFuncti... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>tion);
}
}
}
<|fim_prefix|>#include <Functions/FunctionSQLJSON.h>
#include <Functions/FunctionFactory.h>
namespace DB
{
REGISTER_FUNCTION(SQLJSON)
{
/// JSON_EXISTS
{
FunctionDocumentation::Description description = R"(
If the value exists in the JSON document, `1` will be returned... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>Parser> & generator_json_path, bool function_json_value_return_type_allow_complex)
{
Element current_element = root;
VisitorStatus status = {};
while ((status = generator_json_path.getNextItem(current_element)) != VisitorStatus::Exhausted)
{
if (status == V... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include "config.h"
#include <memory>
#include <string>
#include <Columns/ColumnMap.h>
#include <Columns/ColumnArray.h>
#include <Columns/ColumnTuple.h>
#include <DataTypes/DataTypeMap.h>
#include <DataTypes/DataTypeString.h>
#include <DataTypes/DataTypesNumber.h>
#include <Functions/FunctionFactory.h>
... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>nts) const override
{
UInt64 tuple_size = 0;
const auto * col_const = typeid_cast<const ColumnConst *>(arguments[0].column.get());
if (!col_const)
throw Exception(ErrorCodes::ILLEGAL_COLUMN,
"Illegal column type {} for function {}, should... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#pragma once
#include <Columns/ColumnString.h>
#include <DataTypes/DataTypesNumber.h>
#include <DataTypes/getLeastSupertype.h>
#include <Functions/FunctionHelpers.h>
#include <Functions/GatherUtils/GatherUtils.h>
#include <Functions/GatherUtils/Sources.h>
#include <Functions/IFunction.h>
#include <Interp... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#pragma once
#include <DataTypes/DataTypesNumber.h>
#include <Functions/IFunction.h>
#include <Functions/FunctionHelpers.h>
#include <Columns/ColumnVector.h>
#include <Columns/ColumnString.h>
#include <Columns/ColumnFixedString.h>
#include <Columns/ColumnArray.h>
#include <Columns/ColumnMap.h>
#include <C... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>aystack->getOffsets(),
col_needle_const->getValue<String>(),
col_replacement_vector->getChars(),
col_replacement_vector->getOffsets(),
col_res->getChars(),
col_res->getOffsets(),
input_rows_count);
... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|> {}", arguments[0].column->getName(), getName());
}
};
}
<|fim_prefix|>#pragma once
#include <DataTypes/DataTypeString.h>
#include <Columns/ColumnString.h>
#include <Columns/ColumnFixedString.h>
#include <Functions/FunctionHelpers.h>
#include <Functions/IFunction.h>
#include <Interpreters/Context_fw... | fim | ClickHouse/ClickHouse | c |
#pragma once
#include <Columns/ColumnArray.h>
#include <Columns/ColumnConst.h>
#include <Columns/ColumnString.h>
#include <DataTypes/DataTypeArray.h>
#include <DataTypes/DataTypeString.h>
#include <Functions/FunctionHelpers.h>
#include <Functions/IFunction.h>
#include <Functions/Regexps.h>
#include <Interpreters/Conte... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>eturn false; }
bool isDeterministic() const override { return false; }
bool isDeterministicInScopeOfQuery() const override { return false; }
bool useDefaultImplementationForNulls() const override { return false; }
size_t getNumberOfArguments() const override { return 1; }
DataTypePtr ... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>cker_);
}
<|fim_prefix|>#pragma once
#include <memory>
namespace DB
{
class IFunctionOverloadResolver<|fim_middle|>;
using FunctionOverloadResolverPtr = std::shared_ptr<IFunctionOverloadResolver>;
struct TopKThresholdTracker;
using TopKThresholdTrackerPtr = std::shared_ptr<TopKThresholdTracker>;
Func... | fim | ClickHouse/ClickHouse | c |
#pragma once
#include <Columns/ColumnDecimal.h>
#include <Columns/ColumnFixedString.h>
#include <Columns/ColumnString.h>
#include <Columns/ColumnVector.h>
#include <Columns/ColumnsNumber.h>
#include <DataTypes/DataTypeFixedString.h>
#include <DataTypes/DataTypeInterval.h>
#include <DataTypes/DataTypeString.h>
#include... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>et_scale(target_scale_)
, name(name_)
, allow_nonconst_timezone_arguments(context->getSettingsRef()[Setting::allow_nonconst_timezone_arguments])
{}
}
<|fim_prefix|>#include <Core/Settings.h>
#include <Interpreters/Context.h>
#include <Functions/FunctionUnixTimestamp64.h>
namespace DB
{
namespace... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>nfo & /*arguments*/) const override { return false; }
bool useDefaultImplementationForConstants() const override { return true; }
DataTypePtr getReturnTypeImpl(const ColumnsWithTypeAndName & arguments) const override
{
if (arguments.empty() || arguments.size() > 2)
throw E... | fim | ClickHouse/ClickHouse | c |
#include <Common/CurrentThread.h>
#include <Common/Exception.h>
#include <Common/UnorderedSetWithMemoryTracking.h>
#include <Common/VectorWithMemoryTracking.h>
#include <Core/Settings.h>
#include <DataTypes/DataTypeLowCardinality.h>
#include <DataTypes/DataTypeNothing.h>
#include <DataTypes/DataTypeNullable.h>
#include... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>
ExecutableFunctionPtr prepare(const ColumnsWithTypeAndName & /*arguments*/) const override
{
return std::make_unique<ExecutableFunctionVariantAdaptor>(function_overload_resolver, variant_argument_index);
}
bool isSuitableForConstantFolding() const override { return false; }
... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Functions/FunctionsAES.h>
#include <Interpreters/Context.h>
#include <Common/OpenSSLHelpers.h>
#if USE_SSL
#include <openssl/evp.h>
#include <openssl/err.h>
#include <string>
namespace DB
{
namespace ErrorCodes
{
extern const int OPENSSL_ERROR;
}
namespace OpenSSLDetails
{
void onError(... | fim | ClickHouse/ClickHouse | cpp |
#pragma once
#include "config.h"
#include <base/MemorySanitizer.h>
#include <Columns/ColumnNullable.h>
#include <Columns/ColumnsNumber.h>
#include <DataTypes/DataTypeNullable.h>
#include <Common/OpenSSLHelpers.h>
#include <Common/safe_cast.h>
#if USE_SSL
#include <DataTypes/DataTypeString.h>
#include <Columns/Column... | fim | ClickHouse/ClickHouse | c |
#include <Columns/ColumnDecimal.h>
#include <Columns/ColumnFixedString.h>
#include <Columns/ColumnString.h>
#include <Columns/ColumnVector.h>
#include <Columns/ColumnsNumber.h>
#include <Core/UUID.h>
#include <DataTypes/DataTypeString.h>
#include <Functions/FunctionFactory.h>
#include <Functions/IFunction.h>
#include <... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <Columns/ColumnArray.h>
#include <Columns/ColumnString.h>
#include <Columns/ColumnVector.h>
#include <DataTypes/DataTypeArray.h>
#include <DataTypes/DataTypeString.h>
#include <DataTypes/DataTypesNumber.h>
#include <Functions/FunctionFactory.h>
#include <Functions/IFunction.h>
#include <IO/WriteB... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>rCardinality(bitmap1, bitmap2)";
FunctionDocumentation::Arguments arguments_bitmapXorCardinality = {
{"bitmap1", "First bitmap object. [`AggregateFunction(groupBitmap, T)`](/sql-reference/data-types/aggregatefunction)."},
{"bitmap2", "Second bitmap object. [`AggregateFunction(groupBitm... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <AggregateFunctions/AggregateFunctionFactory.h>
#include <Columns/ColumnAggregateFunction.h>
#include <Columns/ColumnArray.h>
#include <Columns/ColumnConst.h>
#include <Columns/ColumnVector.h>
#include <Columns/ColumnsNumber.h>
#include <Interpreters/castColumn.h>
#include <DataType... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Common/FrequencyHolder.h>
#if USE_NLP
#include <Functions/FunctionFactory.h>
#include <Functions/FunctionsTextClassification.h>
namespace DB
{
namespace
{
/* We need to solve zero-frequency problem for Naive Bayes Classifier
* If the bigram is not found in the text, we assume that ... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <functional>
#pragma clang diagnostic ignored "-Wreserved-identifier"
#include <Functions/FunctionsCodingIP.h>
#include <Columns/ColumnArray.h>
#include <Columns/ColumnConst.h>
#include <Columns/ColumnFixedString.h>
#include <Columns/ColumnString.h>
#include <Columns/ColumnTuple.h>
#include <Co... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <type_traits>
#include <Common/formatIPv6.h>
#include <Common/IPv6ToBinary.h>
#include <Columns/ColumnFixedString.h>
#include <Columns/ColumnNullable.h>
#include <Columns/ColumnString.h>
#include <Columns/ColumnsNumber.h>
namespace DB
{
namespace ErrorCodes
{
extern const int... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>olumnsWithTypeAndName & arguments) const override
{
if (arguments.empty() || arguments.size() > 2)
throw Exception(
ErrorCodes::NUMBER_OF_ARGUMENTS_DOESNT_MATCH, "Wrong number of arguments for function {}: should be 1 or 2", getName());
if (!checkAndGetData... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>d_name_left = arguments[0];
const auto & col_with_type_and_name_right = arguments[1];
const IColumn * col_left_untyped = col_with_type_and_name_left.column.get();
const IColumn * col_right_untyped = col_with_type_and_name_right.column.get();
const DataTypePtr & left_type =... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>
executeType<UInt32>(hash_col, num_buckets, res_col.get());
else if (which.isUInt64())
executeType<UInt64>(hash_col, num_buckets, res_col.get());
else if (which.isInt8())
executeType<Int8>(hash_col, num_buckets, res_col.get());
else if (which.isI... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>}
}
<|fim_prefix|>#include <Functions/FunctionsConversion.h>
namespace DB
{
namespace detail
{
template class FunctionConvert<DataTyp<|fim_middle|>eUInt8, NameToUInt8, ToNumberMonotonicity<UInt8>>;
<|endoftext|> | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>ypeUInt16, NameToUInt16, ToNumberMonotonicity<UInt16>>;
}
}
<|fim_prefix|>#include <Fu<|fim_middle|>nctions/FunctionsConversion.h>
namespace DB
{
namespace detail
{
template class FunctionConvert<DataT<|endoftext|> | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>
namespace detail
{
template class FunctionConvert<DataTypeUInt32, NameToUInt32, ToNumberMonotonicity<UInt32>>;
}
}
<|fim_prefix|>#include <Functions/FunctionsConversion.h>
namespace DB
{<|fim_middle|>
<|endoftext|> | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>64, NameToUInt64, ToNumberMonotonicity<UInt64>>;
}
}
<|fim_prefix|>#include <Functions/FunctionsConvers<|fim_middle|>ion.h>
namespace DB
{
namespace detail
{
template class FunctionConvert<DataTypeUInt<|endoftext|> | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>onvert<DataTypeUInt128, NameToUInt128, ToNumberMonotonicity<UInt128>>;
}
}
<|fim_prefix|>#include <Functions/FunctionsConversion.h>
namespace DB
<|fim_middle|>{
namespace detail
{
template class FunctionC<|endoftext|> | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>;
}
}
<|fim_prefix|>#include <Functions/<|fim_middle|>FunctionsConversion.h>
namespace DB
{
namespace detail
{
template class FunctionConvert<DataTypeUInt256, NameToUInt256, ToNumberMonotonicity<UInt256>><|endoftext|> | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>tionConvert<DataTypeInt8, NameToInt8, ToNumberMonotonicity<Int8>>;
}
}
<|fim_prefix|>#include <Functions/FunctionsConversion.h>
namespace DB
{
namespac<|fim_middle|>e detail
{
template class Func<|endoftext|> | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <Functions/FunctionsConvers<|fim_suffix|>detail
{
template class FunctionConvert<DataTypeInt16, NameToInt16, ToNumberMonotonicity<Int16>>;
}
}
<|fim_middle|>ion.h>
namespace DB
{
namespace <|endoftext|> | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>nConvert<DataTypeInt32, NameToInt32, ToNumberMonotonicity<Int32>>;
}
}
<|fim_prefix|>#include <Functions/FunctionsConversion.h>
namespace DB
{
name<|fim_middle|>space detail
{
template class Functio<|endoftext|> | fim | ClickHouse/ClickHouse | cpp |
#include <Functions/FunctionsConversion.h>
namespace DB
{
namespace detail
{
template class FunctionConvert<DataTypeInt64, NameToInt64, ToNumberMonotonicity<Int64>>;
}
}
<|endoftext|> | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <Functions/FunctionsConversion.h>
namespace DB
{
namespace detail
{
template class FunctionConvertFromString<DataTypeUInt8, NameToUInt8OrZero, ConvertFromStringExceptionMode::Zero>;
template class FunctionConvertFromString<DataTypeUInt16, NameToUInt16OrZero, ConvertFromStringExceptionMode::Zer... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <Functions/FunctionsCo<|fim_suffix|>t128>>;
}
}
<|fim_middle|>nversion.h>
namespace DB
{
namespace detail
{
template class FunctionConvert<DataTypeInt128, NameToInt128, ToNumberMonotonicity<In<|endoftext|> | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>FunctionConvert<DataTypeInt256, NameToInt256, ToNumberMonotonicity<Int256>>;
}
}
<|fim_prefix|>#include <Functions/FunctionsCo<|fim_middle|>nversion.h>
namespace DB
{
namespace detail
{
template class <|endoftext|> | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#includ<|fim_suffix|>umberMonotonicity<BFloat16>>;
}
}
<|fim_middle|>e <Functions/FunctionsConversion.h>
namespace DB
{
namespace detail
{
template class FunctionConvert<DataTypeBFloat16, NameToBFloat16, ToN<|endoftext|> | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|> NameToFloat32, ToNumberMonotonicity<Float32>>;
}
}
<|fim_prefix|>#include <Functions/FunctionsConversion.h>
namespace DB
{
namespace detail
{
templat<|fim_middle|>e class FunctionConvert<DataTypeFloat32,<|endoftext|> | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|><|fim_prefix|>#include <Functions/FunctionsConversion.h>
namespace DB
{
namespace det<|fim_middle|>ail
{
template class FunctionConvert<DataTypeFloat64, NameToFloat64, ToNumberMonotonicity<Float64>>;
}
}
<|endoftext|> | fim | ClickHouse/ClickHouse | cpp |
#include <Functions/FunctionsConversion.h>
namespace DB
{
namespace detail
{
template class FunctionConvert<DataTypeDate, NameToDate, ToDateMonotonicity<DataTypeDate>>;
}
}
<|endoftext|> | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>y<DataTypeDate32>>;
}
}
<|fim_prefix|>#inclu<|fim_middle|>de <Functions/FunctionsConversion.h>
namespace DB
{
namespace detail
{
template class FunctionConvert<DataTypeDate32, NameToDate32, ToDateMonotonicit<|endoftext|> | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <Functions/FunctionsConversion.h>
namespace DB
{
namespace detail
{
template class Functio<|fim_suffix|>ataTypeDateTime, NameToDateTime, ToDateTimeMonotonicity<DataTypeDateTime>>;
}
}
<|fim_middle|>nConvert<D<|endoftext|> | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <Functions<|fim_suffix|>plate class FunctionConvert<DataTypeDateTime, NameToDateTime32, ToDateTimeMonotonicity<DataTypeDateTime>>;
}
}
<|fim_middle|>/FunctionsConversion.h>
namespace DB
{
namespace detail
{
tem<|endoftext|> | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <Functions/FunctionsConversion.h>
namespace DB
{
namespace detail
{
templat<|fim_suffix|><|fim_middle|>e class FunctionConvert<DataTypeDateTime64, NameToDateTime64, ToDateTimeMonotonicity<DataTypeDateTime64>>;
}
}
<|endoftext|> | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <Functions/FunctionsConversion.h>
namespace DB
{
namespace detail
{
template class FunctionConvertFromString<DataTypeUInt8, NameToUInt8OrNull, ConvertFromStringExceptionMode::Null>;
template class FunctionConvertFromString<DataTypeUInt16, NameToUInt16OrNull, ConvertFromStringExceptionMode::Nul... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>
}
<|fim_prefix|>#include <Functions/FunctionsConversion.h>
namespace DB
{
namespace detail
{
template class FunctionConvert<DataType<|fim_middle|>UUID, NameToUUID, ToNumberMonotonicity<UInt128>>;
}
<|endoftext|> | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <Functions/FunctionsConversion.h>
namespace DB
{
namespace detail
{
<|fim_suffix|>32>>;
}
}
<|fim_middle|>
template class FunctionConvert<DataTypeIPv4, NameToIPv4, ToNumberMonotonicity<UInt<|endoftext|> | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>on.h>
namespace DB
{
namespace detail
{
template class FunctionConvert<DataTypeIPv6, NameToIPv6, ToNumberMonotonicity<UInt128>>;
}
}
<|fim_prefix|>#inc<|fim_middle|>lude <Functions/FunctionsConversi<|endoftext|> | fim | ClickHouse/ClickHouse | cpp |
#include <Functions/FunctionsConversion.h>
namespace DB
{
namespace detail
{
template class FunctionConvert<DataTypeString, NameToString, ToStringMonotonicity>;
}
}
<|endoftext|> | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <Functions/FunctionsConversion.h>
name<|fim_suffix|>UnixTimestamp, ToNumberMonotonicity<UInt32>>;
}
}
<|fim_middle|>space DB
{
namespace detail
{
template class FunctionConvert<DataTypeUInt32, NameTo<|endoftext|> | fim | ClickHouse/ClickHouse | cpp |
#include <Functions/FunctionsConversion.h>
namespace DB
{
namespace detail
{
template class FunctionConvert<DataTypeDecimal<Decimal32>, NameToDecimal32, UnknownMonotonicity>;
}
}
<|endoftext|> | fim | ClickHouse/ClickHouse | cpp |
#include <Functions/FunctionsConversion.h>
namespace DB
{
namespace detail
{
template class FunctionConvert<DataTypeDecimal<Decimal64>, NameToDecimal64, UnknownMonotonicity>;
}
}
<|endoftext|> | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <Functions/FunctionsConversion.h>
namespace DB
{
namespace detail
{
templ<|fim_suffix|>>, NameToDecimal128, UnknownMonotonicity>;
}
}
<|fim_middle|>ate class FunctionConvert<DataTypeDecimal<Decimal128<|endoftext|> | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <Functions/FunctionsConversion.h>
namespace DB
{
nam<|fim_suffix|>ass FunctionConvert<DataTypeDecimal<Decimal256>, NameToDecimal256, UnknownMonotonicity>;
}
}
<|fim_middle|>espace detail
{
template cl<|endoftext|> | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <Functions/FunctionsConversion.h>
namespace DB
{
namespace detail
{
template class FunctionConvertFromString<
DataTypeDateTime, NameParseDateTimeBestEffort, ConvertFromStringExceptionMode::Throw, ConvertFromStringParsingMode::BestEffort>;
template class FunctionConvertFromString<
DataT... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>Data(), col_to->getData(), scale_a, scale_b, result_scale, input_rows_count);
}
else if (first_col_const)
{
op.constantVector(first_col_const->template getValue<FirstArgValueType>(), second_col->getData(), col_to->getData(), scale_a, scale_b, result_scale, input_rows_co... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>ategory = FunctionDocumentation::Category::EmbeddedDictionary;
FunctionDocumentation documentation = {description, syntax, arguments, {}, returned_value, examples, introduced_in, category};
factory.registerFunction<FunctionRegionToName>(documentation);
}
}
}
<|fim_prefix|>#include <F... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>or<T>::Container & vec_from1 = col_vec1->getData();
const T const_from2 = col_const2->template getValue<T>();
typename ColumnUInt8::Container & vec_to = col_to->getData();
vec_to.resize(input_rows_count);
for (size_t i = 0; i < input_rows_count; ++i)
... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Functions/FunctionFactory.h>
#include <Functions/FunctionsExternalDictionaries.h>
namespace DB
{
/// Helper to get the description for dictGet<type> functions
static String getDictGetDescription(const String & type_name)
{
return fmt::format("Converts a dictionary attribute value to `{}` d... | fim | ClickHouse/ClickHouse | cpp |
#pragma once
#include <DataTypes/DataTypesNumber.h>
#include <DataTypes/DataTypesDecimal.h>
#include <DataTypes/DataTypeArray.h>
#include <DataTypes/DataTypeString.h>
#include <DataTypes/DataTypeDate.h>
#include <DataTypes/DataTypeDateTime.h>
#include <DataTypes/DataTypeTuple.h>
#include <DataTypes/DataTypeUUID.h>
#in... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|> ColumnPtr full_column = col_from_const->convertToFullColumn();
return executeBigIntType<FromType, first>(key_cols, full_column.get(), vec_to);
}
}
auto value = col_from_const->template getValue<FromType>();
to_little_endian(va... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Functions/FunctionsHashing.h>
#include <Functions/FunctionFactory.h>
/// FunctionsHashing instantiatio<|fim_suffix|>mespace DB
{
REGISTER_FUNCTION(HashingInt)
{
FunctionDocumentation::Description intHash32_description = R"(
Calculates a 32-bit hash of an integer.
The hash function is rel... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <Functions/FunctionsHashing.h>
#include <Functions/FunctionFactory.h>
/// FunctionsHashing instantiations are separated into files FunctionsHashing*.cpp
/// to better parallelize the build procedure and avoid MSan build failure
/// due to excessive resource consumption.
namespace DB
{
REGISTE... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <Functions/FunctionsHashing.h>
#include <Functions/FunctionFactory.h>
/// FunctionsHashing instantiations are separated into files FunctionsHashing*.cpp
/// to better parallelize the build procedure and avoid MSan build failure
/// due to excessive resource consumption.
namespace DB
{
REGISTE... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <type_traits>
#include <base/range.h>
#include <Formats/JSONExtractTree.h>
#include <Formats/FormatFactory.h>
#include <Common/typeid_cast.h>
#include <Common/assert_cast.h>
#include <Common/VectorWithMemoryTracking.h>
#include <Core/Settings.h>
#include <Col<|fim_suffix|>_in, category};
... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|> {
if (!isString(arguments[0]))
throw Exception(ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT,
"Illegal type {} of argument of function {}. Must be String.",
arguments[0]->getName(), getName());
return std::make_shared<DataTypeMap>(std::make_shared<DataT... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <Functions/FunctionFactory.h>
#include <Functions/FunctionsLogical.h>
#include <Functions/IFunctionAdaptors.h>
#include <Functions/logical.h>
#include <Columns/ColumnConst.h>
#include <Columns/ColumnNullable.h>
#include <Columns/ColumnVector.h>
#include <Columns/ColumnsNumber.h>
#include <Column... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <base/types.h>
#include <Core/Defines.h>
#include <DataTypes/IDataType.h>
#include <DataTypes/DataTypesNumber.h>
#include <Functions/IFunction.h>
#include <Interpreters/Context_fwd.h>
#if USE_EMBEDDED_COMPILER
# include <DataTypes/Native.h>
# include <llvm/IR/IRBuilder.h>
#e... | fim | ClickHouse/ClickHouse | c |
#include "config.h"
#include <Storages/MergeTree/MergeTreePartInfo.h>
#if CLICKHOUSE_CLOUD
#include <Storages/SharedMergeTree/MergeMutateIntention.h>
#endif
#include <Functions/IFunction.h>
#include <Functions/FunctionHelpers.h>
#include <Functions/FunctionFactory.h>
#include <Columns/ColumnString.h>
#include <DataT... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>rayJoin())
throw Exception(ErrorCodes::BAD_ARGUMENTS, "Expression with arrayJoin or other unusual action cannot be captured");
UnorderedMapWithMemoryTracking<std::string, DataTypePtr> arguments_map;
for (const auto * input : actions_dag.getInputs())
arguments_map[... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#pragma once
#include <Core/Settings.h>
#include <Columns/ColumnArray.h>
#include <Columns/ColumnConst.h>
#include <Columns/ColumnString.h>
#include <Columns/ColumnVector.h>
#include <Columns/ColumnsNumber.h>
#include <DataTypes/DataTypeArray.h>
#include <DataTypes/DataTypeString.h>
#include <DataTypes/D... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#pragma once
#include <Columns/ColumnArray.h>
#include <Columns/ColumnConst.h>
#include <Columns/ColumnString.h>
#include <Columns/ColumnVector.h>
#include <DataTypes/DataTypeArray.h>
#include <DataTypes/DataTypeString.h>
#include <DataTypes/DataTypesNumber.h>
#include <Functions/FunctionHelpers.h>
#incl... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|> const int ILLEGAL_TYPE_OF_ARGUMENT;
extern const int ILLEGAL_COLUMN;
}
template <typename Impl>
class FunctionsMultiStringSearch final : public IFunction
{
public:
static constexpr auto name = Impl::name;
static FunctionPtr create(ContextPtr context)
{
const auto & settings = c... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#pragma once
#include <DataTypes/DataTypeNothing.h>
#include <DataTypes/DataTypeTuple.h>
#include <DataTypes/IDataType.h>
#include <Functions/IFunction.h>
#include <Functions/FunctionsComparison.h>
#include <Common/quoteString.h>
#include <Columns/ColumnVariant.h>
#include <Columns/ColumnDynamic.h>
namesp... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Functions/FunctionFactory.h>
/// Include this last — see the reason inside
#include <Functions/FunctionsNumericIndexedVector.h>
namespace DB
{
REGISTER_FUNCTION(NumericIndexedVector)
{
/// numericIndexedVectorBuild
{
FunctionDocumentation::Description description = R"(
Creates... | fim | ClickHouse/ClickHouse | cpp |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.