text stringlengths 14 100k | source stringclasses 1
value | repo stringclasses 810
values | language stringclasses 13
values |
|---|---|---|---|
<|fim_prefix|>#pragma once
#include <Parsers/IParserBase.h>
namespace DB
{
class ParserJSONPathRange : public IParserBase
{
private:
const char * getName() const override { return "ParserJSONPathRange"; }
bool parseImpl(Pos & pos, ASTPtr & n<|fim_suffix|>c:
explicit ParserJSONPathRange() = default;
};
}... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Functions/JSONPath/ASTs/ASTJSONPathRoot.h>
#include <Functions/JSONPath/Parsers/ParserJSONPathRoot.h>
#include <Parsers/Lexer.h>
namespace DB
{
/**
*
* @param pos token iterator
* @param node node of ASTJSONPathRoot
* @param expected stuff fo<|fim_suffix|> expected.add(pos, "dollar sign (s... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>ase
{
private:
const char * getName() const override { return "ParserJSONPathRoot"; }
bool parseImpl(Pos & pos, ASTPtr & node, Expected & expected) override;
public:
explicit ParserJSONPathRoot() = default;
};
}
<|fim_prefix|>#pragma once
#include <<|fim_middle|>Parsers/IParserBase.h>
nam... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>eturn false;
}
++pos;
if (pos->type != TokenType::Asterisk)
{
return false;
}
++pos;
if (pos->type != TokenType::ClosingSquareBracket)
{
expected.add(pos, "Closing square bracket");
return false;
}
++pos;
node = make_intrusive<ASTJSONPat... | fim | ClickHouse/ClickHouse | cpp |
#pragma once
#include <Parsers/IParserBase.h>
namespace DB
{
class ParserJSONPathStar : public IParserBase
{
private:
const char * getName() const override { return "ParserJSONPathStar"; }
bool parseImpl(Pos & pos, ASTPtr & node, Expected & expected) override;
public:
explicit ParserJSONPathStar() = def... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Functions/IFunction.h>
#include <Functions/FunctionHelpers.h>
#include <Functions/FunctionFactory.h>
#include <DataTypes/DataTypesNumber.h>
#include <DataTypes/DataTypeMap.h>
#include <DataTypes/DataTypeArray.h>
#include <DataTypes/DataTypeString.h>
#include <DataTypes/DataTypeObject.h>
#include... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|> auto tuple_column = tuple_element_func
->build(untuple_args)
->execute(untuple_args, result_type, input_rows_count, /* dry_run = */ false);
tuple_column = tuple_column->convertToFullColumnIfConst();
aut... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>(types);
}
return getLeastSupertype(types);
}
private:
ContextPtr context;
bool legacy_null_behavior;
};
}
<|fim_prefix|>#pragma once
#include <DataTypes/getLeastSupertype.h>
#include <DataTypes/NumberTraits.h>
#include <Interpreters/Context.h>
#include <Interpreters/castCo... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#pragma once
#include <DataTypes/DataTypeString.h>
#include <Columns/ColumnString.h>
#include <Columns/ColumnFixedString.h>
#include <Columns/ColumnConst.h>
#include <Functions/FunctionHelpers.h>
#include <Functions/IFunction.h>
#include <Functions/GatherUtils/GatherUtils.h>
#include <Functions/GatherUti... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#pragma once
#include <Columns/ColumnString.h>
#include <Common/TargetSpecific.h>
namespace DB
{
template <char not_case_lower_bound, char not_case_upper_bound>
struct LowerUpperImpl
{
static void vector(
const ColumnString::Chars & data,
const ColumnString::Offsets & offsets,
... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#pragma once
#include "config.h"
#if USE_ICU
# include <Columns/ColumnString.h>
# include <Functions/LowerUpperImpl.h>
# include <base/scope_guard.h>
# include <unicode/ucasemap.h>
# include <unicode/unistr.h>
# include <unicode/urename.h>
# include <unicode/utypes.h>
# include ... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#pragma once
#include <type_traits>
#include <base/types.h>
#include <Common/Volnitsky.h>
#include <Columns/ColumnString.h>
#include <Columns/ColumnsNumber.h>
#include <Core/ColumnNumbers.h>
#include <Functions/Regexps.h>
namespace DB
{
namespace ErrorCodes
{
extern const int ILLEGAL_COLUMN;
}
nam... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#pragma once
#include <base/types.h>
#include <Columns/ColumnArray.h>
#include <Columns/ColumnString.h>
#include <DataTypes/DataTypesNumber.h>
#include <DataTypes/DataTypeArray.h>
#include <Functions/checkHyperscanRegexp.h>
#include <Functions/Regexps.h>
#include "config.h"
#if USE_VECTORSCAN
# incl... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#pragma once
#include <base/types.h>
#include <Columns/ColumnArray.h>
#include <Columns/ColumnString.h>
#include <Functions/checkHyperscanRegexp.h>
#include <Functions/Regexps.h>
#include "config.h"
#if USE_VECTORSCAN
# include <hs.h>
#endif
namespace DB
{
namespace ErrorCodes
{
extern const ... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>MATCH,
"Number of arguments for function {} doesn't match: passed {}, should be at most 255", name, needles_size);
vec_res.resize(vec_res.size() + needles_size);
auto searcher = Impl::createMultiSearcherInBigHaystack(needles); /// sub-optimal
/// ... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#pragma once
#include <vector>
#include <Columns/ColumnArray.h>
#include <Columns/ColumnString.h>
#include <Common/VectorWithMemoryTracking.h>
namespace DB
{
namespace ErrorCodes
{
extern const int NUMBER_OF_ARGUMENTS_DOESNT_MATCH;
}
template <typename Name, typename Impl>
struct MultiSearchFirst... | fim | ClickHouse/ClickHouse | c |
#pragma once
#include <vector>
#include <Columns/ColumnArray.h>
#include <Columns/ColumnString.h>
#include <Common/VectorWithMemoryTracking.h>
namespace DB
{
namespace ErrorCodes
{
extern const int TOO_MANY_ARGUMENTS_FOR_FUNCTION;
}
template <typename Name, typename Impl>
struct MultiSearchFirstPositionImpl
{
... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#pragma once
#include <vector>
#include <Columns/ColumnArray.h>
#include <Columns/ColumnString.h>
#include <Common/VectorWithMemoryTracking.h>
namespace DB
{
namespace ErrorCodes
{
extern const int TOO_MANY_ARGUMENTS_FOR_FUNCTION;
}
/// The Volnitsky multi-searcher used for a constant array of ne... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#pragma once
#include <Functions/IFunction.h>
#include <Common/TargetSpecific.h>
#include <Common/Stopwatch.h>
#include <Common/VectorWithMemoryTracking.h>
#include <Core/Settings.h>
#include <Interpreters/Context.h>
#include <pcg_random.hpp>
#include <mutex>
#include <random>
/* This file contains h... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#pragma once
#include <base/demangle.h>
#include <base/types.h>
#include <Common/Exception.h>
#include <Core/Defines.h>
#include <base/TypeLists.h>
#include <Columns/IColumn.h>
#include <Columns/ColumnVector.h>
#include <Common/typeid_cast.h>
#include <Common/NaNUtils.h>
#include <Common/VectorWithMemory... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>cePos(
reinterpret_cast<const char *>(&haystack_data[prev_haystack_offset]),
reinterpret_cast<const char *>(&haystack_data[haystack_offsets[i]]),
start - 1);
/// searcher returns a pointer to the found substring or to the end of `... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>
size_t total = 0;
for (size_t i = 0; i < input_rows_count; ++i)
{
std::string_view query = col_query.getDataAt(i);
Impl::processRow(query, data_begin, data_end, data_type, total, parser_settings);
offsets[i] = total;
}
Mutab... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>alCacheTable pool; /// Different variables for different pattern parameters, thread-safe in C++11
VectorWithMemoryTracking<String> str_patterns;
str_patterns.reserve(patterns.size());
for (const auto & pattern : patterns)
str_patterns.emplace_back(String(pattern));
size_t bucket_... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#pragma once
#include <Columns/ColumnString.h>
#include <Common/OptimizedRegularExpression.h>
#include <Common/VectorWithMemoryTracking.h>
#include <Common/re2.h>
#include <Functions/Regexps.h>
#include <Functions/ReplaceStringImpl.h>
#include <base/types.h>
namespace DB
{
namespace ErrorCodes
{
ex... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#pragma once
#include <base/types.h>
#include <Common/Volnitsky.h>
#include <Columns/ColumnString.h>
namespace DB
{
struct ReplaceStringTraits
{
enum class Replace : uint8_t
{
First,
All
};
};
/** Replace one or all occurencies of substring 'needle' to 'replacement'.
*/
... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>lumnString::Offsets & res_offsets,
size_t input_rows_count)
{
res_offsets.resize(input_rows_count);
res_data.reserve(input_rows_count * Extractor::getReserveLengthForElement());
size_t prev_offset = 0;
size_t res_offset = 0;
/// Matched part.
P... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|> /// We can handle UUID and FixedString(16) as UInt128 as they have the same size.
std::string_view data = column.getRawData();
chassert(data.size() == num_rows * sizeof(UInt128));
const UInt128 * begin = reinterpret_cast<const UInt128 *>(data.data())... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>sAndValues(const VectorWithMemoryTracking<TagNamesAndValuesPtr> & tags_vector);
}
<|fim_prefix|>#pragma once
#include <Columns/IColumn_fwd.h>
#include <Interpreters/ContextTimeSeriesTagsCollector.h>
#include <base/types.h>
#include <Common/VectorWithMemoryTracking.h>
namespace DB
{
struct ColumnWi... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>src_group, '__name__') AS result_group,
timeSeriesGroupToTags(result_group)
)",
R"(
ββdest_groupββ¬βsrc_groupββ¬βresult_groupββ¬βtimeSeriesGroupToTags(result_group)βββββββββββββββββββββββββ
β 1 β 2 β 3 β [('__name__','http_codes'),('code','404'),('region','e... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <Functions/FunctionFactory.h>
#include <DataTypes/DataTypesNumber.h>
#include <Functions/TimeSeries/TimeSeriesTagsFunctionHelpers.h>
#include <Interpreters/Context.h>
#include <Interpreters/ContextTimeSeriesTagsCollector.h>
namespace DB
{
namespace ErrorCodes
{
extern const int NUMBER_OF_... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>s) const override
{
checkArgumentTypes(arguments);
return std::make_shared<DataTypeNullable>(std::make_shared<DataTypeString>());
}
static void checkArgumentTypes(const ColumnsWithTypeAndName & arguments)
{
if (arguments.size() != 2)
{
throw Exc... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>eriesGroupToSamplingKey final : public IFunction
{
public:
static constexpr auto name = "timeSeriesGroupToSamplingKey";
static FunctionPtr create(ContextPtr context) { return std::make_shared<FunctionTimeSeriesGroupToSamplingKey>(context); }
explicit FunctionTimeSeriesGroupToSamplingKey(Conte... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <Functions/FunctionFactory.h>
#include <DataTypes/DataTypeArray.h>
#include <DataTypes/DataTypeString.h>
#include <DataTypes/DataTypeTuple.h>
#include <Functions/TimeSeries/TimeSeriesTagsFunctionHelpers.h>
#include <Interpreters/Context.h>
#include <Interpreters/ContextTimeSeriesTagsCollector.h>... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>AndName & arguments) const override
{
checkArgumentTypes(arguments);
return std::make_shared<DataTypeUInt64>();
}
static void checkArgumentTypes(const ColumnsWithTypeAndName & arguments)
{
if (arguments.size() != 1)
{
throw Exception(ErrorCodes:... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>ags>(documentation);
}
}
<|fim_prefix|>#include <Functions/FunctionFactory.h>
#include <Functions/TimeSeries/TimeSeriesTagsFunctionHelpers.h>
#include <DataTypes/DataTypeArray.h>
#include <DataTypes/DataTypeString.h>
#include <DataTypes/DataTypeTuple.h>
#include <Interpreters/Context.h>
#include <Interp... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <Functions/FunctionFactory.h>
#include <DataTypes/DataTypesNumber.h>
#include <Functions/TimeSeries/TimeSeriesTagsFunctionHelpers.h>
#include <Interpreters/Context.h>
#include <Interpreters/ContextTimeSeriesTagsCollector.h>
namespace DB
{
namespace ErrorCodes
{
extern const int NUMBER_OF_... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>scale = 0;
if (isDateTime64(*end_timestamp_type))
end_timestamp_scale = getDecimalScale(*end_timestamp_type);
chassert(end_timestamp_scale <= result_timestamp_scale);
Int64 end_timestamp_multiplier = (end_timestamp_scale < result_timestamp_scale) ? DecimalUtils::scaleMu... | fim | ClickHouse/ClickHouse | cpp |
#include <Functions/FunctionFactory.h>
#include <DataTypes/DataTypesNumber.h>
#include <Functions/TimeSeries/TimeSeriesTagsFunctionHelpers.h>
#include <Interpreters/Context.h>
#include <Interpreters/ContextTimeSeriesTagsCollector.h>
namespace DB
{
namespace ErrorCodes
{
extern const int NUMBER_OF_ARGUMENTS_DOES... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <Functions/FunctionFactory.h>
#include <DataTypes/DataTypesNumber.h>
#include <Functions/TimeSeries/TimeSeriesTagsFunctionHelpers.h>
#include <Interpreters/Context.h>
#include <Interpreters/ContextTimeSeriesTagsCollector.h>
namespace DB
{
namespace ErrorCodes
{
extern const int NUMBER_OF_... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>gs(empty_group)ββ
β 1 β 2 β [('__name__','http_requests_count')] β 0 β [] β
ββββββββββββββ΄βββββββββββββ΄βββββββββββββββββββββββββββββββββββββββ΄ββββββββββββββ΄βββββββββββββββββββββββββββββββββββββ
)"
}
};
FunctionDocumentation::I... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>ents, 3);
auto regex = TimeSeriesTagsFunctionHelpers::extractConstStringFromArgument(name, arguments, 4);
auto new_groups = tags_collector->replaceTag(old_groups, dest_tag, replacement, src_tag, regex);
chassert(new_groups.size() == input_rows_count);
return TimeSeriesTa... | fim | ClickHouse/ClickHouse | cpp |
#include <Functions/FunctionFactory.h>
#include <Functions/TimeSeries/TimeSeriesTagsFunctionHelpers.h>
#include <Interpreters/Context.h>
#include <Interpreters/ContextTimeSeriesTagsCollector.h>
namespace DB
{
namespace ErrorCodes
{
extern const int NUMBER_OF_ARGUMENTS_DOESNT_MATCH;
}
/// Function timeSeriesSto... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <Functions/FunctionFactory.h>
#include <Functions/TimeSeries/TimeSeriesTagsFunctionHelpers.h>
#include <DataTypes/DataTypesNumber.h>
#include <Interpreters/Context.h>
#include <Interpreters/ContextTimeSeriesTagsCollector.h>
namespace DB
{
namespace ErrorCodes
{
extern const int NUMBER_OF_... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <Functions/FunctionFactory.h>
#include <Columns/ColumnsNumber.h>
#include <DataTypes/DataTypesNumber.h>
#include <Functions/FunctionHelpers.h>
#include <Functions/TimeSeries/TimeSeriesTagsFunctionHelpers.h>
#include <Interpreters/Context.h>
#include <Interpreters/ContextTimeSeriesTagsCollector.h... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>f range and denormals conversion.
if constexpr (TransformHasExecuteOverload_v<DateTime64, decltype(scale_multiplier), Args...>)
{
return wrapped_transform.executeExtendedResult(t, scale_multiplier, std::forward<Args>(args)...);
}
else if constexpr (TransformHas... | fim | ClickHouse/ClickHouse | c |
#pragma once
#include <Core/Types.h>
#include <Core/DecimalFunctions.h>
namespace DB
{
/** Transform-type wrapper for DateTime64, simplifies DateTime64 support for given Transform.
*
* Depending on what overloads of Transform::execute() are available, when called with DateTime64 value,
* invokes Transform::execute... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>tation::Category::ULID;
FunctionDocumentation documentation = {description, syntax, arguments, {}, returned_value, examples, introduced_in, category};
factory.registerFunction<FunctionULIDStringToDateTime>(documentation);
}
}
#endif
<|fim_prefix|>#include "config.h"
#if USE_ULID
#include <Com... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>ain of the second level
res_data += last_periods[1] + 1 - begin;
res_size = last_periods[0] - last_periods[1] - 1;
}
};
}
<|fim_prefix|>#pragma once
#include <base/find_symbols.h>
#include <Functions/URL/domain.h>
#include <Functions/URL/tldLookup.h>
#include <Common/TLDListsHolder.... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>e String.",
arguments[0].type->getName(), getName());
if (!isString(arguments[1].type))
throw Exception(ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT,
"Illegal type {} of second argument (TLD_list_name) of function {}. Must be String/FixedString.",
... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Functions/FunctionFactory.h>
#include <Functions/FunctionTokens.h>
namespace DB
{
namespace
{
using Pos = const char *;
class URLPathHierarchyImpl
{
private:
Pos begin;
Pos pos;
Pos end;
Pos start;
public:<|fim_suffix|> < end && !(*pos == '/' || *pos == '?' || *pos == '#'))... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>if (pos != end)
++pos;
token_begin = begin;
token_end = pos;
return true;
}
};
using FunctionURLHierarchy = FunctionTokens<URLHierarchyImpl>;
}
REGISTER_FUNCTION(URLHierarchy)
{
FunctionDocumentation::Description description = R"(
Returns an array containi... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <Functions/FunctionFactory.h>
#include <Functions/FunctionStringToString.h>
#include <Functions/StringHelpers.h>
namespace DB
{
/** Extract substring after the last slash or backslash.
* If there are no slashes, return the string unchanged.
* It is used to extract filename from path.
*/
... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <Functions/FunctionFactory.h>
#include <Functions/FunctionStringToString.h>
#include <Functions/URL/fragment.h>
namespace DB
{
struct NameCutFragment { static constexpr auto name = "cutFragment"; };
using FunctionCutFragment = FunctionStringToString<CutSubstringImpl<ExtractFragment<false>>, Nam... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <Functions/FunctionFactory.h>
#include <Functio<|fim_suffix|>erFunction<FunctionCutQueryString>(documentation_cutQueryString);
}
}
<|fim_middle|>ns/FunctionStringToString.h>
#include <Functions/URL/queryString.h>
namespace DB
{
struct NameCutQueryString { static constexpr auto name = "cutQuery... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <Functions/FunctionFactory.h>
#include <Functions/FunctionStringToString.h>
#include <Functions/URL/queryStringAndFragment.h>
namespace DB
{
struct NameCutQueryStringAndFragment { static constexpr auto name = "cutQueryStringAndFragment"; };
using FunctionCutQueryStringAndFragment = FunctionStri... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <Functions/FunctionFactory.<|fim_suffix|>nCutToFirstSignificantSubdomainWithWWW>(cutToFirstSignificantSubdomainWithWWW_documentation);
FunctionDocumentation::Description cutToFirstSignificantSubdomainRFC_description = R"(
Returns the part of the domain that includes top-level subdomains up t... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>cutToFirstSignificantSubdomainCustomRFC_documentation = {cutToFirstSignificantSubdomainCustomRFC_description, cutToFirstSignificantSubdomainCustomRFC_syntax, cutToFirstSignificantSubdomainCustomRFC_arguments, {}, cutToFirstSignificantSubdomainCustomRFC_returned_value, cutToFirstSignificantSubdomainCustomR... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <Columns/ColumnString.h>
#include <DataTypes/DataTypeArray.h>
#include <DataTypes/DataTypeString.h>
#include <Functions/FunctionHelpers.h>
#include <Functions/FunctionFactory.h>
#include <base/find_symbols.h>
namespace DB
{
namespace ErrorCodes
{
extern const int ILLEGAL_TYPE_OF_ARGUMENT;
... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|> FunctionDocumentation::Arguments arguments_cutWWW = {
{"url", "URL.", {"String"}}
};
FunctionDocumentation::ReturnedValue returned_value_cutWWW = {"Returns the URL with leading `www.` removed from the domain.", {"String"}};
FunctionDocumentation::Examples examples_cutWWW = {
{
... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>ionEncodeURLComponent = FunctionStringToString<CodeURLComponentImpl<encode, false>, NameEncodeURLComponent>;
using FunctionDecodeURLFormComponent = FunctionStringToString<CodeURLComponentImpl<decode, true>, NameDecodeURLFormComponent>;
using FunctionEncodeURLFormComponent = FunctionStringToString<CodeURLC... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>ββββββββββββββββββββββββββββββββββββββββββββ
)"
}
};
FunctionDocumentation::IntroducedIn introduced_in_domain = {1, 1};
FunctionDocumentation::Category category_domain = FunctionDocumentation::Category::URL;
FunctionDocumentation documentation_domain = {description_domain, synt... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|> case '=':
case '&':
return std::string_view{};
default:
goto exloop;
}
}
}
exloop: if ((scheme_end - pos) > 2 && *pos == ':' && *(pos + 1) == '/' && *(pos + 2) == '/')
pos +=... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>domainWithoutWWWRFC = R"(
Returns the domain without leading `www.` if present. Similar to [`domainWithoutWWW`](#domainWithoutWWW) but conforms to [RFC 3986](https://datatracker.ietf.org/doc/html/rfc3986).
)";
FunctionDocumentation::Syntax syntax_domainWithoutWWWRFC = "domainWithoutWWWRFC(url)";
... | fim | ClickHouse/ClickHouse | cpp |
#include <Functions/FunctionFactory.h>
#include <Functions/FunctionsStringSearchToString.h>
#include <base/find_symbols.h>
namespace DB
{
struct ExtractURLParameterImpl
{
static void vector(const ColumnString::Chars & data,
const ColumnString::Offsets & offsets,
std::string pattern,
Colum... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <Functions/FunctionFactory.h>
#include <Functions/FunctionTokens.h>
namespace DB
{
namespace
{
using Pos = const char *;
class ExtractURLParameterNamesImpl
{
private:
Pos pos;
Pos end;
bool first;
public:
static constexpr auto name = "extractURLParameterNames";
<|fim_suff... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>d)
return false;
/// Skip to the query string or fragment identifier
if (first)
{
first = false;
pos = find_first_symbols<'?', '#'>(pos, end);
if (pos + 1 >= end)
return false;
++pos;
}
//... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <Functions/FunctionFactory.h>
#include <Functions/FunctionStringToString.h>
#include <Functions/URL/ExtractFirstSignificantSubdomain.h>
namespace DB
{
struct NameFirstSignificantSubdomain { static constexpr auto name = "firstSignificantSubdomain"; };
using FunctionFirstSignificantSubdomain = F... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <Functions/FunctionFactory.h>
#include <Functions/URL/ExtractFirstSignificantSubdomain.h>
#include <Functions/URL/FirstSignificantSubdomainCustomImpl.h>
namespace DB
{
struct NameFirstSignificantSubdomainCustom { static constexpr auto name = "firstSignificantSubdomainCustom"; };
using Function... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <Functions/FunctionFactory.h>
#include <Functions/FunctionStringToString.h>
#include <Functions/URL<|fim_suffix|>e-a-clickhouse-service');
)",
R"(
ββfragment('httpβ―ouse-service')ββ
β 1-create-a-clickhouse-service β
βββββββββββββββββββββββββββββββββ
)"
}... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>data, size_t & res_size)
{
res_data = data;
res_size = 0;
Pos pos = data;
Pos end = pos + size;
if (end != (pos = find_first_symbols<'#'>(pos, end)))
{
res_data = pos + (without_leading_char ? 1 : 0);
res_size = end - res_data;
... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>ples_netloc, introduced_in_netloc, category_netloc};
factory.registerFunction<FunctionNetloc>(documentation_netloc);
}
}
<|fim_prefix|>#include <Common/StringUtils.h>
#include <Functions/FunctionFactory.h>
#include <Functions/FunctionStringToString.h>
#include <Functions/StringHelpers.h>
#include <... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|> FunctionDocumentation::Examples examples_path = {
{
"Usage example",
R"(
SELECT path('https://clickhouse.com/docs/sql-reference/functions/url-functions/?query=value');
)",
R"(
ββpath('https://clickhouse.com/en/sql-reference/functions/url-functions/?query=value')ββ
β /... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|> return;
}
res_data = pos;
if constexpr (with_query_string)
{
res_size = end - res_data;
}
else
{
Pos query_string_or_fragment = find_first_symbols<'?', '#'>(pos, end);
res_size = query_string_or_fragment - res_... | fim | ClickHouse/ClickHouse | c |
#include <Functions/FunctionFactory.h>
#include <Functions/FunctionStringToString.h>
#include <Functions/StringHelpers.h>
#include <Functions/URL/path.h>
#include <base/find_symbols.h>
namespace DB
{
struct NamePathFull { static constexpr auto name = "pathFull"; };
using FunctionPathFull = FunctionStringToString<Extr... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <Functions/FunctionFactory.h>
#include <Funct<|fim_suffix|> }
ColumnNumbers getArgumentsThatAreAlwaysConstant() const override { return {1}; }
bool isSuitableForShortCircuitArgumentsExecution(const DataTypesWithConstInfo & /*arguments*/) const override { return true; }
DataTypePtr ge... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <Functions/FunctionFactory.h>
#include <Functions/FunctionStringToString.h>
#include <Functions/URL/protocol.h>
namespace DB
{
struct NameProtocol { static const<|fim_suffix|>rotocol = FunctionStringToString<ExtractSubstringImpl<ExtractProtocol>, NameProtocol>;
REGISTER_FUNCTION(Protocol)
{
... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <Common/StringUtils.h>
#include <Functions/StringHelpers.h>
namespace DB
{
/// Extracts scheme from given url.
inline std::string_view getURLScheme(const char * data, size_t size)
{
if (size == 0)
return {};
// scheme = ALPHA *( ALPHA / DIGIT / "+" / "-" / "." )
... | fim | ClickHouse/ClickHouse | c |
#include <Functions/FunctionFactory.h>
#include <Functions/FunctionStringToString.h>
#include <Functions/URL/queryString.h>
namespace DB
{
struct NameQueryString { static constexpr auto name = "queryString"; };
using FunctionQueryString = FunctionStringToString<ExtractSubstringImpl<ExtractQueryString<true>>, NameQuer... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <base/find_symbols.h>
#include <Functions/StringHelpers.h>
namespace DB
{
template <bool without_leading_char>
struct ExtractQueryString
{
static size_t getReserveLengthForElement() { return 10; }
static void execute(Pos data, size_t size, Pos & res_data, size_t & res_si... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Functions/FunctionFactory.h>
#include <Functions/FunctionStringToString.h>
#include <Functions/URL/queryString<|fim_suffix|> "queryStringAndFragment(url)";
FunctionDocumentation::Arguments arguments_queryStringAndFragment = {
{"url", "URL.", {"String"}}
};
FunctionDocumentati... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>es_size = 0;
Pos end = data + size;
Pos pos = nullptr;
if (end != (pos = find_first_symbols<'?'>(data, end)))
{
res_data = pos + (without_leading_char ? 1 : 0);
res_size = end - res_data;
}
else if (end != (pos = find_first_symbols<... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|> hash(const char *str, size_t len);
public:
static const char * isValid(const char *str, size_t len);
};
namespace DB
{
using tldLookup = TopLevelDomainLookupHash;
}
<|fim_prefix|>#pragma once
#include <cstdlib>
// Definition of<|fim_middle|> the class generated by gperf, present on gperf/tldLo... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Functions/FunctionFactory.h>
#include <Functions/FunctionStringToString.h>
#include <Functions/URL/domain.h>
namespace DB
{
template<bool conform_rfc>
struct ExtractTopLevelDomain
{
static size_t getReserveLengthForElement() { return 5; }
static void execute(Pos data, size_t size, Pos... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>types;
DataTypePtr return_type;
};
class UTCTimestampOverloadResolver final : public IFunctionOverloadResolver
{
public:
static constexpr auto name = "UTCTimestamp";
String getName() const override { return name; }
bool isDeterministic() const override { return false; }
bool isVari... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <Columns/ColumnConst.h>
#include <Columns/ColumnsDateTime.h>
#include <Columns/ColumnString.h>
#include <Columns/ColumnsNumber.h>
#include <Columns/IColumn.h>
#include <Common/DateLUT.h>
#include <Common/DateLUTImpl.h>
#include <Common/LocalDateTime.h>
#include <Common/logger_useful.h>
#include <... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <Functions/UUIDv7Utils.h>
#include <Core/UUID.h>
namespace DB
{
namespace UUIDv7Utils
{
void setTimestampAndVersion(UUID & uuid, uint64_t timestamp)
{
UUIDHelpers::getHighBytes(uuid) = (UUIDHelpers::getHighBytes(uuid) & rand_a_bits_mask) | (timestamp << 16) | 0x7000;
}
void setVariant(UUI... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <Common/SharedMutex.h>
#include <DataTypes/DataTypeUUID.h>
#include <mutex>
/// Common functionality for UUIDv7-related functions.
namespace DB
{
namespace UUIDv7Utils
{
/* Bit layout of UUIDv7
0 1 2 3
0 1 2 3 4 5 6 7 8 9 ... | fim | ClickHouse/ClickHouse | c |
#include <Functions/FunctionFactory.h>
#include <Functions/UniqTheta/FunctionsUniqTheta.h>
#if USE_DATASKETCHES
namespace DB
{
REGISTER_FUNCTION(UniqTheta)
{
/// uniqThetaUnion documentation
FunctionDocumentation::Description description_uniqThetaUnion = R"(
Two uniqThetaSketch objects to do union calculati... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include "config.h"
#if USE_DATASKETCHES
#include <AggregateFunctions/AggregateFunctionFactory.h>
#include <Columns/ColumnAggregateFunction.h>
#include <Columns/ColumnConst.h>
#include <Columns/ColumnVector.h>
#include <DataTypes/DataTypeAggregateFunction.h>
#include <Functions/FunctionHel... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>mmand_execution_time,
.is_executable_pool = is_executable_pool,
.send_chunk_header = send_chunk_header,
.execute_direct = execute_direct
};
auto coordinator = std::make_shared<ShellCommandSourceCoordinator>(shell_command_coordinator_configration);
return std::make_shar... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>tr createObject(const std::string & name,
const Poco::Util::AbstractConfiguration & config,
const std::string & key_in_config,
const std::string & repository_name) const override;
};
}
<|fim_prefix|>#pragma once
#include <memory>
#include <Interpreters/Context_fwd.h>
#include <... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#pragma once
#include <base/types.h>
#include <Core/Types.h>
#include <Interpreters/Context_fwd.h>
#include <Parsers/IA<|fim_suffix|>KeeperStorage
class IUserDefinedSQLObjectsStorage
{
public:
virtual ~IUserDefinedSQLObjectsStorage() = default;
/// Whether this loader can replicate SQL objects... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>
}
}
<|fim_prefix|>#include <Functions/UserDefined/UserDefinedExecutableFunction.h>
#include <Functions/IFunction.h>
#include <Functions/FunctionFactory.h>
#include <Functions/FunctionHelpers.h>
#include <Processors/Sources/ShellCommandSource.h>
namespace DB
{
Us<|fim_middle|>erDefinedExecutableFunc... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>onst UserDefinedExecutableFunction> shared_from_this() const
{
return std::static_pointer_cast<const UserDefinedExecutableFunction>(IExternalLoadable::shared_from_this());
}
private:
UserDefinedExecutableFunctionConfiguration configuration;
std::shared_ptr<ShellCommandSourceCoordi... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>sedMicroseconds, sampler->getElapsedMicroseconds());
ProfileEvents::increment(ProfileEvents::ExecutableUserDefinedFunctionUserTimeMicroseconds, sampler->getUserTimeMicroseconds());
ProfileEvents::increment(ProfileEvents::ExecutableUserDefinedFunctionSystemTimeMicros... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>t String & function_name, ContextPtr context, Array parameters = {});
static bool has(const String & function_name, ContextPtr context);
static Strings getRegisteredNames(ContextPtr context);
};
}
<|fim_prefix|>#pragma once
#include <functional>
#include <memory>
#include <string>
#include <u... | fim | ClickHouse/ClickHouse | c |
#include <Functions/UserDefined/UserDefinedSQLFunctionFactory.h>
#include <Common/CurrentThread.h>
#include <Common/UnorderedSetWithMemoryTracking.h>
#include <Common/quoteString.h>
#include <Common/ThreadStatus.h>
#include <AggregateFunctions/AggregateFunctionFactory.h>
#include <Backups/RestorerFromBackup.h>
#includ... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <Core/Types.h>
#include <Common/NamePrompter.h>
#include <Parsers/ASTCreateSQLFunctionQuery.h>
#include <Interpreters/Context_fwd.h>
namespace DB
{
class BackupEntriesCollector;
class RestorerFromBackup;
class IUserDefinedSQLObjectsStorage;
class WasmModuleMa<|fim_suffix|>unregist... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>n_core_expression->children.at(1)->clone();
if (context_->getSettingsRef()[Setting::skip_redundant_aliases_in_udf])
{
Aliases aliases;
QueryAliasesVisitor(aliases).visit(function_body_to_update);
/// Mark table ASTIdentifiers with not a column marker
MarkTableIden... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <Interpreters/Aliases.h>
#include <Interpreters/InDepthNodeVisitor.h>
#include <Common/UnorderedSetWithMemoryTracking.h>
namespace DB
{
class ASTFunction;
/** Visits ASTFunction nodes and<|fim_suffix|>* SELECT number + 1 FROM system.numbers LIMIT 10;
*/
class UserDefinedSQLFunc... | fim | ClickHouse/ClickHouse | c |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.