text stringlengths 14 100k | source stringclasses 1
value | repo stringclasses 810
values | language stringclasses 13
values |
|---|---|---|---|
<|fim_suffix|>arguments = {
{"x", "The angle in radians.", {"(U)Int*", "Float*", "Decimal*"}}
};
FunctionDocumentation::ReturnedValue returned_value = {"Returns the cosine of `x`.", {"Float*"}};
FunctionDocumentation::Examples examples = {{"Usage example", "SELECT cos(0);", "1"}};
FunctionDocume... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <Functions/FunctionFactory.h>
#include <Functions/FunctionMathUnary.h>
namespace DB
{
namespace
{
struct CoshName
{
static constexpr auto name = "cosh";
};
using FunctionCosh = FunctionMathUnary<UnaryFunctionVectorized<CoshName, cosh>>;
}
REGISTER_FUNCTION(Cosh)
{
FunctionDocumentatio... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>βββββββββββββββββββββ΄ββββββββββββββββββββββββββββββββββ΄ββββββββββββββββββββββββββββββββββ΄βββββββββββββββββββββββββββββββββββ΄βββββββββββββββββββββββββββββββββββ΄ββββββββββββββββββββββββββββββββββββ
)"
}
};
FunctionDocumentation::IntroducedIn introduced_in = {20, 8};
FunctionDocumenta... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <Core/Settings.h>
#include <Functions/IFunction.h>
#include <Functions/FunctionFactory.h>
#include <Functions/FunctionHelpers.h>
#include <Columns/ColumnFixedString.h>
#include <Columns/ColumnString.h>
#include <Columns/ColumnsNumber.h>
#include <DataTypes/DataTypesNumber.h>
#include <DataTypes/D... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|> };
FunctionDocumentation::IntroducedIn introduced_in = {21, 1};
FunctionDocumentation::Category category = FunctionDocumentation::Category::StringSearch;
FunctionDocumentation documentation = {description, syntax, arguments, {}, returned_value, examples, introduced_in, category};
factor... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <Functions/FunctionsStringSearch.h>
#include <Functions/FunctionFactory.h>
#include <Functions/CountSubstringsImpl.h>
namespace DB
{
namespace
{
struct NameCountSubstringsCaseInsensitive
{
static constexpr auto name = "countSubstringsCaseInsensitive";
};
using FunctionCountSubstringsCaseI... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>tSubstriβ―ΡΠΊΠ°', 'ΠΠ')ββ
β 4 β
ββββββββββββββββββββββββββββ
)"
},
{
"With start_pos argument",
"SELECT countSubstringsCaseInsensitiveUTF8('Π»ΠΎΠΆΠΊΠ°, ΠΊΠΎΡΠΊΠ°, ΠΊΠ°ΡΡΠΎΡΠΊΠ°', 'ΠΠ', 13);",
R"(
ββcountSubstriβ―, 'ΠΠ', 13)ββ
β 2 β
ββββββ... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#if WITH_COVERAGE_DEPTH
#include <DataTypes/DataTypeArray.h>
#include <DataTypes/DataTypesNumber.h>
#include <DataTypes/DataTypeString.h>
#include <Columns/ColumnArray.h>
#include <Columns/ColumnVector.h>
#include <Columns/ColumnsNumber.h>
#include <Columns/ColumnString.h>
#include <Columns/ColumnConst.h... | 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 FunctionCurrentDatabase final : public IFunction
{
const String d... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <Access/AccessControl.h>
#include <Access/ContextAccess.h>
#include <Access/User.h>
#include <Columns/ColumnArray.h>
#include <Columns/ColumnConst.h>
#include <Columns/ColumnString.h>
#include <DataTypes/DataTypeArray.h>
#include <DataTypes/DataTypeString.h>
#include <Functions/FunctionFactory.h>... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>ββββββββββββββββββββββββββββββββββββ
)"}}},
.introduced_in = {25, 2},
.category = FunctionDocumentation::Category::Other,
});
factory.registerAlias("current_query_id", FunctionCurrentQueryID::name, FunctionFactory::Case::Insensitive);
}
}
<|fim_prefix|>#include <Columns/ColumnCons... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <base/sort.h>
#include <Access/AccessControl.h>
#include <Access/ContextAccess.h>
#include <Access/EnabledRolesInfo.h>
#include <Access/User.h>
#include <Columns/ColumnArray.h>
#include <Columns/ColumnConst.h>
#include <Columns/ColumnString.h>
#include <DataTypes/DataTypeArray.h>
#include <DataT... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>ation::Syntax syntax = "currentSchemas(bool)";
FunctionDocumentation::Arguments arguments = {
{"bool", "A boolean value, which is ignored.", {"Bool"}}
};
FunctionDocumentation::ReturnedValue returned_value = {"Returns a single-element array with the name of the current database.", {"Ar... | 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>
#includ<|fim_suffix|>
)",
R"(
ββCURRENT_USERββ
β default β
ββββββββββββββββ
)"}
};
FunctionD... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>](#toRelativeYearNum)).
If the unit `week` was specified, then `dateDiff` assumes that weeks start on Monday.
Note that this behavior is different from that of function `toWeek()` in which weeks start by default on Sunday.
For an alternative to `dateDiff`, see function [`age`](#age).
)";
Functio... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <Common/DateLUTImpl.h>
#include <Core/DecimalFunctions.h>
#include <IO/WriteHelpers.h>
#include <DataTypes/DataTypeDate.h>
#include <DataTypes/DataTypeDate32.h>
#include <DataTypes/DataTypeDateTime.h>
#include <DataTypes/DataTypeDateTime64.h>
#include <DataTypes/DataTypeString.h>
#include <Colu... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <Functions/FunctionFactory.h>
#include <Functions/IFunction.h>
#include <Functions/FunctionHelpers.h>
#include <DataTypes/DataTypeDateTime64.h>
#include <DataTypes/DataTypesDecimal.h>
#include <DataTypes/DataTypesNumber.h>
#include <Columns/ColumnConst.h>
#include <Columns/ColumnsDateTime.h>
#inc... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>eToUUIDv7(toDateTime('2021-08-15 18:57:56', 'Asia/Shanghai'));
)",
R"(
ββdateTimeToUUIDv7(toDateTime('2021-08-15 18:57:56', 'Asia/Shanghai'))ββ
β 018f05af-f4a8-778f-beee-1bedbc95c93b β
βββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββ... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>des::ILLEGAL_TYPE_OF_ARGUMENT, "First argument for function {} must be constant string: "
"name of datepart", getName());
String datepart_param = Poco::toLower(datepart_column->getValue<String>());
IntervalKind::Kind datepart_kind = IntervalKind::Kind::Second;
if (... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|> return code_point <= max_legal_unicode_value;
}
};
using FunctionDecodeHTMLComponent = FunctionStringToString<FunctionDecodeHTMLComponentImpl, DecodeHTMLComponentName>;
}
REGISTER_FUNCTION(DecodeHTMLComponent)
{
FunctionDocumentation::Description description = R"(
Decodes HT... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <Columns/ColumnString.h>
#include <Functions/FunctionFactory.h>
#include <Functions/FunctionStringToString.h>
#include <Common/StringUtils.h>
#include <base/hex.h>
#include <base/find_symbols.h>
namespace DB
{
namespace ErrorCodes
{
extern const int ILLEGAL_TYPE_OF_ARGUMENT;
}
namespace
{
... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include "config.h"
#if USE_SSL
#include <Functions/FunctionFactory.h>
#include <Functions/FunctionsAES.h>
namespace DB
{
namespace
{
struct DecryptImpl
{
static constexpr auto name = "decrypt";
static constexpr auto compatibility_mode = OpenSSLDetails::CompatibilityMode::OpenSSL;
static ... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <Columns/ColumnConst.h>
#include <DataTypes/IDataType.h>
#include <Functions/IFunction.h>
#include <Functions/FunctionFactory.h>
#include <Core/Field.h>
namespace DB
{
namespace
{
/// Returns global default value for type of passed argument (example: 0 for numeric types, '' for String).
class ... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>nt8", "String", "NULL"}};
FunctionDocumentation::Examples examples = {
{
"Usage example",
R"(
SELECT defaultValueOfTypeName('Int8');
)",
R"(
ββdefaultValueOfTypeName('Int8')ββ
β 0 β
ββββββββββββββββββββββββββββββββββ
)"
},
... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <DataTypes/IDataType.h>
#include <Functions/FunctionFactory.h>
#include <Functions/FunctionMathUnary.h>
namespace DB
{
namespace
{
struct DegreesName
{
static constexpr auto name = "degrees";
};
Float64 degrees(Float64 r)
{
Float64 degrees = r * (180 / M_PI);
return degrees;
}
us... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <DataTypes/IDataType.h>
#include <Functions/FunctionHelpers.h>
#include <base/demangle.h>
#include <Columns/ColumnString.h>
#include <DataTypes/DataTypeString.h>
#include <Functions/IFunction.h>
#include <Functions/FunctionFactory.h>
#include <IO/WriteHelpers.h>
#include <Access/Common/AccessFlag... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>egisterFunction<FunctionDivideOrNull>(documentation);
}
}
<|fim_prefix|>#include <Functions/FunctionFactory.h>
#include <Functions/FunctionBinaryArithmetic.h>
namespace DB
{
namespace ErrorCodes
{
extern const int LOGICAL_ERROR;
}
template <typename A, typename B>
struct DivideFloatingImpl
{
us... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <Functions/FunctionsDecimalArithmetics.h>
#include <Functions/FunctionFactory.h>
namespace DB
{
namespace ErrorCodes
{
extern const int DECIMAL_OVERFLOW;
extern const int ILLEGAL_DIVISION;
}
namespace
{
struct DivideDecimalsImpl
{
static constexpr auto name = "divideDecimal";
... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>t32>(const UInt32 * __restrict, UInt8, UInt32 * __restrict, size_t);
template void divideImpl<Int64, Int64, Int64>(const Int64 * __restrict, Int64, Int64 * __restrict, size_t);
template void divideImpl<Int64, Int32, Int64>(const Int64 * __restrict, Int32, Int64 * __restrict, size_t);
template void divide... | fim | ClickHouse/ClickHouse | cpp |
#pragma once
#include <base/types.h>
namespace DB
{
template <typename A, typename B, typename ResultType>
extern void divideImpl(const A * __restrict a_pos, B b, ResultType * __restrict c_pos, size_t size);
}
<|endoftext|> | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Columns/ColumnConst.h>
#include <Columns/IColumn.h>
#include <Functions/IFunction.h>
#include <Functions/Functi<|fim_suffix|>tReturnTypeImpl(const DataTypes & /*arguments*/) const override
{
return std::make_shared<DataTypeString>();
}
ColumnPtr executeImpl(const ColumnsWith... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <Functions/IFunction.h>
#include <Functions/FunctionFactory.h>
#include <Functions/Fun<|fim_suffix|>ception(ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT,
"First argument for function {} must be Variant or Array of Variant. Actual {}",
getName(),
... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <Functions/IFunction.h>
#include <Functions/FunctionFactory.h>
#include <Functions/FunctionHelpers.h>
#include <DataTypes/IDataType.h>
#include <DataTypes/DataTypesBinaryEncoding.h>
#include <DataTypes/DataTypeFactory.h>
#include <DataTypes/DataTypeString.h>
#include <DataTypes/DataTypeLowCardina... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <DataTypes/DataTypeString.h>
#include <Functions/FunctionFactory.h>
#include <Functions/FunctionStringOrArrayToT.h>
#include <Functions/IFunctionAdaptors.h>
#include <Functions/EmptyImpl.h>
#include <Columns/ColumnObject.h>
namespace DB
{
namespace ErrorCodes
{
extern const int BAD_ARGUMEN... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <Columns/ColumnString.h>
#include <Functions/FunctionFactory.h>
#include <Functions/FunctionStringToString.h>
#include <base/find_symbols.h>
namespace DB
{
namespace ErrorCodes
{
extern const int ILLEGAL_TYPE_OF_ARGUMENT;
}
namespace
{
struct EncodeXMLComponentName
{
static... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>ring"}},
{"aad", "Additional authenticated data. It isn't encrypted, but it affects decryption. Works only in `-gcm` modes, for others it throws an exception.", {"String"}}
};
FunctionDocumentation::ReturnedValue returned_value = {"Returns binary string ciphertext.", {"String"}};
Funct... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <DataTypes/DataTypeString.h>
#include <Functions/FunctionFactory.h>
#include <Functions/FunctionStartsEndsWith.h>
namespace DB
{
using FunctionEndsWith = FunctionStartsEndsWith<NameEndsWith>;
using FunctionEndsWithCaseInsensitive = FunctionStartsEndsWith<NameEndsWithCaseInsensitive>;
REGISTER... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <Functions/FunctionFactory.h>
#include <Functions/FunctionStartsEndsWith.h>
namespace DB
{
using FunctionEndsWithUTF8 = FunctionStartsEndsWith<NameEndsWithUTF8>;
using FunctionEndsWithCaseInsensitiveUTF8 = FunctionStartsEndsWith<NameEndsWithCaseInsensitiveUTF8>;
REGISTER_FUNCTION(EndsWithUTF8... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <Functions/FunctionFactory.h>
#include <Functions/FunctionsComparison.h>
#include <Functions/FunctionsLogical.h>
namespace DB
{
using FunctionEquals = FunctionComparison<EqualsOp, NameEquals>;
REGISTER_FUNCTION(Equals)
{
// Documentation for equals
FunctionDocumentation::Description d... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <Functions/FunctionMathUnary.h>
#include <Functions/FunctionFactory.h>
namespace DB
{
namespace
{
struct ErfName { static constexpr auto name = "erf"; };
using FunctionErf = FunctionMathUnary<UnaryFunctionVectorized<ErfName, std::erf>>;
}
REGISTER_FUNCTION(Erf)
{
FunctionDocumentation::De... | fim | ClickHouse/ClickHouse | cpp |
#include <Functions/FunctionMathUnary.h>
#include <Functions/FunctionFactory.h>
namespace DB
{
namespace
{
struct ErfcName { static constexpr auto name = "erfc"; };
using FunctionErfc = FunctionMathUnary<UnaryFunctionVectorized<ErfcName, std::erfc>>;
}
REGISTER_FUNCTION(Erfc)
{
FunctionDocumentation::Descriptio... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <Functions/IFunction.h>
#include <Functions/FunctionFactory.h>
#include <DataTypes/DataTypeLowCardinality.h>
#include <DataTypes/DataTypeString.h>
#include <Columns/ColumnString.h>
#include <Common/ErrorCodes.h>
namespace DB
{
namespace ErrorCodes
{
extern const int BAD_ARGUMENTS;
}
/** er... | fim | ClickHouse/ClickHouse | cpp |
#include <Core/ColumnsWithTypeAndName.h>
#include <Functions/IFunction.h>
#include <Functions/FunctionFactory.h>
#include <Functions/FunctionHelpers.h>
#include <DataTypes/DataTypeAggregateFunction.h>
#include <Columns/ColumnAggregateFunction.h>
#include <Common/FunctionDocumentation.h>
#include <Common/typeid_cast.h>
... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>'s argument is a subquery
/// and the whole EXISTS expression is either rewritten to '1 IN (SELECT 1 FROM <subquery>)'
/// if subquery is not correlated or it's replaced with JOINs during decorrelation.
class FunctionExists final : public IFunction
{
public:
String getName() const override { return "e... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>sitive);
}
}
<|fim_prefix|>#include <Functions/FunctionMathUnary.h>
#include <Functions/FunctionFactory.h>
namespace DB
{
namespace ErrorCodes
{
extern const int NOT_IMPLEMENTED;
}
namespace
{
struct ExpName { static constexpr auto name = "exp"; };
#if USE_FASTOPS
namespace
{
struct Impl
{
... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <Functions/FunctionMathUnary.h>
#include <Functions/FunctionFactory.h>
#include <base/preciseExp10.h>
namespace DB
{
namespace
{
struct Exp10Name { stati<|fim_suffix|>"Float*"}};
FunctionDocumentation::Examples examples = {{"Usage example", "SELECT exp10(2);", "100"}};
FunctionDocumenta... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>rgument.
)";
FunctionDocumentation::Syntax syntax = "exp2(x)";
FunctionDocumentation::Arguments arguments = {
{"x", "The exponent.", {"(U)Int*", "Float*", "Decimal*"}}
};
FunctionDocumentation::ReturnedValue returned_value = {"Returns 2^x", {"Float*"}};
FunctionDocumentation::E... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>ing groups (sub-patterns), the function matches the input string against the first capturing group.
)";
FunctionDocumentation::Syntax syntax = "extract(haystack, pattern)";
FunctionDocumentation::Arguments arguments = {
{"haystack", "String from which to extract.", {"String"}},
... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>e].length;
}
pos += matches[0].offset + matches[0].length;
return true;
}
};
using FunctionExtractAll = FunctionTokens<ExtractAllImpl>;
}
REGISTER_FUNCTION(ExtractAll)
{
FunctionDocumentation::Description description = R"(
Like [`extract`](#extract), but returns an arr... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>...
// ]
size_t row_offset = 0;
for (const auto matches_per_row : number_of_matches_per_row)
{
const size_t next_row_offset = row_offset + matches_per_row * groups_count;
for (size_t group_id = 0; group_id < groups_count; ++g... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>ontextPtr ctx){ return FunctionExtractAllGroups::create(ctx, "extractAllGroupsHorizontal", ExtractAllGroupsResultKind::HORIZONTAL); }, documentation);
}
}
<|fim_prefix|>#include <Functions/FunctionFactory.h>
#include <Functions/extractAllGroups.h>
namespace DB
{
REGISTER_FUNCTION(ExtractAllGroupsHorizo... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>],['Date','Tue, 22 Jan 2019 00:26:14 GMT'],['Content-Type','text/html; charset=UTF-8'],['Connection','keep-alive']]
)"
}
};
FunctionDocumentation::IntroducedIn introduced_in = {20, 5};
FunctionDocumentation::Category category = FunctionDocumentation::Category::StringSplitting;
... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <Columns/ColumnString.h>
#include <Columns/ColumnArray.h>
#include <Columns/ColumnConst.h>
#include <DataTypes/DataTypeArray.h>
#include <DataTypes/DataTypeString.h>
#include <Functions/FunctionFactory.h>
#include <Functions/FunctionHelpers.h>
#include <Functions/Regexps.h>
#include <memory>
#in... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <Columns/ColumnsNumber.h>
#include <Columns/ColumnMap.h>
#include <Core/Settings.h>
#include <Functions/FunctionFactory.h>
#include <Functions/IFunction.h>
#include <DataTypes/DataTypeMap.h>
#include <DataTypes/DataTypeString.h>
#include <Interpreters/Context.h>
#include <Functions/keyvaluepa... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>XHTML.
This function removes HTML tags, comments, and script/style elements, leaving only the text content. It handles:
- Removal of all HTML/XML tags
- Removal of comments (`<!-- -->`)
- Removal of script and style elements with their content
- Processing of CDATA sections (copied verbatim)
- Proper whi... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <Columns/ColumnString.h>
#include <DataTypes/DataTypeDateTime.h>
#include <DataTypes/DataTypeDateTime64.h>
#include <Functions/FunctionHelpers.h>
#include <Functions/extractTimeZoneFromFunctionArguments.h>
#include <Common/DateLUT.h>
#include <Common/DateLUTImpl.h>
namespace DB
{
namespace Err... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <Common/DateLUT.h>
#include <Core/ColumnsWithTypeAndName.h>
#include <string>
namespace DB
{
class Block;
std::string extractTimeZoneNameFromColumn(const IColumn * column, const String & column_name);
/// Determine working timezone either from optional argument with time zone ... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>rial of an integer value.
The factorial of 0 is 1. Likewise, the `factorial()` function returns `1` for any negative value.
The maximum positive value for the input argument is `20`, a value of `21` or greater will cause an exception.
)";
FunctionDocumentation::Syntax syntax = "factorial(n)";
... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <Columns/ColumnConst.h>
#include <Columns/ColumnString.h>
#include <Columns/ColumnVector.h>
#include <DataTypes/DataTypesNumber.h>
#include <Disks/IDisk.h>
#include <Functions/FunctionFactory.h>
#include <Functions/IFunction.h>
#include <Interpreters/Context.h>
#include <Poco/Util/AbstractConfigu... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <Functions/IFunction.h>
#include <Functions/FunctionFactory.h>
#include <Functions/FunctionHelpers.h>
#include <DataTypes/DataTypeAggregateFunction.h>
#include <Columns/ColumnAggregateFunction.h>
#include <Common/typeid_cast.h>
namespace DB
{
namespace ErrorCodes
{
<|fim_suffix|> arguments) ... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <Columns/ColumnArray.h>
#include <Columns/ColumnVector.h>
#include <Columns/ColumnsDateTime.h>
#include <Columns/IColumn.h>
#include <DataTypes/DataTypeArray.h>
#include <DataTypes/DataTypeDate.h>
#include <DataTypes/DataTypeDate32.h>
#include <DataTypes/DataTypesNumber.h>
#include <DataTypes/IDa... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <Functions/FunctionFactory.h>
#include <Functions/FunctionStringToString.h>
#include <Functions/StringHelpers.h>
#include <base/find_symbols.h>
namespace DB
{
struct FirstLine
{
static size_t getReserveLengthForElement() { return 16; }
static void execute(Pos data, size_t size, Pos & r... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|> bool useDefaultImplementationForConstants() const override { return true; }
bool useDefaultImplementationForLowCardinalityColumns() const override { return false; }
bool useDefaultImplementationForNulls() const override { return false; }
bool isVariadic() const override { return true; }
... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <Functions/IFunction.h>
#include <Functions/FunctionFactory.h>
#include <Functions/FunctionHelpers.h>
#include <DataTypes/DataTypeTuple.h>
#include <DataTypes/DataTypeNullable.h>
#include <DataTypes/flattenTuple.h>
#include <Columns/ColumnTuple.h>
#include <Columns/ColumnNullable.h>
namespace DB... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <Columns/ColumnArray.h>
#include <Columns/ColumnConst.h>
#include <Columns/ColumnTuple.h>
#include <Columns/IColumn.h>
#include <Columns/ColumnsNumber.h>
#include <DataTypes/DataTypeArray.h>
#include <DataTypes/DataTypeTuple.h>
#include <Functions/FunctionFactory.h>
#include <Functions/FunctionHe... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include "config.h"
#if USE_ICU
#include <Columns/ColumnString.h>
#include <Functions/FunctionFactory.h>
#include <Functions/FunctionStringToString.h>
#include <unicode/uchar.h>
#include <unicode/unorm2.h>
#include <unicode/ustring.h>
#include <unicode/utypes.h>
#pragma clang diagnostic push
#pragma cl... | 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|>formatted query", {"String"}},
.examples{
{"multiline",
"SELECT formatQuerySingleLine('select a, b FRom tab WHERE a > 3 and b < 3');",
"SELECT a, b FROM tab WHERE (a > 3) AND (b < 3)"}},
.introduced_in = {23, 11},
.c... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>nst override { return true; }
bool useDefaultImplementationForConstants() const override { return true; }
ColumnNumbers getArgumentsThatAreAlwaysConstant() const override { return {1}; }
DataTypePtr getReturnTypeImpl(const ColumnsWithTypeAndName & arguments) const override
{
Funct... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>ption = R"(
Given a size (number of bytes), this function returns a readable, rounded size with suffix (KB, MB, etc.) as a string.
The opposite operations of this function are [`parseReadableSize`](#parseReadableSize).
)";
FunctionDocumentation::Syntax syntax = "formatReadableDecimalSize(value[, ... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <Functions/FunctionFactory.h>
#include <Functions/formatReadable.h>
#include <Common/formatReadable.h>
namespace DB
{
REGISTER_FUNCTION(FormatReadableQuantity)
{
FunctionDocumentation::Description description = R"(
G<|fim_suffix|> no_decimals,
formatReadableQuantity(98765432101234, 4) ... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|> FunctionDocumentation::Arguments arguments = {
{"value", "Size in bytes.", {"Int8", "Int16", "Int32", "Int64", "UInt8", "UInt16", "UInt32", "UInt64", "Float32", "Float64", "Decimal"}},
{"precision", "Optional. Number of digits after the decimal point. Defaults to 2.", {"const UInt8"}}
... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|> break;
[[fallthrough]];
case Days:
processUnit(24 * 3600, 0, " day", 4, whole_part, fractional_str, buf_to, has_output, min_unit, min_unit == Days);
if (min_unit == Days)
break;
... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>sage",
R"(
SELECT formatRow('CSV', number, 'good')
FROM numbers(3)
)",
R"(
ββformatRow('CSV', number, 'good')ββ
β 0,"good"
β
β 1,"good"
β
β 2,"good"
β
ββββββββββββββββββββββββββββββββββββ
)"
},
... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>ng and iterators invalidation.
/// These are exactly what is between {} tokens, for `Hello {} world {}` we will have [`Hello `, ` world `, ``].
VectorWithMemoryTracking<String> substrings;
Format::init(pattern, argument_number, constant_strings, index_positions, substrings);
... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>ion::ReturnedValue returned_value_fromDaysSinceYearZero32 = {"Returns the date corresponding to the number of days passed since year zero.", {"Date32"}};
FunctionDocumentation::Examples examples_fromDaysSinceYearZero32 =
{
{"Convert days since year zero to dates", R"(
SELECT
fromDaysSinceY... | fim | ClickHouse/ClickHouse | cpp |
#include <Columns/ColumnNullable.h>
#include <Columns/ColumnString.h>
#include <Columns/ColumnVector.h>
#include <Columns/ColumnsNumber.h>
#include <Core/callOnTypeIndex.h>
#include <DataTypes/DataTypeString.h>
#include <DataTypes/DataTypeNullable.h>
#include <DataTypes/DataTypesNumber.h>
#include <DataTypes/IDataType.... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>,
R"(
SELECT fromUnixTimestamp64Micro(1640995200123456)
)",
R"(
ββfromUnixTimestamp64Micro(1640995200123456)ββ
β 2022-01-01 00:00:00.123456 β
ββββββββββββββββββββββββββββββββββββββββββββββ
)"
}
};
FunctionDocumentation::IntroducedIn introduced_in... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|> };
FunctionDocumentation::ReturnedValue returned_value = {"A `DateTime64` value with millisecond precision.", {"DateTime64(3)"}};
FunctionDocumentation::Examples examples = {
{
"Usage example",
R"(
SELECT fromUnixTimestamp64Milli(1640995200123)
)",
R"(
ββfrom... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>ntation documentation = {description, syntax, arguments, {}, returned_value, examples, introduced_in, category};
factory.registerFunction("fromUnixTimestamp64Nano",
[](ContextPtr context){ return std::make_shared<FunctionFromUnixTimestamp64>(9, "fromUnixTimestamp64Nano", context); }, document... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>ontext){ return std::make_shared<FunctionFromUnixTimestamp64>(0, "fromUnixTimestamp64Second", context); }, documentation);
}
}
<|fim_prefix|>#include <Functions/FunctionUnixTimestamp64.h>
#include <Functions/FunctionFactory.h>
namespace DB
{
REGISTER_FUNCTION(FromUnixTimestamp64)
{
/// fromUnixTime... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>Chars & chars_to = col_to->getChars();
size_t total_size = 0;
if (common::mulOverflow(input_rows_count, n, total_size))
throw Exception(ErrorCodes::DECIMAL_OVERFLOW, "Decimal math overflow");
chars_to.resize(total_size);
const auto * ptr_i... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <Columns/ColumnString.h>
#include <Common/QueryFuzzer.h>
#include <Core/Settings.h>
#include <DataTypes/DataTypeString.h>
#include <Functions/FunctionFactory.h>
#include <Functions/FunctionHelpers.h>
#include <IO/WriteBufferFromString.h>
#include <Interpreters/Context.h>
#include <Interpreters/ex... | 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 DB
{
namespace
{
struct NameGCD { static constexpr auto name = "gcd"; };
template <typename A, typename B>
struct GCDImpl : pu... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>eries_identifier[, start_value])";
FunctionDocumentation::Arguments arguments = {
{"series_identifier", "Series identifier", {"const String"}},
{"start_value", "Optional. Starting value for the counter. Defaults to 0. Note: this value is only used when creating a new series and is igno... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>entDescriptor::ColumnValidator>(&isColumnConst), "const UInt*"}
};
validateFunctionArguments(*this, arguments, mandatory_args, optional_args);
return std::make_shared<DataTypeUInt64>();
}
ColumnPtr executeImpl(const ColumnsWithTypeAndName & arguments, const DataTypePtr &,... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>t64_t generateSnowflakeID();
}
<|fim_prefix|>#pragma once
#include <Core/Types.h>
namespace DB
{
<|fim_middle|>
uin<|endoftext|> | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include "config.h"
#if USE_ULID
#include <Columns/ColumnFixedString.h>
#include <DataTypes/DataTypeFixedString.h>
#include <Functions/FunctionFactory.h>
#include <Functions/FunctionHelpers.h>
#include <Functions/IFunction.h>
#include <Interpreters/Context.h>
#include <ulid.h>
namespace DB
{
namespa... | fim | ClickHouse/ClickHouse | cpp |
#include <DataTypes/DataTypeUUID.h>
#include <Functions/FunctionFactory.h>
#include <Functions/FunctionHelpers.h>
#include <Functions/FunctionsRandom.h>
#include <Core/UUID.h>
namespace DB
{
class FunctionGenerateUUIDv4 : public IFunction
{
public:
static constexpr auto name = "generateUUIDv4";
static Functi... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>ls on UUID structure, counter management, and concurrency guarantees.
:::note
As of September 2025, version 7 UUIDs are in draft status and their layout may change in future.
:::
)";
FunctionDocumentation::Syntax syntax = "generateUUIDv7([expr])";
FunctionDocumentation::Arguments arguments = ... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>resolution' ({}) of function {} is out of bounds because the maximum resolution in H3 library is {}",
static_cast<uint8_t>(res),
getName(),
MAX_H3_RES);
LatLng coord;
coord.lng = degsToRads(lon);
coord.lat = d... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>st override
{
auto non_const_arguments = arguments;
for (auto & argument : non_const_arguments)
argument.column = argument.column->convertToFullColumnIfConst();
const auto * col_lon = checkAndGetColumn<ColumnFloat64>(non_const_arguments[0].column.get());
if... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>dName & arguments, const DataTypePtr &, size_t input_rows_count) const override
{
const IColumn * encoded = arguments[0].column.get();
ColumnPtr res_column;
if (tryExecute<ColumnString>(encoded, res_column, input_rows_count) ||
tryExecute<ColumnFixedString>(encoded... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>e", "Latitude part of the coordinate to encode. Range: `[-90Β°, 90Β°]`.", {"Float32", "Float64"}},
{"precision", "Optional. Length of the resulting encoded string. Default: 12. Range: `[1, 12]`.", {"(U)Int*"}}
};
FunctionDocumentation::ReturnedValue returned_value = {
"Returns an alp... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>cision, res, input_rows_count);
return res;
}
};
}
REGISTER_FUNCTION(GeohashesInBox)
{
FunctionDocumentation::Description description = R"(
Returns an array of [geohash](https://en.wikipedia.org/wiki/Geohash)-encoded strings of given precision that fall inside and intersect boundaries o... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>LineString<Point> linestring = getLineStringFromField<Point>(field);
res_data.push_back(FunctionToCalculate()(linestring));
break;
}
case GeometryColumnType::MultiLinestring:
{
MultiLineString<Point> multilinestring = getM... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#pragma once
#include <Core/ColumnWithTypeAndName.h>
#include <Core/Types.h>
#include <boost/geometry/geometries/geometries.hpp>
#include <boost/geometry.hpp>
#include <boost/geometry/geometries/point_xy.hpp>
#include <Columns/ColumnsNumber.h>
#include <Columns/ColumnArray.h>
#include <Columns/ColumnTu... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Functions/IFunction.h>
#include <Functions/FunctionFactory.h>
#include <Functions/FunctionHelpers.h>
#include <DataTypes/DataTypeString.h>
#include <Columns/ColumnString.h>
#include <Interpreters/Context.h>
#include <Core/Field.h>
#include <Core/Settings.h>
namespace DB
{
namespace Setting
{
... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <config.h>
#if USE_FUZZING_MODE
#include <Columns/ColumnConst.h>
#include <Functions/IFunction.h>
#include <Functions/FunctionFactory.h>
#include <DataTypes/DataTypeString.h>
#include <Core/Field.h>
namespace DB
{
namespace
{
class FunctionGetFuzzerData final : public IFunction
{
inline... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>mpl(const ColumnsWithTypeAndName & arguments, const DataTypePtr & result_type, size_t input_rows_count) const override
{
const IColumn * arg_column = arguments[0].column.get();
const ColumnString * arg_string = checkAndGetColumnConstData<ColumnString>(arg_column);
if (!arg_str... | fim | ClickHouse/ClickHouse | cpp |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.