text stringlengths 14 100k | source stringclasses 1
value | repo stringclasses 810
values | language stringclasses 13
values |
|---|---|---|---|
<|fim_suffix|>t in a `haystack` string which matches any of multiple `needle` strings. Returns `0`, if there was no match.", {"UInt64"}};
FunctionDocumentation::Examples examples = {
{
"Find the leftmost offset in UTF-8 string 'ΠΠ΄ΡΠ°Π²ΡΡΠ²ΡΠΉ, ΠΌΠΈΡ' ('Hello, world') which matches any of the given needles",
... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>gory};
factory.registerFunction<FunctionMultiply>(documentation);
}
}
<|fim_prefix|>#include <type_traits>
#include <Functions/FunctionFactory.h>
#include <Functions/FunctionBinaryArithmetic.h>
#include <base/arithmeticOverflow.h>
namespace DB
{
template <typename A, typename B>
struct MultiplyImp... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <Functions/FunctionsDecimalArithmetics.h>
#include <Functions/FunctionFactory.h>
namespace DB
{
namespace ErrorCodes
{
extern const int DECIMAL_OVERFLOW;
}
namespace
{
struct MultiplyDecimalsImpl
{
static constexpr auto name = "multiplyDecimal";
static constexpr auto suitable_for_... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>model_path, model_name);
}
DB::ReadBufferFromFile in(model_path);
String ngram; /// Avoid reallocation
while (!in.eof())
{
UInt32 class_id = 0;
UInt32 ngram_length = 0;
UInt32 count = 0;
DB::readBinary(class_id, in)... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Columns/ColumnString.h>
#include <DataTypes/DataTypeString.h>
#include <Functions/FunctionFactory.h>
namespace DB
{
namespace ErrorCodes
{
extern const int ILLEGAL_COLUMN;
extern const int ILLEGAL_TYPE_OF_ARGUMENT;
extern const int TOO_LARGE_STRING_SIZE;
}
class FunctionNaturalSortKey final :... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>}, returned_value, examples, introduced_in, category};
factory.registerFunction<FunctionNegate>(documentation);
}
}
<|fim_prefix|>#include <Functions/FunctionFactory.h>
#include <Functions/FunctionUnaryArithmetic.h>
#include <Common/FieldVisitorConvertToNumber.h>
#include <DataTypes/NumberTraits.h>
... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <Core/Settings.h>
#include <Columns/ColumnConst.h>
#include <DataTypes/DataTypesNumber.h>
#include <DataTypes/getLeastSupertype.h>
#include <Functions/FunctionFactory.h>
#include <Functions/IFunction.h>
#include <IO/WriteHelpers.h>
#include <Interpreters/Context.h>
#include <Interpreters/castColu... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>umnArray & other_array = assert_cast<const ColumnArray &>(*other_array_materialized);
if (!first_array.hasEqualOffsets(other_array))
throw Exception(ErrorCodes::SIZES_OF_ARRAYS_DONT_MATCH,
"The argument 2 and argument {} of function {} have different array ... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|> & tokenizer,
StringColumnType & input_data_column,
ResultStringColumnType & result_data_column,
ColumnArray::ColumnOffsets & offsets_column,
size_t input_rows_count) const
{
size_t current_tokens_size = 0;
auto & offsets_data = offsets_column.getData();... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <DataTypes/DataTypeString.h>
#include <Columns/ColumnString.h>
#include <Functions/FunctionFactory.h>
#include <Functions/FunctionStringToString.h>
#include <Parsers/queryNormalization.h>
namespace DB
{
namespace ErrorCodes
{
extern const int ILLEGAL_COLUMN;
}
namespace
{
template <bool k... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>nfc, examples_nfc, introduced_in, category};
FunctionDocumentation::Description description_nfd = R"(
Normalizes a UTF-8 string according to the [NFD normalization form](https://en.wikipedia.org/wiki/Unicode_equivalence#Normal_forms).
)";
FunctionDocumentation::Syntax syntax_nfd = "normalizeUTF8N... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>
REGISTER_FUNCTION(NormalizedQueryHash)
{
FunctionDocumentation::Description normalizedQueryHash_description = R"(
Returns identical 64 bit hash values without the values of literals for similar queries.
Can be helpful in analyzing query logs.
)";
FunctionDocumentation::Syntax normalizedQuery... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <Functions/FunctionFactory.h>
#include <Functions/FunctionsComparison.h>
#include <Functions/FunctionsLogical.h>
namespace DB
{
using FunctionNotEquals = FunctionComparison<NotEqualsOp, NameNotEquals>;
REGISTER_FUNCTION(NotEquals)
{
// Documentation for notEquals
FunctionDocumentation:... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>ch the pattern (case-insensitive), otherwise `0`.", {"UInt8"}};
FunctionDocumentation::Examples examples =
{
{
"Usage example",
"SELECT notILike('ClickHouse', '%house%');",
R"(
ββnotILike('Clβ― '%house%')ββ
β 0 β
ββββββββββββββββββββββββββββ
... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|> 1 β
ββββββββββββββββββββββββββββ
)"
}
};
FunctionDocumentation::IntroducedIn introduced_in = {1, 1};
FunctionDocumentation::Category category = FunctionDocumentation::Category::StringSearch;
FunctionDocumentation documentation = {description, syntax, arguments, ... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <ctime>
#include <Core/Field.h>
#include <Core/Settings.h>
#include <DataTypes/DataTypeDateTime.h>
#include <Functions/FunctionFactory.h>
#include <Functions/FunctionHelpers.h>
#include <Functions/IFunction.h>
#include <Functions/extractTimeZoneFromFunctionArguments.h>
#include <Interpreters/Cont... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <Common/assert_cast.h>
#include <Columns/ColumnConst.h>
#include <Core/Settings.h>
#include <DataTypes/DataTypeDateTime64.h>
#include <DataTypes/DataTypeNullable.h>
#include <Functions/FunctionFactory.h>
#include <Functions/IFunction.h>
#include <Functions/extractTimeZoneFromFunctionArguments.h>
... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>erent in different blocks for long-running queries.
It makes sense to use this function to generate the current time in long-running `INSERT SELECT` queries.
)";
FunctionDocumentation::Syntax syntax = R"(
nowInBlock([timezone])
)";
FunctionDocumentation::Arguments arguments = {
{"... | fim | ClickHouse/ClickHouse | cpp |
#include <Columns/ColumnVector.h>
#include <Columns/ColumnsDateTime.h>
#include <Functions/FunctionFactory.h>
#include <Functions/FunctionHelpers.h>
#include <Functions/IFunction.h>
#include <Functions/extractTimeZoneFromFunctionArguments.h>
#include <Functions/nowSubsecond.h>
#include <Interpreters/Context.h>
namespa... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <Common/intExp10.h>
#include <Common/ErrnoException.h>
#include <Core/DecimalFunctions.h>
#include <Functions/nowSubsecond.h>
namespace DB
{
namespace ErrorCodes
{
extern const int CANNOT_CLOCK_GETTIME;
}
Field nowSubsecond(UInt32 scale)
{
static constexpr Int32 fractional_scale = 9;
... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
<|fim_suffix|>ld.h>
namespace DB
{
Field nowSubsecond(UInt32 scale);
}
<|fim_middle|>
#include <Core/Fie<|endoftext|> | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>tory.registerFunction<FunctionNullIf>(documentation, FunctionFactory::Case::Insensitive);
}
}
<|fim_prefix|>#include <Functions/IFunction.h>
#include <Functions/FunctionHelpers.h>
#include <Functions/FunctionFactory.h>
#include <DataTypes/DataTypesNumber.h>
#include <DataTypes/DataTypeNullable.h>
#includ... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#i<|fim_suffix|>quote.
inline Int64 numLiteralChars(const char * cur, const char * end)
{
bool found = false;
Int64 count = 0;
while (cur < end)
{
if (*cur == '\'')
{
if (cur + 1 < end && *(cur + 1) == '\'')
{
count += 2... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>must be String", getName());
// For both `obfuscateQuery` and `obfuscateQueryWithSeed`, second argument must be integer or String.
if (arguments.size() == 2)
{
if (!isInteger(arguments[1].type) && !isString(arguments[1].type))
throw Exception(ErrorCodes... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <Columns/ColumnConst.h>
#include <Columns/ColumnString.h>
#include <Common/UTF8Helpers.h>
#include <DataTypes/DataTypeString.h>
#include <Functions/FunctionFactory.h>
#include <Functions/FunctionHelpers.h>
#include <Functions/GatherUtils/Sources.h>
#include <Functions/IFunction.h>
namespace DB
{... | fim | ClickHouse/ClickHouse | cpp |
#include <memory>
#include <Columns/ColumnFixedString.h>
#include <Common/StringUtils.h>
#include <Common/VectorWithMemoryTracking.h>
#include <Columns/ColumnString.h>
#include <DataTypes/DataTypeString.h>
#include <DataTypes/IDataType.h>
#include <Functions/FunctionFactory.h>
#include <Functions/FunctionHelpers.h>
#in... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <base/types.h>
#include <boost/algorithm/string/case_conv.hpp>
#include <Columns/ColumnNullable.h>
#include <Columns/ColumnsNumber.h>
#include <Columns/ColumnString.h>
#include <Common/Exception.h>
#include <Common/FunctionDocumentation.h>
#include <Common/UnorderedMapWithMemoryTracking.h>
#incl... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>th separators (space, `;`, `-`, `+`, `,`, `:`).
The length of years and months are approximations: year is 365 days, month is 30.5 days.
)";
FunctionDocumentation::Syntax syntax = "parseTimeDelta(timestr)";
FunctionDocumentation::Arguments arguments = {
{"timestr", "A sequence of numb... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>on ID](../../engines/table-engines/mergetree-family/custom-partitioning-key.md).
:::note
This function is slow and should not be called for large numbers of rows.
:::
)";
FunctionDocumentation::Syntax syntax = "partitionId(column1[, column2, ...])";
FunctionDocumentation::Arguments arguments = {
... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>}
String getName() const override { return name; }
size_t getNumberOfArguments() const override { return 2; }
ColumnNumbers getArgumentsThatAreAlwaysConstant() const override { return {1}; }
bool isSuitableForShortCircuitArgumentsExecution(const DataTypesWithConstInfo &) const override { ... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>es, introduced_in, category};
factory.registerFunction<FunctionPerimeter<CartesianPoint>>(documentation);
}
{
FunctionDocumentation::Description description = R"(
Returns the perimeter of the object.
)";
FunctionDocumentation::Syntax syntax = "perimeterSphe... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>ry = FunctionDocumentation::Category::Arithmetic;
FunctionDocumentation::IntroducedIn introduced_in = {1, 1};
FunctionDocumentation documentation = {description, syntax, arguments, {}, returned_value, examples, introduced_in, category};
factory.registerFunction<FunctionPlus>(documentation);
}... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>x - el.x) / el.a);
double p2 = ((y - el.y) / el.b);
if (x <= el.x + el.a && x >= el.x - el.a && y <= el.y + el.b && y >= el.y - el.b /// Bounding box check
&& p1 * p1 + p2 * p2 <= 1.0) /// Precise check
{
start_index = index;
... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|> 0, out_polygon);
}
}
void NO_SANITIZE_UNDEFINED parseConstPolygon(const ColumnsWithTypeAndName & arguments, Polygon & out_polygon) const
{
if (arguments.size() == 2)
parseConstPolygonFromSingleColumn(arguments[1], out_polygon);
else
parseConstP... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>erical = R"(
Calculates the surface area of a polygon.
)";
FunctionDocumentation::Syntax syntax_spherical = "polygonAreaSpherical(polygon)";
FunctionDocumentation::Arguments arguments_spherical = {{"polygon", "A polygon value.", {"Polygon"}}};
FunctionDocumentation::ReturnedValue returned_... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <Functions/FunctionFactory.h>
#include <Functions/geometryConverters.h>
#include <memory>
namespace DB
{
namespace ErrorCodes
{
extern const int BAD_ARGUMENTS;
}
namespace
{
template <typename Point>
class FunctionPolygonConvexHull final : public IFunction
{
public:
static const cha... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>gon;
FunctionDocumentation function_documentation_cartesian = {description_cartesian, syntax_cartesian, arguments_cartesian, {}, returned_value_cartesian, examples_cartesian, introduced_in_cartesian, category_cartesian};
factory.registerFunction<FunctionPolygonPerimeter<CartesianPoint>>(function_... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <Functions/FunctionFactory.h>
#include <Functions/geometryConverters.h>
#include <boost/geometry.hpp>
#include <boost/geometry/geometries/point_xy.hpp>
#include <Common/logger_useful.h>
#include <Columns/ColumnTuple.h>
#include <Columns/ColumnConst.h>
#include <Columns/ColumnsNumber.h>
#includ... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <Functions/FunctionFactory.h>
#include <Functions/geometryConverters.h>
#include <boost/geometry.hpp>
#include <boost/geometry/geometries/point_xy.hpp>
#include <boost/geometry/geometries/polygon.hpp>
#include <Common/logger_useful.h>
#include <Columns/ColumnArray.h>
#include <Columns/ColumnTu... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <Functions/FunctionFactory.h>
#include <Functions/geometryConverters.h>
#include <boost/geometry.hpp>
#include <boost/geometry/geometries/point_xy.hpp>
#include <Columns/ColumnConst.h>
#include <Columns/ColumnTuple.h>
#include <Columns/ColumnsNumber.h>
#include <DataTypes/DataTypesNumber.h>
#... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <Functions/FunctionFactory.h>
#include <Functions/geometryConverters.h>
#include <boost/geometry.hpp>
#include <boost/geometry/geometries/point_xy.hpp>
#include <Common/logger_useful.h>
#include <Columns/ColumnTuple.h>
#include <Columns/ColumnConst.h>
#include <memory>
namespace DB
{
names... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <Functions/FunctionFactory.h>
#include <Functions/geometryConverters.h>
#include <boost/geometry.hpp>
#include <boost/geometry/geometries/point_xy.hpp>
#include <Common/logger_useful.h>
#include <Columns/ColumnTuple.h>
#include <Columns/ColumnConst.h>
#include <memory>
namespace DB
{
namesp... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <Functions/FunctionFactory.h>
#include <Functions/geometryConverters.h>
#include <boost/geometry.hpp>
#include <boost/geometry/geometries/point_xy.hpp>
#include <Common/logger_useful.h>
#include <Columns/ColumnTuple.h>
#include <memory>
namespace DB
{
namespace ErrorCodes
{
extern cons... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|> {"polygon2", "The second Polygon.", {"Polygon"}}
};
FunctionDocumentation::ReturnedValue returned_value_spherical = {"Returns `1` if `polygon1` lies completely within `polygon2`, otherwise `0`.", {"UInt8"}};
FunctionDocumentation::Examples examples_spherical =
{
{
"Usage examp... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|> 4 β 0 β
βββββββββββββββββββββββ΄βββββββββββββββββββββββββ΄βββββββββββββββββββββββββ΄βββββββββββββββββββββββββ΄βββββββββββββββββββββββββ΄βββββββββββββββββββββββββ΄βββββββββββββββββββββββββ
)"
}
};
FunctionDocumentation::IntroducedIn introduced_in = {1, 1};
... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <Functions/FunctionsStringSearch.h>
#include <Functions/FunctionFactory.h>
#include <Functions/PositionImpl.h>
namespace DB
{
namespace
{
struct NamePositionCaseInsensitive
{
static constexpr auto name = "positionCaseI<|fim_suffix|>'Hello, world!', 'hello')ββ
β ... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <Functions/FunctionsStringSearch.h>
#include <Functions/FunctionFactory.h>
#include <Functions/PositionImpl.h>
namespace DB
{
namespace
{
struct NamePositionCaseInsensitiveUTF8
{
static constexpr auto name = "positionCaseInsensitiveUTF8";
};
using FunctionPositionCaseInsensitiveUTF8
=... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <Functions/FunctionsStringSearch.h>
#include <Functions/FunctionFactory.h>
#include <Functions/PositionImpl.h>
namespace DB
{
namespace
{
struct NamePositionUTF8
{
static constexpr auto name = "positionUTF8";
};
using FunctionPositionUTF8 = FunctionsStringSearch<PositionImpl<NamePositionU... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>n = {description, syntax, arguments, {}, returned_value, examples, introduced_in, category};
factory.registerFunction<FunctionPow>(documentation, FunctionFactory::Case::Insensitive);
factory.registerAlias("power", "pow", FunctionFactory::Case::Insensitive);
}
}
<|fim_prefix|>#include <Functions/... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>r executeImpl(const ColumnsWithTypeAndName & arguments, const DataTypePtr &, size_t input_rows_count) const override
{
const auto * col = checkAndGetColumn<ColumnString>(arguments[0].column.get());
if (!col)
throw Exception(ErrorCodes::ILLEGAL_COLUMN, "First argument of fun... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>ror & e)
{
throw Exception(
ErrorCodes::BAD_ARGUMENTS,
"Bad format '{}' in function {} at row {}, reason: {}",
format, getName(), row, e.what());
}
result_chars.resize(curr_offset + row_result.... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include "config.h"
#if USE_IDNA
#include <Columns/ColumnString.h>
#include <Functions/FunctionFactory.h>
#include <Functions/FunctionStringToString.h>
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wnewline-eof"
#include <ada/idna/punycode.h>
#include <ada/idna/unicode_transcoding.h>... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <Columns/ColumnConst.h>
#include <Columns/IColumn.h>
#include <Functions/IFunction.h>
#include <Functions/FunctionFactory.h>
#include <Interpreters/Context.h>
#include <DataTypes/DataTypeString.h>
#include <Core/Field.h>
namespace DB
{
class FunctionQueryID final : public IFunction
{
const S... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>ion::Arguments arguments = {
{"x", "Input in degrees.", {"(U)Int*", "Float*", "Decimal*"}}
};
FunctionDocumentation::ReturnedValue returned_value = {"Returns value in radians", {"Float64"}};
FunctionDocumentation::Examples examples = {
{"Usage example", "SELECT radians(180)", "... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <Functions/FunctionFactory.h>
#include <Functions/FunctionsRandom.h>
namespace DB
{
namespace
{
struct NameRand { static constexpr auto name = "rand"; };
using FunctionRand = FunctionRandom<UInt32, NameRand>;
}
REGISTER_FUNCTION(Rand)
{
FunctionDocumentation::Description description = R"(... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>nal libraries.
)";
FunctionDocumentation::Syntax syntax = "rand64([x])";
FunctionDocumentation::Arguments arguments = {
{"x", "Optional and ignored. The only purpose of the argument is to prevent [common subexpression elimination](/sql-reference/functions/overview#common-subexpression-... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|> FunctionDocumentation::Arguments arguments = {
{"x", "Optional and ignored. The only purpose of the argument is to prevent [common subexpression elimination](/sql-reference/functions/overview#common-subexpression-elimination) when the same function call is used multiple times in a query.", {"Any"... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>rride { return name; }
bool isDeterministic() const override { return false; }
bool useDefaultImplementationForNulls() const override { return false; }
bool isVariadic() const override { return true; }
size_t getNumberOfArguments() const override { return 0; }
static FunctionOverloa... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <Functions/IFunction.h>
#include <Functions/FunctionHelpers.h>
#include <Functions/FunctionFactory.h>
#include <Common/Exception.h>
#include <Common/thread_local_rng.h>
#include <Common/NaNUtils.h>
#include <Columns/ColumnConst.h>
#include <Columns/ColumnsNumber.h>
#include <DataTypes/DataTypesNu... | fim | ClickHouse/ClickHouse | cpp |
#include <Columns/ColumnFixedString.h>
#include <DataTypes/DataTypeFixedString.h>
#include <Functions/FunctionFactory.h>
#include <Functions/FunctionHelpers.h>
#include <Functions/IFunction.h>
#include <Functions/PerformanceAdaptors.h>
#include <Functions/FunctionsRandom.h>
#include <pcg_random.hpp>
#include <Common/ra... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <Functions/IFunction.h>
#include <Functions/FunctionFactory.h>
#include <Functions/FunctionHelpers.h>
#include <Columns/ColumnString.h>
#include <DataTypes/DataTypeString.h>
#include <pcg_random.hpp>
#include <Common/randomSeed.h>
namespace DB
{
namespace ErrorCodes
{
extern const int TOO_... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>g"}};
FunctionDocumentation::Examples examples = {
{"Usage example", "SELECT randomString(5) AS str FROM numbers(2)", R"(
οΏ½οΏ½οΏ½
οΏ½v6BοΏ½
)"}
};
FunctionDocumentation::IntroducedIn introduced_in = {20, 5};
FunctionDocumentation::Category category = FunctionDocumentation::Category... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>s a random [UTF-8](https://en.wikipedia.org/wiki/UTF-8) string with the specified number of codepoints.
No codepoints from unassigned [planes](https://en.wikipedia.org/wiki/Plane_(Unicode)) (planes 4 to 13) are returned.
It is still possible that the client interacting with ClickHouse server is not able t... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <Columns/ColumnString.h>
#include <DataTypes/DataTypeCustomGeo.h>
#include <DataTypes/DataTypeString.h>
#include <Functions/FunctionFactory.h>
#include <Functions/FunctionHelpers.h>
#include <IO/ReadBufferFromString.h>
#include <Columns/ColumnFixedString.h>
#include <Columns/IColumn.h>
#include ... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <Columns/ColumnString.h>
#include <Columns/ColumnVariant.h>
#include <DataTypes/DataTypeCustomGeo.h>
#include <DataTypes/DataTypeString.h>
#include <Functions/FunctionFactory.h>
#include <Functions/FunctionHelpers.h>
#include <Functions/geometryConverters.h>
#include <boost/algorithm/string/case_... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <optional>
#include <Columns/ColumnConst.h>
#include <Columns/ColumnString.h>
#include <DataTypes/DataTypeString.h>
#include <DataTypes/DataTypesNumber.h>
#include <Functions/FunctionFactory.h>
#include <Functions/FunctionHelpers.h>
#include <Functions/IFunction.h>
#include <Functions/Regexps.h>... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <Columns/ColumnConst.h>
#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/IFunction.h>
#include <Interp... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>::Category::StringReplacement;
FunctionDocumentation documentation = {description, syntax, arguments, {}, returned_value, examples, introduced_in, category};
factory.registerFunction<FunctionRegexpQuoteMeta>(documentation);
}
}
<|fim_prefix|>#include <Columns/ColumnString.h>
#include <DataTypes/... | fim | ClickHouse/ClickHouse | cpp |
#include "config.h"
#include <Functions/FunctionFactory.h>
#include <Common/MemoryTrackerBlockerInThread.h>
namespace DB
{
void registerFunctions();
void registerFunctions()
{
/// Registration runs once and allocates while building static function metadata (for example
/// HMAC enumerates the OpenSSL digest... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
namespace DB
{
void registerFunc<|fim_suffix|>ns();
}
<|fim_middle|>tio<|endoftext|> | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>reinterpretAsUInt64};
factory.registerFunction<FunctionReinterpretAsUInt64>(documentation_reinterpretAsUInt64);
FunctionDocumentation::Description description_reinterpretAsUInt128 = R"(
Reinterprets the input value as a value of type UInt128.
Unlike [`CAST`](#CAST), the function does not attempt... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <Columns/ColumnString.h>
#include <Columns/ColumnVector.h>
#include <DataTypes/DataTypeString.h>
#include <DataTypes/DataTypesNumber.h>
#include <Functions/FunctionFactory.h>
#include <Functions/FunctionHelpers.h>
#include <Functions/IFunction.h>
#include <Functions/castTypeToEither.h>
namespac... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>ionDocumentation documentation = {description, syntax, arguments, {}, returned_value, examples, introduced_in, category};
factory.registerFunction<FunctionReplaceAll>(documentation);
factory.registerAlias("replace", NameReplaceAll::name, FunctionFactory::Case::Insensitive);
}
}
<|fim_prefix|>#in... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>"(
ββresββββββββββββββ
β Hi, Hello world β
βββββββββββββββββββ
)"
}
};
FunctionDocumentation::IntroducedIn introduced_in = {1, 1};
FunctionDocumentation::Category category = FunctionDocumentation::Category::StringReplacement;
FunctionDocumentation documentation = {description, ... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <Functions/FunctionStringReplace.h>
#include <Functions/FunctionFactory.h>
#include <Functions/ReplaceRegexpImpl.h>
namespace DB
{
namespace
{
struct NameReplaceRegexpAll
{
static constexpr auto name = "replaceRegexpAll";
};
using FunctionReplaceRegexpAll = Funct<|fim_suffix|>!', '^', 'he... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#inclu<|fim_suffix|>ng literals require extra escaping.
)";
FunctionDocumentation::Syntax syntax = "replaceRegexpOne(haystack, pattern, replacement)";
FunctionDocumentation::Arguments arguments = {
{"haystack", "The input string to search in.", {"String"}},
{"pattern", "The regular... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <Functions/replicate.h>
#include <Functions/FunctionFactory.h>
#include <Functions/FunctionHelpers.h>
#include <DataTypes/DataTypeArray.h>
#include <Columns/ColumnArray.h>
namespace DB
{
namespace ErrorCodes
{
extern const int ILLEGAL_COLUMN;
}
DataTypePtr FunctionReplicate::getReturnTypeI... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <Functions/IFunction.h>
#include <Interpreters/Context_fwd.h>
namespace DB
{
/// Creates an array, multiplying the column (the first argument) by the number of elements in the array (the second argument).
/// Function may accept <|fim_suffix|>tsExecution(const DataTypesWithConstIn... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>_res;
}
if (const ColumnTuple * col_tuple = checkAndGetColumn<ColumnTuple>(column.get()))
{
size_t tuple_size = col_tuple->tupleSize();
if (tuple_size == 0)
{
/// Preserve the number of rows for empty tuple columns
... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <Columns/ColumnString.h>
namespace DB
{
/** Reverse the string as a sequence <|fim_suffix|>lumnString::Chars & res_data,
size_t input_rows_count)
{
res_data.resize_exact(data.size());
for (size_t i = 0; i < input_rows_count; ++i)
for (size_... | fim | ClickHouse/ClickHouse | c |
#include <Columns/ColumnString.h>
#include <DataTypes/DataTypeString.h>
#include <Functions/FunctionFactory.h>
#include <Functions/FunctionStringToString.h>
#include <Common/StringUtils.h>
#include <Common/UTF8Helpers.h>
#include <Functions/reverse.h>
namespace DB
{
namespace ErrorCodes
{
extern const int ILLEGAL... | fim | ClickHouse/ClickHouse | cpp |
#include <Functions/FunctionFactory.h>
#include <Functions/LeftRight.h>
namespace DB
{
REGISTER_FUNCTION(Right)
{
FunctionDocumentation::Description description = R"(
Returns a substring of string `s` with a specified `offset` starting from the right.
)";
FunctionDocumentation::Syntax syntax = "right(s, offse... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>unctionDocumentation::ReturnedValue returned_value = {"Returns either the highest or lowest age of the range `age` falls within.", {"UInt8"}};
FunctionDocumentation::Examples examples = {
{
"Usage example",
"SELECT *, roundAge(*) FROM system.numbers WHERE number IN (0, 5, 20, 31, 3... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <Functions/FunctionFactory.h>
#include <Functions/FunctionUnaryArithmetic.h>
namespace DB
{
namespace
{
template <typename A>
struct RoundDurationImpl
{
using ResultType = UInt16;
static constexpr bool allow_string_or_fixed_string = false;
static ResultType apply(A x)
{
... | fim | ClickHouse/ClickHouse | cpp |
#include <type_traits>
#include <base/bit_cast.h>
#include <Functions/FunctionFactory.h>
#include <Functions/FunctionUnaryArithmetic.h>
namespace DB
{
namespace ErrorCodes
{
extern const int NOT_IMPLEMENTED;
}
namespace
{
template <typename T>
requires std::is_integral_v<T> && (sizeof(T) <= sizeof(UInt32))
inlin... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>ataTypePtr getReturnTypeImpl(const DataTypes & /*arguments*/) const override
{
return std::make_shared<DataTypeUInt64>();
}
ColumnPtr executeImplDryRun(const ColumnsWithTypeAndName &, const DataTypePtr &, size_t input_rows_count) const override
{
/// Dry-run callers (e.g. ... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>) processed by `rowNumberInBlock`, returns the number of the current row.
The returned number starts from 0 for each block.
)";
FunctionDocumentation::Syntax syntax = "rowNumberInBlock()";
FunctionDocumentation::Arguments arguments = {};
FunctionDocumentation::ReturnedValue returned_value... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|> )",
R"(
ββnumberββ¬βone_row_sumββ¬βcumulative_sumββ
β 0 β 0 β 0 β
β 1 β 1 β 1 β
β 2 β 2 β 3 β
β 3 β 3 β 6 β
β 4 β 4 β 10 β
ββββββββββ΄ββββββββββββββ΄βββββββββ... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|> return std::make_unique<ExecutableFunctionRunningConcurrency>();
}
bool isStateful() const override
{
return true;
}
bool isSuitableForShortCircuitArgumentsExecution(const DataTypesWithConstInfo & /*arguments*/) const override { return true; }
p... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>ed_value = {"Returns the difference between consecutive values, with 0 for the first row.", {}};
FunctionDocumentation::Examples examples = {{"Usage example",
R"(
SELECT
EventID,
EventTime,
runningDifference(EventTime) AS delta
FROM
(
SELECT
EventID,
EventTime
... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <Columns/ColumnNullable.h>
#include <Core/Settings.h>
#include <DataTypes/DataTypeDate.h>
#include <DataTypes/DataTypeDate32.h>
#include <DataTypes/DataTypeDateTime.h>
#include <DataTypes/DataTypeDateTime64.h>
#include <DataTypes/DataTypeNullable.h>
#include <DataTypes/NumberTraits.h... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>
FunctionDocumentation::IntroducedIn introduced_in = {1, 1};
FunctionDocumentation::Category category = FunctionDocumentation::Category::Other;
FunctionDocumentation documentation = {description, syntax, arguments, {}, returned_value, examples, introduced_in, category};
factory.registerFu... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|> const auto * col_point = checkAndGetColumn<ColumnUInt64>(non_const_arguments[2].column.get());
if (!col_point)
throw Exception(
ErrorCodes::ILLEGAL_COLUMN,
"Illegal type {} of argument {} of function {}. Must be UInt64",
arguments[... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#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 <Functions/FunctionHelpers.h>
#include <Common/typeid_cast.h>
#include <... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|> getName());
dst_data.emplace_back(S2CellId(id_first).intersects(S2CellId(id_second)));
}
return dst;
}
};
}
REGISTER_FUNCTION(S2CellsIntersect)
{
FunctionDocumentation::Description description = R"(
Determines if two provided S2 cells intersect or not.
)";
... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>FunctionDocumentation::Examples examples = {{"Basic usage", "SELECT s2GetNeighbors(5765131099823669248)", "[5765131099698741248, 5765131099950653440, 5765131100074868736, 5765131100088901632]"}};
FunctionDocumentation::IntroducedIn introduced_in = {21, 9};
FunctionDocumentation::Category category ... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#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 <Functions/s2_fwd.h>
namespace DB
{
namespace ErrorCodes
{
extern... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#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_f... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#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_f... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>n 4; }
bool useDefaultImplementationForConstants() const override { return true; }
bool isSuitableForShortCircuitArgumentsExecution(const DataTypesWithConstInfo & /*arguments*/) const override { return true; }
DataTypePtr getReturnTypeImpl(const DataTypes & arguments) const override
{
... | fim | ClickHouse/ClickHouse | cpp |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.