text stringlengths 14 100k | source stringclasses 1
value | repo stringclasses 810
values | language stringclasses 13
values |
|---|---|---|---|
#include "config.h"
#if USE_S2_GEOMETRY
#include <Columns/ColumnsNumber.h>
#include <Columns/ColumnTuple.h>
#include <DataTypes/DataTypesNumber.h>
#include <DataTypes/DataTypeTuple.h>
#include <Functions/FunctionFactory.h>
#include <Common/typeid_cast.h>
#include <base/range.h>
#include <Functions/s2_fwd.h>
class S... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>cell_id.h>
#include <s2/s2point.h>
#include <s2/s2latlng_rect.h>
#include <s2/s2cap.h>
#include <s2/s1angle.h>
#pragma clang diagnostic pop
<|fim_prefix|>#pragma once
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wambiguous-reversed-operator"
#include <s2/s2<|fim_middle|>latlng.h>
#in... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wold-style-cast"
#pragma clang diagnostic ignored "-Wshadow"
#pragma clang diagnostic ignored "-Wimplicit-float-conversion"
#include <Functions/stl.hpp>
#pragma clang diagnostic pop
#include <Columns/ColumnArray.h>
#include <Columns/ColumnC... | fim | ClickHouse/ClickHouse | cpp |
#include <Columns/ColumnArray.h>
#include <Columns/ColumnString.h>
#include <Columns/ColumnsNumber.h>
#include <DataTypes/DataTypeArray.h>
#include <DataTypes/DataTypesNumber.h>
#include <Functions/FunctionFactory.h>
#include <Functions/FunctionHelpers.h>
#include <Functions/IFunction.h>
#include <Common/NaNUtils.h>
#i... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>stride_out{sizeof(std::complex<double>)};
pocketfft::r2c(shape, stride_src, stride_out, axes, pocketfft::FORWARD, src.data(), out.data(), static_cast<double>(1));
size_t spec_len = (len - 1) / 2; //removing the nyquist element when len is even
double max_mag = 0;
size_t ... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>er is first started.
The UUID is persisted, i.e. the second, third, etc. server start return the same UUID.
)";
FunctionDocumentation::Syntax syntax_serverUUID = "serverUUID()";
FunctionDocumentation::Arguments arguments_serverUUID = {};
FunctionDocumentation::ReturnedValue returned_value_... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|> R"(
Calculates the sigmoid function: `1 / (1 + exp(-x))`. The sigmoid function maps any real number to the range (0, 1) and is commonly used in machine learning.
)";
FunctionDocumentation::Syntax syntax = "sigmoid(x)";
FunctionDocumentation::Arguments arguments = {
{"x", "The input va... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|> if (sign)
{
auto * is_negative = b.CreateICmpSLT(arg, zero);
auto * select_zero = b.CreateSelect(is_zero, res_zero, res_one);
return b.CreateSelect(is_negative, res_minus_one, select_zero);
}
else
return b... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <Functions/FunctionMathUnary.h>
#include <Functions/FunctionFactory.h>
namespace DB
{
namespace
{
struct SinName { static constexpr auto name = "sin"; };
using FunctionSin = FunctionMathUnary<UnaryFunctionVectorized<SinName, sin>>;
}
<|fim_suffix|>mples = {{.name = "simple", .query = "SELECT s... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>ction<FunctionSinh>(documentation);
}
}
<|fim_prefix|>#include <Functions/FunctionFactory.h>
#include <Functions/FunctionMathUnary.h>
namespace DB
{
namespace
{
struct SinhName
{
static constexpr auto name = "sinh";
};
using FunctionSinh = FunctionMathUnary<UnaryFunctionVectorize... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|> second */ static_cast<UInt64>(1000000));
sleepForMicroseconds(sleep_time);
elapsed += sleep_time;
if (query_status && !query_status->checkTimeLimit())
break;
}
ProfileEvents::increment(P... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>ithConstInfo & /*arguments*/) const override { return true; }
DataTypePtr getReturnTypeImpl(const ColumnsWithTypeAndName & arguments) const override
{
FunctionArgumentDescriptors args{
{"value", static_cast<FunctionArgumentDescriptor::TypeValidator>(&isDateTime64), nullptr, "D... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <Functions/FunctionFactory.h>
#include <Functions/extractTimeZoneFromFunctionArguments.h>
#include <Functions/IFunction.h>
#include <Functions/FunctionHelpers.h>
#include <DataTypes/DataTypeDateTime64.h>
#include <Columns/ColumnConst.h>
#include <Columns/ColumnsDateTime.h>
#include <Columns/Colum... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|> const char * const end = value + value_length;
char * const out_end = out + length;
while (cur < end && !isAlphaASCII(*cur))
++cur;
char prev_code = '0';
if (cur < end)
{
*out = toUpperIfAlphaASCII(*cur);
++out;
p... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <Columns/ColumnString.h>
#include <Columns/ColumnsNumber.h>
#include <DataTypes/DataTypesNumber.h>
#include <DataTypes/DataTypeString.h>
#include <Functions/FunctionFactory.h>
#include <Functions/FunctionHelpers.h>
#include <Functions/IFunction.h>
#include <cstring>
namespace DB
{
namespace Err... | fim | ClickHouse/ClickHouse | cpp |
#include <Functions/FunctionFactory.h>
#include <Functions/FunctionTokens.h>
#include <Functions/sparseGramsImpl.h>
namespace DB
{
/** Functions that finds all substrings win minimal length n
* such their border (n-1)-grams' hashes are more than hashes of every (n-1)-grams' in substring.
* As a hash function use ... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <Common/Exception.h>
#include <Columns/ColumnsNumber.h>
#include <DataTypes/DataTypesNumber.h>
#include <Functions/FunctionFactory.h>
#include <Functions/FunctionHelpers.h>
#include <Functions/FunctionTokens.h>
#include <Functions/sparseGramsImpl.h>
#include <base/types.h>
namespace DB
{
namesp... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>,
.symbols_between = length
});
convex_hull.pop_back();
}
if (!convex_hull.empty())
{
size_t possible_left_position = convex_hull.back().left_ngram_position;
size_t possible_left_symbol_index = convex_hull.back().symb... | fim | ClickHouse/ClickHouse | c |
#include <Columns/ColumnConst.h>
#include <Functions/FunctionHelpers.h>
#include <Functions/FunctionTokens.h>
#include <Functions/FunctionFactory.h>
#include <Common/StringUtils.h>
#include <Common/assert_cast.h>
namespace DB
{
namespace ErrorCodes
{
extern const int BAD_ARGUMENTS;
extern const int ILLEGAL_C... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>
token_end = pos;
splits++;
return true;
}
};
using FunctionSplitByNonAlpha = FunctionTokens<SplitByNonAlphaImpl>;
}
REGISTER_FUNCTION(SplitByNonAlpha)
{
FunctionDocumentation::Description description = R"(
Splits a string separated by whitespace and punctuation charact... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <Columns/ColumnConst.h>
#include <DataTypes/IDataType.h>
#include <Functions/FunctionFactory.h>
#include <Functions/FunctionHelpers.h>
#include <Functions/FunctionTokens.h>
#include <Functions/IFunctionAdaptors.h>
#include <Functions/Regexps.h>
#include <ranges>
namespace DB
{
namespace ErrorC... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>rator.", {"String"}},
{"s", "The string to split.", {"String"}},
{"max_substrings", "Optional. When `max_substrings > 0`, the returned substrings will be no more than `max_substrings`, otherwise the function will return as many substrings as possible. Default value: `0`.", {"Int64"}}
}... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <Functions/FunctionTokens.h>
#include <Functions/FunctionFactory.h>
#include <Common/StringUtils.h>
namespace DB
{
/** Functions that split strings into an array of strings or vice versa.
*
* splitByWhitespace(s[, max_substrings]) - split the string by whitespace characters
*/
name<... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include "config.h"
#if USE_SQIDS
#include <Columns/ColumnArray.h>
#include <Columns/ColumnString.h>
#include <Columns/ColumnsNumber.h>
#include <Common/typeid_cast.h>
#include <DataTypes/DataTypeArray.h>
#include <DataTypes/DataTy<|fim_suffix|>());
for (size_t i = 0; i < arguments.size(); ++i)... | fim | ClickHouse/ClickHouse | cpp |
#include <Functions/FunctionMathUnary.h>
#include <Functions/FunctionFactory.h>
namespace DB
{
namespace
{
struct SqrtName { static constexpr auto name = "sqrt"; };
using FunctionSqrt = FunctionMathUnary<UnaryFunctionVectorized<SqrtName, sqrt>>;
}
REGISTER_FUNCTION(Sqrt)
{
FunctionDocumentation::Description des... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>umentation::Category::String;
FunctionDocumentation documentation = {description, syntax, arguments, {}, returned_value, examples, introduced_in, category};
factory.registerFunction<FunctionStartsWithCaseInsensitive>(documentation);
}
}
<|fim_prefix|>#include <DataTypes/DataTypeString.h>
#includ... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|> {"prefix", "Case-insensitive prefix to check for.", {"String"}}
};
FunctionDocumentation::ReturnedValue returned_value = {"Returns `1` if `s` starts with case-insensitive `prefix`, otherwise `0`.", {"UInt8"}};
FunctionDocumentation::Examples examples = {
{
"Usage example",
... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>
MutableColumnPtr stemmed;
if (const auto * nullable_nested = checkAndGetColumn<ColumnNullable>(&array_data))
{
auto stemmed_inner = stemmer.stemColumn(
nullable_nested->getNestedColumn(), nested_rows, &nullable_nested->getNullMapData());
st... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|> m = 0;
for (size_t j = 1; j < newn; j++) {
// window down the array
v = v - x[m] + x[k];
ave[j] = v / flen;
k += 1;
m += 1;
}
}
}
inline void fts(const float* x, size_t n, size_t np, float* trend, float* work) {
ma(x, n,... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <Columns/ColumnString.h>
#include <<|fim_suffix|> return col_res;
}
};
}
<|fim_middle|>Columns/ColumnVector.h>
#include <DataTypes/DataTypesNumber.h>
#include <Functions/IFunction.h>
#include <Common/BitHelpers.h>
#include <cmath>
namespace DB
{
namespace ErrorCodes
{
... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Functions/FunctionFactory.h>
#include <Functions/stringBytes.h>
#include <cmath>
namespa<|fim_suffix|>rned_value = {"Returns Shannon's entropy of byte distribution in the string.", {"Float64"}};
FunctionDocumentation::Examples examples = {
{
"Usage example",
"SELECT str... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <Columns/ColumnConst.h>
#include <Columns/ColumnString.h>
#include <Columns/ColumnVector.h>
#include <DataTypes/DataTypeString.h>
#include <DataTypes/DataTypesNumber.h>
#include <Functions/FunctionFactory.h>
#include <Functions/stringBytes.h>
#include <Functions/IFunction.h>
#include <Common/BitH... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>= {
{
"Convert string to H3 index",
"SELECT stringToH3('89184926cc3ffff') AS index",
R"(
βββββββββββββββindexββ
β 617420388351344639 β
ββββββββββββββββββββββ
)"
}
};
FunctionDocumentation::IntroducedIn introduced_in = {20, 4};
Fun... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>reToProtobufSchema)
{
FunctionDocumentation::Description structureToProtobufSchema_description = R"(
Converts a ClickHouse table structure to Protobuf format schema.
This function takes a ClickHouse table structure definition and converts it into a Protocol Buffers (Protobuf)
schema definition in pro... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|> database β base β b β
ββββββββββββ΄βββββββββββββββββββββββββββ΄ββββββββββββββββββββββββββββββ
)"
}
};
FunctionDocumentation::IntroducedIn introduced_in = {1, 1};
FunctionDocumentation::Category category = FunctionDocumentation::Category:... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <Columns/ColumnConst.h>
#include <Columns/ColumnString.h>
#include <Core/ColumnsWithTypeAndName.h>
#include <DataTypes/DataTypeString.h>
#include <Functions/FunctionFactory.h>
#include <Functions/FunctionHelpers.h>
#include <Functions/IFunction.h>
#include <Functions/PositionImpl.h>
#include <Int... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>t_days_with_date,
subtractDays(date_time, 31) AS subtract_days_with_date_time,
subtractDays(date_time_string, 31) AS subtract_days_with_date_time_string
)",
R"(
ββsubtract_days_with_dateββ¬βsubtract_days_with_date_timeββ¬βsubtract_days_with_date_time_stringββ
β 2023-12-0... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>alternative INTERVAL syntax", R"(
SELECT dateSub('1998-06-16'::Date, INTERVAL 10 hour)
)",
R"(
ββminus(CAST('β―alHour(10))ββ
β 1998-06-15 14:00:00 β
ββββββββββββββββββββββββββββ
)"}
};
FunctionDocumentation::IntroducedIn introduced_in = {1, 1};
FunctionDocumentation... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>_time_string
)",
R"(
ββsubtract_microseconds_with_date_timeββ¬βsubtract_microseconds_with_date_time_stringββ
β 2023-12-31 23:59:59.000000 β 2023-12-31 23:59:59.000000 β
ββββββββββββββββββββββββββββββββββββββββ΄ββββββββββββββββββββββββββββββββββββββββββββββ
... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <Functions/FunctionFactory.h>
#include <Functions/FunctionDateOrDateTimeAddInterval.h>
namespace DB
{
using FunctionSubtractMilliseconds = FunctionDateOrDateTimeAddInterval<SubtractMillisecondsImpl>;
REGISTER_FUNCTION(SubtractMilliseconds)
{
FunctionDocumentation::Description description =... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>' AS date_time_string
SELECT
subtractMinutes(date, 30) AS subtract_minutes_with_date,
subtractMinutes(date_time, 30) AS subtract_minutes_with_date_time,
subtractMinutes(date_time_string, 30) AS subtract_minutes_with_date_time_string
)",
R"(
ββsubtract_minutes_with_dateββ¬βsubtra... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>tion::Category category = FunctionDocumentation::Category::DateAndTime;
FunctionDocumentation documentation = {description, syntax, arguments, {}, returned_value, examples, introduced_in, category};
factory.registerFunction<FunctionSubtractMonths>(documentation);
}
}
<|fim_prefix|>#include <Fu... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <Functions/FunctionFactory.h>
#include <Functions/FunctionDateOrDateTimeAddInterval.h>
namespace DB
{
using FunctionSubtractNanoseconds = FunctionDateOrDateTimeAddInterval<SubtractNanosecondsImpl>;
REGISTER_FUNCTION(SubtractNanoseconds)
{
FunctionDocumentation::Description description = R... | fim | ClickHouse/ClickHouse | cpp |
#include <Functions/IFunction.h>
#include <Functions/FunctionFactory.h>
#include <Functions/FunctionDateOrDateTimeAddInterval.h>
namespace DB
{
using FunctionSubtractQuarters = FunctionDateOrDateTimeAddInterval<SubtractQuartersImpl>;
REGISTER_FUNCTION(SubtractQuarters)
{
FunctionDocumentation::Description descr... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <Functions/IFunction.h>
#include <Functions/FunctionFactory.h>
#include <Functions/FunctionDateOrDateTimeAddInterval.h>
namespace DB
{
using FunctionSubtractSeconds = FunctionDateOrDateTimeAddInterval<SubtractSecondsImpl>;
REGISTER_FUNCTION(SubtractSeconds)
{
FunctionDocumentation::Descri... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <Functions/IFunction.h>
#include <Functions/FunctionFactory.h>
#include <Functions/FunctionDateOrDateTimeAddInterval.h>
namespace DB
{
using FunctionSubtractWeeks = FunctionDateOrDateTimeAddInterval<SubtractWeeksImpl>;
REGISTER_FUNCTION(SubtractWeeks)
{
FunctionDocumentation::Description ... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>rguments, {}, returned_value, examples, introduced_in, category};
factory.registerFunction<FunctionSubtractYears>(documentation);
}
}
<|fim_prefix|>#include <Functions/IFunction.h>
#include <Functions/FunctionFactory.h>
#include <Functions/FunctionDateOrDateTimeAddInterval.h>
namespace DB
{
usi... | fim | ClickHouse/ClickHouse | cpp |
#include <DataTypes/DataTypeString.h>
#include <Functions/FunctionFactory.h>
#include <Functions/FunctionHelpers.h>
#include <Functions/geometryConverters.h>
#include <Columns/ColumnString.h>
#include <string>
#include <memory>
namespace DB
{
namespace ErrorCodes
{
extern const int ILLEGAL_TYPE_OF_ARGUMENT;
... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include "config.h"
#if USE_NLP
#include <Columns/ColumnArray.h>
#include <Columns/ColumnString.h>
#include <Columns/ColumnVector.h>
#include <Core/Settings.h>
#include <DataTypes/DataTypeArray.h>
#include <DataTypes/DataTypeString.h>
#include <Functions/FunctionFactory.h>
#include <Functions/FunctionHe... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <Functions/FunctionMathUnary.h>
#include <Functions/FunctionFactory.h>
namespace DB
{
namespace
{
struct TanName { static constexpr auto name = "tan"; };
using <|fim_suffix|>
REGISTER_FUNCTION(Tan)
{
FunctionDocumentation::Description description = R"(
Returns the tangent of the argument.
)... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>e interval: -1 < tanh(x) < 1", {"Float*"}};
FunctionDocumentation::Examples examples = {{"Usage example", "SELECT tanh(0)", "0"}};
FunctionDocumentation::IntroducedIn introduced_in = {20, 1};
FunctionDocumentation::Category category = FunctionDocumentation::Category::Mathematical;
Function... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <gtest/gtest.h>
#include <Functions/FunctionsConversion.h>
#include <DataTypes/DataTypeFixedString.h>
#include <DataTypes/DataTypeLowCardinality.h>
#include <DataTypes/DataTypesNumber.h>
using namespace DB;
using namespace DB::detail;
TEST(ConversionMonotonic, toNumber)
{
/// From_type and... | fim | ClickHouse/ClickHouse | cpp |
#include <random>
#include <gtest/gtest.h>
#include <Functions/GatherUtils/Algorithms.h>
using namespace DB::GatherUtils;
static auto uni_int_dist(int min, int max)
{
std::random_device rd;
std::mt19937 mt(rd());
std::uniform_int_distribution<> dist(min, max);
return std::make_pair(dist, mt);
}
temp... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>esult = merge({{2, 5}, {2, 5}});
ASSERT_EQ(result.size(), 1);
EXPECT_EQ(result[0], (Interval{2, 5}));
}
TEST(HighlightMergeIntervals, MixedGroups)
{
auto result = merge({{0, 3}, {2, 6}, {10, 15}, {14, 20}});
ASSERT_EQ(result.size(), 2);
EXPECT_EQ(result[0], (Interval{0, 6}));
EXPE... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <gtest/gtest.h>
#include <Functions/hilbertDecode2DLUT.h>
#include <Functions/hilbertEncode2DLUT.h>
#include <base/types.h>
TEST(HilbertLookupTable, EncodeBit1And3Consistency)
{
const size_t bound = 1000;
for (size_t x = 0; x < bound<|fim_suffix|>WIthLookupTableImpl<3>::encode(x, y);
... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include "config.h"
#if USE_SSL
#include <gtest/gtest.h>
#include <cstring>
#include <iomanip>
#include <random>
#include <sstream>
#include <string>
#include <vector>
#include <openssl/evp.h>
#define MD5_GTEST_UNIT_TEST
#include "Functions/FunctionMD5.cpp" // NOLINT(bugprone-suspicious-include)
nam... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <gtest/gtest.h>
#include <Common/tests/gtest_global_context.h>
#include <Common/tests/gtest_global_register.h>
#include <Core/Field.h>
#include <DataTypes/DataTypeLowCardinality.h>
#include <DataTypes/DataTypeNullable.h>
#include <DataTypes/DataTypesNumber.h>
#include <Functions/FunctionFactory... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>at32"}, "Float32"},
{{"Float32", "Float64"}, "Float64"},
{{"Float64", "UInt8"}, "Float64"},
{{"Float64", "UInt16"}, "Float64"},
{{"Float64", "UInt32"}, "Float64"},
{{"Float64", "UInt64"}, "Error"},
{{"Float64", "UInt256"}, "Error"},
{{"Float64", "Int8"}, "Float64"},
{{"Floa... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <gtest/gtest.h>
#include <Common/VectorWithMemoryTracking.h>
#include <Common/tests/gtest_global_context.h>
#include <Common/tests/gtest_global_register.h>
#include <Functions/FunctionFactory.h>
#include <Interpreters/Context.h>
#include <DataTypes/DataTypeString.h>
#include <DataTypes/DataType... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <Common/TargetSpecific.h>
#if USE_MULTITARGET_CODE && (defined(__x86_64__) || defined(_M_X64))
# include "config.h"
# if USE_SSL
# include <gtest/gtest.h>
# include <cstring>
# include <iomanip>
# include <random>
# include <sstream>
# include <s... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|> > 128)
long_b[127] = 'd';
if (b_len > 129)
long_b[128] = 'e';
if (b_len > 256)
long_b[b_len / 2] = 'f';
if (b_len > 512)
long_b[(3 * b_len) / 4] = 'g';
runTest(long_a, long_b);
{
const std::string base = "AGTACGCATGCTAGTCGATCGATCGATCGATCGA... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <Functions/FunctionMathUnary.h>
#include <Functions/FunctionFactory.h>
namespace DB
{
namespace
{
struct TGammaName { static constexpr auto name = "tgamma"; };
using FunctionTGamma = FunctionMathUnary<UnaryFunctionVectorized<TGammaName, std::tgamma>>;
}
REGISTER_FUNCTION(TGamma)
{
Functio... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>Documentation::IntroducedIn introduced_in = {1, 1};
FunctionDocumentation::Category category = FunctionDocumentation::Category::Other;
FunctionDocumentation documentation = {description, syntax, arguments, {}, returned_value, examples, introduced_in, category};
factory.registerFunction<Functio... | fim | ClickHouse/ClickHouse | cpp |
#include <DataTypes/DataTypesNumber.h>
#include <Functions/FunctionFactory.h>
#include <Functions/FunctionHelpers.h>
#include <Functions/IFunction.h>
#include <base/getThreadId.h>
namespace DB
{
namespace
{
class FunctionTid final : public IFunction
{
public:
static constexpr auto name = "tid";
... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <Functions/IFunction.h>
#i<|fim_suffix|>ionDocumentation::Category::DateAndTime;
FunctionDocumentation documentation = {description, syntax, arguments, {}, returned_value, examples, introduced_in, category};
factory.registerFunction<FunctionTimeSlot>(documentation);
}
}
<|fim_middle|>... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <DataTypes/DataTypeArray.h>
#include <DataTypes/DataTypeDateTime.h>
#include <DataTypes/DataTypeDateTime64.h>
#include <DataTypes/DataTypesDecimal.h>
#include <DataTypes/IDataType.h>
#include <Columns/ColumnArray.h>
#include <Columns/ColumnsDateTime.h>
#include <Columns/ColumnsNumber.h>
#include... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <Functions/FunctionFactory.h>
#include <Functions/FunctionHelpers.h>
#include <DataTypes/DataTypeDateTime64.h>
#include <Columns/ColumnString.h>
#include <Columns/ColumnFixedString.h>
#include <Columns/ColumnsDateTime.h>
#include <IO/ReadBufferFromMemory.h>
#include <IO/ReadHelpers.h>
namespace ... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <Functions/IFunction.h>
#include <Functions/FunctionFactory.h>
#include <Functions/FunctionHelpers.h>
#include <DataTypes/DataTypeString.h>
#include <DataTypes/DataTypeNullable.h>
#include <DataTypes/DataTypeDateTime.h>
#include <Common/DateLUTImpl.h>
#include <Core/Field.h>
namespace DB
{
name... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <Functions/FunctionFactory.h>
#include <Functions/DateTimeTransforms.h>
#include <Functions/FunctionDateOrDateTimeToSomething.h>
#include <DataTypes/DataTypesNumber.h>
namespace DB
{
using FunctiontimezoneOffset = FunctionDateOrDateTimeToSomething<DataTypeInt32, TimezoneOffsetImpl>;
REGISTER_... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>uments) const override
{
return DataTypeFactory::instance().get(getReturnTypeName(arguments[0]));
}
ColumnPtr executeImpl(const ColumnsWithTypeAndName & arguments, const DataTypePtr & result_type, size_t) const override
{
ColumnPtr col = DataTypeSt... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>, const DataTypePtr &) const override
{
return DataTypeString().createColumnConst(1, arguments[0].type->createColumn()->getName());
}
};
}
REGISTER_FUNCTION(ToColumnTypeName)
{
FunctionDocumentation::Description description = R"(
Returns the internal name of the data type of the give... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <DataTypes/DataTypesNumber.h>
#include <Functions/CustomWeekTransforms.h>
#include <Functions/FunctionCustomWeekToSomething.h>
#include <Functions/FunctionCustomWeekToDateOrDate32.h>
#include <Functions/FunctionFactory.h>
#include <Functions/IFunction.h>
namespace DB
{
using FunctionToWeek = Fu... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <Functions/FunctionFactory.h>
#include <Functions/DateTimeTransforms.h>
#include <Functions/FunctionDateOrDateTimeToSomething.h>
#include <DataTypes/DataTypesNumber.h>
namespace DB
{
using FunctionToDayOfMonth = FunctionDateOrDateTimeToSomething<DataTypeUInt8, ToDayOfMonthImpl>;
REGISTER_FUNC... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|> 4 β
βββββββββββββββββββββββββββββββββββββββββ΄βββββββββββββββββββββββββββββββββββββββββββ
)"}
};
FunctionDocumentation::IntroducedIn introduced_in = {1, 1};
FunctionDocumentation::Category category = FunctionDocumentation::Category::DateAndTime;
Function... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <Functions/FunctionFactory.h>
#include <Functions/DateTimeTransforms.h>
#include <Functions/FunctionDateOrDateTimeToSomething.h>
#include <DataTypes/DataTypesNumber.h>
namespace DB
{
using FunctionToDayOfYear = FunctionDateOrDateTimeToSomething<DataTypeUInt16, ToDayOfYearImpl>;
REGISTER_FUNCT... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|> 31 β
βββββββββββββββββββββββββββββββββββββββ΄ββββββββββββββββββββββββββββββββββββββ΄ββββββββββββββββββββββββββββββββββββββ
)"}
};
FunctionDocumentation::IntroducedIn introduced_in = {26, 3};
FunctionDocumentation::Category category = FunctionDocumentation::Category... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>ctionDocumentation::Examples examples = {
{"Calculate days since year zero", R"(
SELECT toDaysSinceYearZero(toDate('2023-09-08'))
)",
R"(
ββtoDaysSinceYearZero(toDate('2023-09-08')))ββ
β 713569 β
ββββββββββββββββββββββββββββββββββββββββββββββ
... | fim | ClickHouse/ClickHouse | cpp |
#include <Functions/FunctionFactory.h>
#include <Functions/IFunction.h>
#include <Core/Types.h>
#include <Functions/FunctionHelpers.h>
#include <Columns/ColumnString.h>
#include <Columns/ColumnVector.h>
#include <Columns/ColumnDecimal.h>
#include <DataTypes/DataTypeString.h>
#include <DataTypes/DataTypesNumber.h>
#incl... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>e returned_value = {"Returns a FixedString of length N.", {"FixedString(N)"}};
FunctionDocumentation::Examples examples = {
{
"Usage example",
R"(
SELECT toFixedString('foo', 8) AS s;
)",
R"(
ββsββββββββββββββ
β foo\0\0\0\0\0 β
βββββββββββββββββ
)"
}
... | fim | ClickHouse/ClickHouse | cpp |
#pragma once
#include <Functions/IFunction.h>
#include <DataTypes/DataTypeFixedString.h>
#include <Columns/ColumnString.h>
#include <Columns/ColumnFixedString.h>
#include <Columns/ColumnsNumber.h>
#include <Columns/ColumnNullable.h>
#include <Interpreters/Context_fwd.h>
namespace DB
{
namespace ErrorCodes
{
exte... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Functions/FunctionFactory.h>
#include <Functions/DateTimeTr<|fim_suffix|>guments, {}, returned_value, examples, introduced_in, category};
factory.registerFunction<FunctionToHour>(documentation);
/// MySQL compatibility alias.
factory.registerAlias("HOUR", "toHour", FunctionFactory:... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|> 2025-12-29 β 1 β 2025 β
ββββββββββββββ΄ββββββββββ΄βββββββ
)"}
};
FunctionDocumentation::IntroducedIn introduced_in = {20, 1};
FunctionDocumentation::Category category = FunctionDocumentation::Category::DateAndTime;
FunctionDocumentation documentation = {description, syntax, ar... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>ned_value, examples, introduced_in, category};
factory.registerFunction<FunctionToISOYear>(documentation);
}
}
<|fim_prefix|>#include <Functions/FunctionFactory.h>
#include <Functions/DateTimeTransforms.h>
#include <Functions/FunctionDateOrDate<|fim_middle|>TimeToSomething.h>
#include <DataTypes/D... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <Functions/IFunction.h>
#include <Functions/IFunctionAdaptors.h>
#include <array>
#include <Columns/ColumnConst.h>
#include <Columns/ColumnString.h>
#include <Columns/ColumnsNumber.h>
#include <DataTypes/DataTypeInterval.h>
#include <DataTypes/DataTypeLowCardinality.h>
#include <Functions/DateTim... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>::JSON;
FunctionDocumentation documentation = {description, syntax, arguments, {}, returned_value, examples, introduced_in, category};
factory.registerFunction<FunctionToJSONString>(documentation);
}
}
<|fim_prefix|>#include <Columns/ColumnString.h>
#include <DataTypes/DataTypeString.h>
#include... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|> = {1, 1};
FunctionDocumentation::Category category = FunctionDocumentation::Category::DateAndTime;
FunctionDocumentation documentation = {description, syntax, arguments, {}, returned_value, examples, introduced_in, category};
factory.registerFunction<FunctionToLastDayOfMonth>(documentation);... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|> return std::make_shared<DataTypeLowCardinality>(arguments[0]);
}
ColumnPtr executeImpl(const ColumnsWithTypeAndName & arguments, const DataTypePtr & res_type, size_t /*input_rows_count*/) const override
{
const auto & arg = arguments[0];
if (arg.type->lowCardinality())
... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <Common/FunctionDocumentation.h>
#include <Functions/DateTimeTransforms.h>
#include <Functions/FunctionDateOrDateTimeToSomething.h>
#include <Functions/FunctionFactory.h>
namespace DB
{
using FunctionToMicrosecond = FunctionDateOrDateTimeToSomething<DataTypeUInt32, ToMicrosecondImpl>;
REGISTER... | fim | ClickHouse/ClickHouse | cpp |
#include <Common/FunctionDocumentation.h>
#include <Functions/DateTimeTransforms.h>
#include <Functions/FunctionDateOrDateTimeToSomething.h>
#include <Functions/FunctionFactory.h>
namespace DB
{
using FunctionToMillisecond = FunctionDateOrDateTimeToSomething<DataTypeUInt16, ToMillisecondImpl>;
REGISTER_FUNCTION(ToMi... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <Functions/FunctionFactory.h>
#include <Functions/DateTimeTransforms.h>
#include <Functions/FunctionDateOrDateTimeToSomething.h>
#include <DataTypes/DataTypesNumber.h>
namespace DB
{
using FunctionToMinute = FunctionDateOrDateTimeToSomething<DataTypeUInt8, ToMinuteImpl>;
REGISTER_FUNCTION(ToM... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <Columns/ColumnNullable.h>
#include <Columns/ColumnString.h>
#include <Columns/ColumnFixedString.h>
#include <Columns/ColumnVector.h>
#include <Columns/ColumnsNumber.h>
#include <DataTypes/IDataType.h>
#include <DataTypes/DataTypesNumber.h>
#include <DataTypes/DataTypeNullable.h>
#include <Functi... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <Functions/FunctionFactory.h>
#include <Functions/DateTimeTransforms.h>
#include <Functions/FunctionDateOrDateTimeToDateOrDate32.h>
namespace DB
{
using FunctionToMonday = FunctionDateOrDateTimeToDateOrDate32<ToMondayImpl>;
REGISTER_FUNCTION(ToMonday)
{
FunctionDocumentation::Description ... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <Functions/FunctionFactory.h><|fim_suffix|>pace DB
{
using FunctionToMonth = FunctionDateOrDateTimeToSomething<DataTypeUInt8, ToMonthImpl>;
REGISTER_FUNCTION(ToMonth)
{
FunctionDocumentation::Description description = R"(
Returns the month component (1-12) of a `Date` or `DateTime` value.
... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <Functions/FunctionFactory.h>
#include <Functions/DateTimeTransforms.h>
#include <Functions/FunctionDateOrDateTimeToSomething.h>
#include <DataTypes/DataTypesNumber.h>
namespace DB
{
using FunctionToMonthNumSinceEpoch = FunctionDateOrDateTimeToSomething<DataTypeUInt32, ToMonthNumSinceEpochImpl... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <Common/FunctionDocumentation.h>
#include <Functions/DateTimeTransforms.h>
#include <Functions/FunctionDateOrDateTimeToSomething.h>
#include <Functions/FunctionFactory.h>
namespace DB
{
using FunctionToNanosecond = FunctionDateOrDateTimeToSomething<DataTypeUInt32, ToNanosecondImpl>;
REGISTER_F... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>cription = R"(
Converts the provided argument type to `Nullable`.
)";
FunctionDocumentation::Syntax syntax = "toNullable(x)";
FunctionDocumentation::Arguments arguments = {
{"x", "A value of any non-compound type.", {"Any"}}
};
FunctionDocumentation::ReturnedValue returned_valu... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>e quarter of the year for the given date/time", {"UInt8"}};
FunctionDocumentation::Examples examples = {
{"Usage example", R"(
SELECT toQuarter(toDateTime('2023-04-21 10:20:30'))
)",
R"(
ββtoQuarter(toDateTime('2023-04-21 10:20:30'))ββ
β ... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <Functions/FunctionFactory.h>
#include <Functions/DateTimeTransforms.h>
#include <Functions/FunctionDateOrDateTimeToSomething.h>
#include <DataTypes/DataTypesNumber.h>
namespace DB
{
using FunctionToRelativeDayNum = FunctionDateOrDateTimeToSomething<DataTypeUInt32, ToRelativeDayNumImpl<ResultP... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <Functions/FunctionFactory.h>
#include <Functions/DateTimeTransforms.h>
#include <Functions/FunctionDateOrDateTimeToSomething.h>
#include <DataTypes/DataTypesNumber.h>
namespace DB
{
using FunctionToRelativeHourNum = FunctionDateOrDateTimeToSomething<DataTypeUInt32, ToRelativeHourNumImpl<Resul... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>RelativeMinuteNum(dt1) - toRelativeMinuteNum(dt2)`.
)";
FunctionDocumentation::Syntax syntax = R"(
toRelativeMinuteNum(date)
)";
FunctionDocumentation::Arguments arguments =
{
{"date", "Date or date with time.", {"Date", "DateTime", "DateTime64"}}
};
FunctionDocumentati... | fim | ClickHouse/ClickHouse | cpp |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.