text stringlengths 14 100k | source stringclasses 1
value | repo stringclasses 810
values | language stringclasses 13
values |
|---|---|---|---|
<|fim_suffix|> {25, 1},
.category = FunctionDocumentation::Category::Other
});
}
}
<|fim_prefix|>#include <Functions/IFunction.h>
#include <Functions/FunctionFactory.h>
#include <Functions/FunctionHelpers.h>
#include <Interpreters/Context.h>
#include <Interpreters/DatabaseCatalog.h>
#include <DataTypes/Dat... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>ER_FUNCTION(GetMergeTreeSetting)
{
FunctionDocumentation::Description description = R"(
Returns the current value of a MergeTree setting.
)";
FunctionDocumentation::Syntax syntax = "getMergeTreeSetting(setting_name)";
FunctionDocumentation::Arguments arguments = {
{"setting_name", "The... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <Functions/IFunction.h>
#include <Functions/IFunctionAdaptors.h>
#include <Functions/FunctionFactory.h>
#include <Functions/FunctionHelpers.h>
#include <DataTypes/DataTypeString.h>
#include <DataTypes/DataTypesNumber.h>
#include <Columns/ColumnString.h>
#include <Interpreters/Context.h>
#include ... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <DataTypes/DataTypesNumber.h>
#include <Functions/FunctionFactory.h>
#include <Functions/FunctionHelpers.h>
#include <Interpreters/Context.h>
namespace DB
{
namespace ErrorCodes
{
extern const int NUMBER_OF_ARGUMENTS_DOESNT_MATCH;
extern const int ILLEGAL_COLUMN;
extern const int I... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>ged at runtime (e.g. memory limits, cache sizes, thread pool sizes).
/// In that case the live value held by the component diverges from the value stored in `ServerSettings`,
/// which only reflects what was last loaded from the config. `system.server_settings` already returns
/// ... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <Functions/IFunction.h>
#include <Functions/FunctionFactory.h>
#include <Functions/FunctionHelpers.h>
#include <DataTypes/FieldToDataType.h>
#include <Interpreters/convertFieldToType.h>
#include <Interpreters/Context.h>
#include <Core/Field.h>
#include <Core/Settings.h>
namespace DB
{
namespace... | fim | ClickHouse/ClickHouse | cpp |
#include <Functions/IFunction.h>
#include <Functions/FunctionFactory.h>
#include <Functions/FunctionHelpers.h>
#include <DataTypes/DataTypeEnum.h>
#include <DataTypes/DataTypesNumber.h>
namespace DB
{
namespace ErrorCodes
{
extern const int ILLEGAL_TYPE_OF_ARGUMENT;
}
namespace
{
/// Returns number of fields in... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>bcolumn>(FunctionDocumentation{
.description=R"(
Receives the expression or identifier and constant string with the name of subcolumn.
Returns requested subcolumn extracted from the expression.
)",
.syntax = "getSubcolumn(nested_value, subcolumn_name)",
.examples{{"getSubcolumn", ... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <Functions/IFunction.h>
#include <Functions/FunctionFactory.h>
#include <DataTypes/DataTypeString.h>
#include <DataTypes/DataTypeArray.h>
#include <DataTypes/DataTypeFactory.h>
#include <DataTypes/Serializations/ISerialization.h>
#include <Core/Field.h>
#include <Columns/ColumnString.h>
#include ... | fim | ClickHouse/ClickHouse | cpp |
#include <Functions/IFunction.h>
#include <Functions/FunctionFactory.h>
#include <Functions/FunctionHelpers.h>
#include <DataTypes/DataTypesNumber.h>
#include <DataTypes/DataTypeString.h>
#include <Columns/ColumnString.h>
#include <Columns/ColumnConst.h>
#include <Core/Field.h>
#include <Common/UnorderedMapWithMemoryT... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>terFunction("geoDistance", [](ContextPtr context) {return std::make_shared<FunctionGeoDistance<Method::WGS84_METERS>>(std::move(context));}, documentation);
}
}
}
<|fim_prefix|>#include <DataTypes/DataTypesNumber.h>
#include <Columns/ColumnsNumber.h>
#include <Functions/IFunction.h>
#include <Functio... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <Functions/FunctionFactory.h>
#include <Functions/FunctionsComparison.h>
#include <Functions/FunctionsLogical.h>
namespace DB
{
using FunctionGreater = FunctionComparison<GreaterOp, NameGreater>;
using FunctionEquals = FunctionComparison<EqualsOp, NameEquals>;
extern template class FunctionComp... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|> };
FunctionDocumentation::ReturnedValue returned_value = {"Returns `1` if `a` is greater than or equal to `b`, otherwise `0`", {"UInt8"}};
FunctionDocumentation::Examples examples = {
{"Usage example", "SELECT 2 >= 1, 2 >= 2, 1 >= 2;", R"(
ββgreaterOrEquals(2, 1)ββ¬βgreaterOrEquals(2, 2... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <Functions/FunctionFactory.h>
#include <Functions/FunctionBinaryArithmetic.h>
#include <Core/AccurateComparison.h>
#include <Functions/LeastGreatestGeneric.h>
namespace DB
{
template <typename A, typename B>
struct GreatestBaseImpl
{
using ResultType = NumberTraits::ResultOfGreatest<A, B>;... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>: public FunctionGroupingBase
{
public:
FunctionGroupingOrdinary(ColumnNumbers arguments_indexes_, bool force_compatibility_)
: FunctionGroupingBase(std::move(arguments_indexes_), force_compatibility_)
{}
String getName() const override { return "groupingOrdinary"; }
ColumnPtr ex... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>"Incorrect H3 index: {}, error: {}", index, err);
cellAreaM2(index, &res);
}
dst_data[row] = res;
}
return dst;
}
};
}
REGISTER_FUNCTION(H3CellAreaM2)
{
FunctionDocumentation::Description description = R"(
Returns the exact area of a spe... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <Functions/h3Common.h>
#if USE_H3
#include <Columns/ColumnsNumber.h>
#include <DataTypes/DataTypesNumber.h>
#include <Functions/FunctionFactory.h>
#include <Functions/IFunction.h>
#include <IO/WriteHelpers.h>
#include <Common/typeid_cast.h>
#include <base/range.h>
namespace DB
{
namespace Erro... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>functions_h3_default_if_invalid;
}
H3Validator::H3Validator(const ContextPtr & context)
: throw_on_error(!context->getSettingsRef()[Setting::functions_h3_default_if_invalid])
{}
bool H3Validator::validateCell(UInt64 h) const
{
if (!isValidCell(h))
{
if (throw_on_error)
th... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>n any one of those values, only on the whole column at once.
/// * segfault in getIcosahedronFaces.
/// Some of these failures were inconsistent or depended on other values in the input IColumn,
/// which means there's probably memory corruption.)
struct H3Validator
{
bool throw_on_error;
explic... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>ell(end))
{
int64_t distance = 0;
if (!gridDistance(start, end, &distance))
res = distance;
}
dst_data[row] = res;
}
return dst;
}
};
}
REGISTER_FUNCTION(H3Distance)
{
FunctionDocumentation:... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include "config.h"
#if USE_H3
#include <Columns/ColumnsNumber.h>
#include <DataTypes/DataTypesNumber.h>
#include <Functions/FunctionFactory.h>
#include <Functions/IFunction.h>
#include <IO/WriteHelpers.h>
#include <Common/typeid_cast.h>
#include <constants.h>
#include <h3api.h>
namespace DB
{
namesp... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include "config.h"
#if USE_H3
#include <Columns/ColumnsNumber.h>
#include <DataTypes/DataTypesNumber.h>
#include <Functions/FunctionFactory.h>
#include <Functions/IFunction.h>
#include <IO/WriteHelpers.h>
#include <Common/typeid_cast.h>
#include <base/range.h>
#include <constants.h>
#include <h3api.h>... | fim | ClickHouse/ClickHouse | cpp |
#include "config.h"
#if USE_H3
#include <Columns/ColumnsNumber.h>
#include <DataTypes/DataTypesNumber.h>
#include <Functions/FunctionFactory.h>
#include <Functions/FunctionHelpers.h>
#include <Functions/IFunction.h>
#include <IO/WriteHelpers.h>
#include <Common/typeid_cast.h>
#include <base/range.h>
#include <consta... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <Functions/h3Common.h>
#if USE_H3
#include <Columns/ColumnsNumber.h>
#include <DataTypes/DataTypesNumber.h>
#include <Functions/FunctionFactory.h>
#include <Functions/IFunction.h>
#include <IO/WriteHelpers.h>
#include <Common/typeid_cast.h>
#include <base/range.h>
namespace DB
{
namespace Err... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <Functions/h3Common.h>
#if USE_H3
#include <Columns/ColumnsNumber.h>
#include <DataTypes/DataTypesNumber.h>
#include <Functions/FunctionFactory.h>
#include <Functions/IFunction.h>
#include <IO/WriteHelpers.h>
#include <Common/typeid_cast.h>
#include <base/range.h>
namespace DB
{
namespace Err... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>eImpl(const DataTypes & arguments) const override
{
const auto * arg = arguments[0].get();
if (!WhichDataType(arg).isUInt64())
throw Exception(
ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT,
"Illegal type {} of argument {} of function {}. Must be UInt... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <Functions/h3Common.h>
#if USE_H3
#include <Columns/ColumnsNumber.h>
#include <DataTypes/DataTypesNumber.h>
#include <Functions/FunctionFactory.h>
#include <Functions/FunctionHelpers.h>
#include <Functions/IFunction.h>
#in<|fim_suffix|>des::ILLEGAL_COLUMN,
"Illegal type {} of ar... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>tion documentation = {description, syntax, arguments, {}, returned_value, examples, introduced_in, category};
factory.registerFunction<FunctionH3GetDestinationIndexFromUnidirectionalEdge>(documentation);
}
}
#endif
<|fim_prefix|>#include <Functions/h3Common.h>
#if USE_H3
#include <Columns/ColumnAr... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|> result_offsets[row] = current_offset;
faces.clear();
}
return ColumnArray::create(std::move(result_column_data), std::move(result_column_offsets));
}
};
}
REGISTER_FUNCTION(H3GetFaces)
{
FunctionDocumentation::Description description = R"(
Returns [icosahed... | fim | ClickHouse/ClickHouse | cpp |
#include <Functions/h3Common.h>
#if USE_H3
#include <Columns/ColumnArray.h>
#include <Columns/ColumnsNumber.h>
#include <Columns/ColumnTuple.h>
#include <DataTypes/DataTypesNumber.h>
#include <DataTypes/DataTypeTuple.h>
#include <Functions/FunctionFactory.h>
#include <Functions/IFunction.h>
#include <Common/typeid_ca... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <Functions/h3Common.h>
#if USE_H3
#include <Columns/ColumnArray.h>
#include <Columns/ColumnsNumber.h>
#include <DataTypes/DataTypeArray.h>
#include <DataTypes/DataTypesNumber.h>
#include <Functions/FunctionFactory.h>
#include <Functions/IFunction.h>
#include <Common/typeid_cast.h>
#include <IO/... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include "config.h"
#if USE_H3
#include <Columns/ColumnArray.h>
#include <Columns/ColumnsNumber.h>
#include <DataTypes/DataTypeArray.h>
#include <DataTypes/DataTypesNumber.h>
#include <Functions/FunctionFactory.h>
#include <Functions/IFunction.h>
#include <Common/typeid_cast.h>
#include <Common/VectorWi... | fim | ClickHouse/ClickHouse | cpp |
#include "config.h"
#if USE_H3
#include <Columns/ColumnConst.h>
#include <DataTypes/DataTypeArray.h>
#include <DataTypes/DataTypesNumber.h>
#include <Functions/FunctionFactory.h>
#include <Functions/IFunction.h>
#include <Common/VectorWithMemoryTracking.h>
#include <h3api.h>
namespace DB
{
namespace
{
class Funct... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <Functions/h3Common.h>
#if USE_H3
#include <Columns/ColumnsNumber.h>
#include <DataTypes/DataTypesNumber.h>
#include <Functions/FunctionFactory.h>
#include <Functions/FunctionHelpers.h>
#include <Functions/IFunction.h>
#include <Common/typeid_cast.h>
#include <base/range.h>
namespace DB
{
nam... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <Functions/h3Common.h>
#if USE_H3
#include <Columns/ColumnArray.h>
#include <Columns/ColumnsNumber.h>
#include <DataTypes/DataTypeArray.h>
#include <DataTypes/DataTypesNumber.h>
#include <Functions/FunctionFactory.h>
#include <Functions/IFunction.h>
#include <Common/typeid_cast.h>
#include <IO/... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <Functions/h3Common.h>
#if USE_H3
#include <Columns/ColumnArray.h>
#include <Columns/ColumnsNumber.h>
#include <Columns/ColumnTuple.h>
#include <DataTypes/DataTypesNumber.h>
#include <DataTypes/DataTypeArray.h>
#include <DataTypes/DataTypeTuple.h>
#include <Functions/FunctionFactory.h>
#include... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <Functions/h3Common.h>
#if USE_H3
#include <Columns/ColumnArray.h>
#include <Columns/ColumnsNumber.h>
#include <Columns/ColumnTuple.h>
#include <DataTypes/DataTypesNumber.h>
#include <DataTypes/DataTypeArray.h>
#include <DataTypes/DataTypeTuple.h>
#include <Functions/FunctionFactory.h>
#include... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include "config.h"
#if USE_H3
#include <Columns/ColumnsNumber.h>
#include <DataTypes/DataTypesNumber.h>
#include <Functions/FunctionFactory.h>
#include <Functions/IFunction.h>
#include <IO/WriteHelpers.h>
#include <Common/typeid_cast.h>
#include <base/range.h>
#include <constants.h>
#include <h3api.h>... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>r getReturnTypeImpl(const DataTypes & arguments) const override
{
const auto * arg = arguments[0].get();
if (!WhichDataType(arg).isUInt8())
throw Exception(
ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT,
"Illegal type {} of argument {} of function {}.... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <Functions/h3Common.h>
#if USE_H3
#include <vector>
#include <Columns/ColumnArray.h>
#include <Columns/ColumnsNumber.h>
#include <DataTypes/DataTypeArray.h>
#include <DataTypes/DataTypesNumber.h>
#include <DataTypes/IDataType.h>
#include <Functions/FunctionFactory.h>
#include <Functions/IFuncti... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|> if (validator.validateCell(hindex_origin) && validator.validateCell(hindex_dest))
{
int are_neighbors = 0;
if (!areNeighborCells(hindex_origin, hindex_dest, &are_neighbors))
res = static_cast<UInt8>(are_neighbors);
}
... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>on index number.", {"UInt64"}}
};
FunctionDocumentation::ReturnedValue returned_value = {
"Returns `1` if the index represents a pentagonal cell, `0` otherwise.",
{"UInt8"}
};
FunctionDocumentation::Examples examples = {
{
"Check if H3 index is a pentago... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <Functions/h3Common.h>
#if USE_H3
#include <Columns/ColumnsNumber.h>
#include <DataTypes/DataTypesNumber.h>
#include <Functions/FunctionFactory.h>
#include <Functions/IFunction.h>
namespace DB
{
namespace ErrorCodes
{
extern const int ILLEGAL_TYPE_OF_ARGUMENT;
extern const int ILLEGAL_COLUMN;
... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|> )"
}
};
FunctionDocumentation::IntroducedIn introduced_in = {20, 1};
FunctionDocumentation::Category category = FunctionDocumentation::Category::Geo;
FunctionDocumentation documentation = {description, syntax, arguments, {}, returned_value, examples, introduced_in, category};
... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>s[1].column.get());
if (!col_end_index)
throw Exception(
ErrorCodes::ILLEGAL_COLUMN,
"Illegal type {} of argument {} of function {}. Must be UInt64.",
arguments[1].type->getName(),
2,
getName());
c... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>Hexagons(resolution)";
FunctionDocumentation::Arguments arguments = {
{"resolution", "Index resolution with range `[0, 15]`.", {"UInt8"}}
};
FunctionDocumentation::ReturnedValue returned_value = {
"Returns the number of unique H3 indices at the specified resolution.",
{... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>troducedIn introduced_in = {22, 6};
FunctionDocumentation::Category category = FunctionDocumentation::Category::Geo;
FunctionDocumentation documentation = {description, syntax, arguments, {}, returned_value, examples, introduced_in, category};
factory.registerFunction("h3PointDistKm", [](Conte... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include "config.h"
#if USE_H3
#include <Columns/ColumnArray.h>
#include <Functions/FunctionFactory.h>
#include <Functions/geometryConverters.h>
#include <Functions/IFunction.h>
#include <boost/geometry.hpp>
#include <boost/geometry/geometries/point_xy.hpp>
#include <DataTypes/DataTypeArray.h>
#inclu... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|> toString(resolution),
function_name,
toString(MAX_H3_RES));
}
/// H3 polygonToCellsExperimental expects uint32_t flags.
/// Fast path: UInt8 literals (0..3) and UInt32 columns; otherwise cast to Int64 and validate 0..3.
/// ... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <Functions/h3Common.h>
#if USE_H3
#include <Columns/ColumnArray.h>
#include <Columns/ColumnsNumber.h>
#include <DataTypes/DataTypeArray.h>
#include <DataTypes/DataTypesNumber.h>
#include <Functions/FunctionFactory.h>
#include <Functions/IFunction.h>
#include <Common/typeid_cast.h>
#include <IO/... | fim | ClickHouse/ClickHouse | cpp |
#include <Functions/h3Common.h>
#if USE_H3
#include <Columns/ColumnArray.h>
#include <Columns/ColumnsNumber.h>
#include <DataTypes/DataTypeArray.h>
#include <DataTypes/DataTypesNumber.h>
#include <Functions/FunctionFactory.h>
#include <Functions/IFunction.h>
#include <Common/typeid_cast.h>
#include <Common/VectorWith... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>βββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββ
)"
}
};
FunctionDocumentation::IntroducedIn introduced_in = {21, 11};
FunctionDocumentation::Category category = FunctionDocumentation... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>onDocumentation::Syntax syntax = "h3ToParent(index, resolution)";
FunctionDocumentation::Arguments arguments = {
{"index", "Child H3 index.", {"UInt64"}},
{"resolution", "Resolution of the parent index with range `[0, 15]`.", {"UInt8"}}
};
FunctionDocumentation::ReturnedValue r... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include "config.h"
#if USE_H3
#include <Columns/ColumnString.h>
#include <Columns/ColumnsNumber.h>
#include <DataTypes/DataTypeString.h>
#include <Functions/FunctionFactory.h>
#include <Functions/IFunction.h>
#include <Common/typeid_cast.h>
#include <h3api.h>
namespace DB
{
namespace ErrorCodes
{
... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>ocumentation::Description description = R"(
Determines if the provided [H3](#h3-index) is a valid unidirectional edge index.
)";
FunctionDocumentation::Syntax syntax = "h3UnidirectionalEdgeIsValid(index)";
FunctionDocumentation::Arguments arguments = {
{"index", "Hexagon index number."... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <Functions/h3Common.h>
#if USE_H3
#include <Columns/ColumnArray.h>
#include <Columns/ColumnsNumber.h>
#include <DataTypes/DataTypeArray.h>
#include <DataTypes/DataTypesNumber.h>
#include <DataTypes/IDataType.h>
#include <Functions/FunctionFactory.h>
#include <Functions/IFunction.h>
#include <Co... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <Functions/h3Common.h>
#if USE_H3
#include <array>
#include <cmath>
#include <Columns/ColumnArray.h>
#include <Columns/ColumnTuple.h>
#include <Columns/ColumnsNumber.h>
#include <DataTypes/DataTypeTuple.h>
#include <DataTypes/DataTypesNumber.h>
#include <Functions/FunctionFactory.h>
#include <F... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <Functions/hasAnyAllTokens.h>
#include <Columns/ColumnFixedString.h>
#include <Columns/ColumnNullable.h>
#include <Columns/ColumnString.h>
#include <Columns/ColumnNothing.h>
#include <Common/FunctionDocumentation.h>
#include <Common/VectorWithMemoryTracking.h>
#include <DataTypes/DataTypeLowCard... | fim | ClickHouse/ClickHouse | cpp |
#pragma once
#include <Functions/IFunction.h>
#include <Interpreters/Context_fwd.h>
#include <absl/container/flat_hash_map.h>
namespace DB
{
enum class HasAnyAllTokensMode : uint8_t
{
Any,
All
};
struct HasAnyTokensTraits
{
static constexpr String name = "hasAnyTokens";
static constexpr HasAnyAllTok... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Core/Sett<|fim_suffix|>y the query should be initialized at an earlier stage.
const StoragePtr & table = DatabaseCatalog::instance().getTable(
{database_name, table_name},
const_pointer_cast<Context>(getContext()));
auto table_metadata = table->getInMemory... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <Functions/hasPhrase.h>
#include <Columns/ColumnFixedString.h>
#include <Columns/ColumnNullable.h>
#include <Columns/ColumnString.h>
#include <DataTypes/DataTypeNullable.h>
#include <DataTypes/DataTypesNumber.h>
#include <Functions/FunctionFactory.h>
#include <Functions/FunctionHelpers.h>
#inclu... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>ysConstant() const override { return {1, 2}; }
DataTypePtr getReturnTypeImpl(const ColumnsWithTypeAndName & arguments) const override;
FunctionBasePtr buildImpl(const ColumnsWithTypeAndName & arguments, const DataTypePtr & return_type) const override;
};
}
<|fim_prefix|>#pragma once
#include <F... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Functions/FunctionFactory.h>
#include <Functions/HasSubsequenceImpl.h>
namespace DB
{
namespace
{
struct HasSubsequenceCaseSensitiveASCII
{
static constexpr bool is_utf8 = false;
static int toLowerIfNeed(int c) { return c; }
};
struct NameHasSubsequence
{
static constexpr auto n... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|> FunctionDocumentation::Examples examples =
{
{
"Usage example",
"SELECT hasSubsequenceCaseInsensitive('garbage', 'ARG');",
R"(
ββhasSubsequenceCaseInsensitive('garbage', 'ARG')ββ
β 1 β
βββββββββββββββββββββββββββββββββββββββ... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>ionDocumentation::ReturnedValue returned_value = {"Returns 1, if needle is a subsequence of haystack, 0 otherwise.", {"UInt8"}};
FunctionDocumentation::Examples examples =
{
{
"Usage example",
"SELECT hasSubsequenceCaseInsensitiveUTF8('ClickHouse - ΡΡΠΎΠ»Π±ΡΠΎΠ²Π°Ρ ΡΠΈΡΡΠ΅ΠΌΠ° ΡΠΏΡΠ°Π²Π»Π΅Π½ΠΈΡ... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <Functions/FunctionFactory.h>
#include <Functions/HasSubsequenceImpl.h>
namespace DB
{
namespace
{
struct HasSubsequenceCaseSensitiveUTF8
{
static constexpr bool is_utf8 = true;
static int toLowerIfNeed(int code_point) { return code_point; }
};
struct NameHasSubsequenceUTF8
{
sta... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>:Arguments arguments = {};
FunctionDocumentation::ReturnedValue returned_value = {"Returns whether Thread Fuzzer is effective.", {"UInt8"}};
FunctionDocumentation::Examples examples = {
{
"Check Thread Fuzzer status",
R"(
SELECT hasThreadFuzzer()
)",
R"(
ββhasTh... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>ntation::ReturnedValue returned_value_or_null = {"Returns `1` if the token is found, `0` otherwise, null if token is ill-formed.", {"Nullable(UInt8)"}};
FunctionDocumentation::Examples examples_or_null = {
{
"Usage example",
"SELECT hasTokenOrNull('apple banana cherry', 'ban ana');... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>stexpr auto name = "hasTokenCaseInsensitive";
};
struct NameHasTokenCaseInsensitiveOrNull
{
static constexpr auto name = "hasTokenCaseInsensitiveOrNull";
};
using FunctionHasTokenCaseInsensitive
= FunctionsStringSearch<HasTokenImpl<NameHasTokenCaseInsensitive, VolnitskyCaseInsensitive, false>>;
... | fim | ClickHouse/ClickHouse | cpp |
#include <Columns/ColumnArray.h>
#include <Columns/ColumnConst.h>
#include <Columns/ColumnFixedString.h>
#include <Columns/ColumnString.h>
#include <Common/FunctionDocumentation.h>
#include <Core/Settings.h>
#include <DataTypes/DataTypeArray.h>
#include <DataTypes/DataTypeString.h>
#include <Functions/FunctionFactory.h... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>tation::Category::Other,
});
}
}
<|fim_prefix|>#include <Functions/FunctionFactory.h>
#include <Functions/QueryTokenizationImpl.h>
#include <Parsers/IParser.h>
#include <Parsers/Lexer.h>
#include <Parsers/ParserQuery.h>
#include <Parsers/TokenIterator.h>
#include <Common/Exception.h>
namespace DB
{... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|> example: 'IP Address' `(0...FFFFFFFF)`
and 'Country code' `(0...FF)`. As with the encode function, this is limited to 8
numbers at most.
)";
FunctionDocumentation::Syntax syntax = R"(
hilbertDecode(tuple_size, code)
)";
FunctionDocumentation::Arguments arguments = {
{"tuple_size", "In... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <Functions/FunctionSpaceFillingCurve.h>
namespace DB
{
namespace HilbertDetails
{
template <UInt8 bit_step>
class HilbertDecodeLookupTable
{
public:
constexpr static UInt8 LOOKUP_TABLE[0] = {};
};
template <>
class HilbertDecodeLookupTable<1>
{
public:
constexpr static U... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|> expand(i, col0->getUInt(i), 0),
expand(i, col1->getUInt(i), 1));
}
return col_res;
}
throw Exception(ErrorCodes::TOO_MANY_ARGUMENTS_FOR_FUNCTION,
"Illegal number of UInt arguments of function {}: should b... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <Functions/FunctionSpaceFillingCurve.h>
namespace DB
{
namespace HilbertDetails
{
template <UInt8 bit_step>
class HilbertEncodeLookupTable
{
public:
constexpr static UInt8 LOOKUP_TABLE[0] = {};
};
template <>
class HilbertEncodeLookupTable<1>
{
public:
constexpr static U... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>>>;
}
REGISTER_FUNCTION(Hypot)
{
FunctionDocumentation::Description description = R"(
Returns the length of the hypotenuse of a right-angle triangle.
Hypot avoids problems that occur when squaring very large or very small numbers.
)";
FunctionDocumentation::Syntax syntax = "hypot(x, y)";
Fun... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>ypeAndName(
std::make_shared<DataTypeUInt32>()->createColumnConst(input_rows_count, static_cast<UInt32>(value)),
std::make_shared<DataTypeUInt32>(),
"");
ColumnsWithTypeAndName modulo_arguments = {bitand_result_with_type, modulo_column};
auto modulo_func... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <Functions/FunctionFactory.h>
#include <Columns/ColumnConst.h>
#include <Columns/ColumnString.h>
#include <Columns/IColumn.h>
#include <DataTypes/DataTypesNumber.h>
#include <DataTypes/DataTypesDecimal.h>
#include <DataTypes/DataTypeString.h>
#include <Functions/IFunction.h>
#include <Interpreter... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <Functions/identity.h>
#include <Functions/FunctionFactory.h>
#include <Common/FunctionDocumentation.h>
namespace DB
{
REGISTER_FUNCTION(Identity)
{
FunctionDocumentation::Description description = R"(
This function returns the argument you pass to it, which is useful for debugging and test... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|> bool isCompilableImpl(const DataTypes & /*types*/, const DataTypePtr & result_type) const override
{
return is_identity && canBeNativeType(result_type);
}
llvm::Value *
compileImpl(llvm::IRBuilderBase & /*builder*/, const ValuesWithType & arguments, const DataTypePtr & /*result... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>a)
{
FunctionDocumentation::Description description_encode = R"(
Returns the ASCII representation (ToASCII algorithm) of a domain name according to the [Internationalized Domain Names in Applications](https://en.wikipedia.org/wiki/Internationalized_domain_name#Internationalizing_Domain_Names_in_Applic... | fim | ClickHouse/ClickHouse | cpp |
#include <Functions/if.h>
#include <Columns/ColumnArray.h>
#include <Columns/ColumnConst.h>
#include <Columns/ColumnDecimal.h>
#include <Columns/ColumnFixedString.h>
#include <Columns/ColumnMap.h>
#include <Columns/ColumnNullable.h>
#include <Columns/ColumnString.h>
#include <Columns/ColumnTuple.h>
#include <Columns/Co... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>ctionOverloadResolver>;
FunctionOverloadResolverPtr createInternalFunctionIfOverloadResolver(bool use_variant_as_common_type);
}
<|fim_prefix|>#pragma once
#include <memory>
namespace DB
{
class IFunctionOverloadResolver;
using FunctionOverloadResolverPtr = std::sh<|fim_middle|>ared_ptr<IFun<|endoftex... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>ation documentation = {description, syntax, arguments, {}, returned_value, examples, introduced_in, category};
factory.registerFunction<FunctionIfNotFinite>(documentation);
}
}
<|fim_prefix|>#include <Functions/IFunction.h>
#include <Functions/FunctionHelpers.h>
#include <Functions/FunctionFactory.... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <Functions/IFunction.h>
#include <Functions/FunctionHelpers.h>
#include <Functions/FunctionFactory.h>
#include <DataTypes/DataTypesNumber.h>
#include <DataTypes/DataTypeNullable.h>
#include <DataTypes/getLeastSupertype.h>
#include <Core/ColumnNumbers.h>
#include <Core/Settings.h>
#include <Interp... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <Functions/IFunction.h>
#include <Functions/FunctionFactory.h>
#include <Columns/ColumnConst.h>
#include <DataTypes/DataTypesNumber.h>
namespace DB
{
namespace
{
/** ignore(...) is a function that takes any arguments, and always returns 0.
*/
class FunctionIgnore final : public IFunction
{
p... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|> FunctionDocumentation::Category category = FunctionDocumentation::Category::StringSearch;
FunctionDocumentation documentation = {description, syntax, arguments, {}, returned_value, examples, introduced_in, category};
factory.registerFunction<FunctionILike>(documentation);
}
}
<|fim_prefix|>#in... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|> if (!column_set)
throw Exception(ErrorCodes::ILLEGAL_COLUMN, "Second argument for function '{}' must be Set; found {}",
getName(), column_set_ptr->getName());
auto future_set = column_set->getData();
if (!future_set)
{
if (dry_run)
... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>int(key = 123);
```
ClickHouse does only one thing:
1. Uses the index to find which granules might contain key = 123 and returns all rows from those granules **without** filtering.
It returns all 8,192 rows, including rows where `key = 456`, `key = 789`, etc. (Everything that happened to be stored in t... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <Columns/ColumnConst.h>
#include <Functions/IFunction.h>
#include <Functions/FunctionFactory.h>
#include <DataTypes/DataTypesNumber.h>
#include <Interpreters/ActionsDAG.h>
namespace DB
{
/** The `indexHint` function takes any number of any argument<|fim_suffix|>
}
bool is... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Functions/FunctionFactory.h>
#include <Functions/FunctionStringToString.h>
#include <Common/StringUtils.h>
namespace DB
{
namespace
{
struct InitcapImpl
{
static void vector(
const ColumnString::Chars & data,
const ColumnString::Offsets & offsets,
ColumnString::Char... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <DataTypes/DataTypeString.h>
#include <Functions/FunctionStringToString.h>
#include <Functions/FunctionFactory.h>
#include <Poco/Unicode.h>
#include <Common/UTF8Helpers.h>
namespace DB
{
namespace ErrorCodes
{
extern const int BAD_ARGUMENTS;
}
namespace
{
struct InitcapUTF8Impl
{
stat... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|> the same results on different shards.
)";
FunctionDocumentation::Syntax syntax = "initialQueryID()";
FunctionDocumentation::Arguments arguments = {};
FunctionDocumentation::ReturnedValue returned_value = {"Returns the ID of the initial current query.", {"String"}};
FunctionDocumentation::... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>cution(const DataTypesWithConstInfo & /*arguments*/) const override { return false; }
ColumnPtr executeImpl(const ColumnsWithTypeAndName &, const DataTypePtr &, size_t input_rows_count) const override
{
return DataTypeDateTime().createColumnConst(
input_rows_count,
... | fim | ClickHouse/ClickHouse | cpp |
#include <Functions/IFunction.h>
#include <Functions/IFunctionAdaptors.h>
#include <Functions/FunctionFactory.h>
#include <Functions/FunctionHelpers.h>
#include <Columns/ColumnString.h>
#include <Columns/ColumnAggregateFunction.h>
#include <Columns/IColumn.h>
#include <DataTypes/DataTypeLowCardinality.h>
#include <Aggr... | fim | ClickHouse/ClickHouse | cpp |
#include <Functions/FunctionFactory.h>
#include <Functions/FunctionBinaryArithmetic.h>
#include <Functions/divideImpl.h>
namespace DB
{
namespace ErrorCodes
{
extern const int ILLEGAL_DIVISION;
}
namespace
{
/// Optimizations for integer division by a constant.
template <typename A, typename B>
struct DivideI... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <Functions/FunctionFactory.h>
#include <Functions/FunctionBinaryArithmetic.h>
namespace DB
{
template <typename A, typename B>
struct DivideIntegralOrZeroImpl
{
using ResultType = typename NumberTraits::ResultOfIntegerDivision<A, B>::Type;
static const constexpr bool allow_fixed_string... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <Functions/FunctionFactory.h>
#include <Functions/FunctionUnaryArithmetic.h>
#include <Common/FieldVisitorConvertToNumber.h>
#include <Common/intExp10.h>
namespace DB
{
namespace ErrorCodes
{
extern const int NOT_IMPLEMENTED;
extern const int BAD_ARGUMENTS;
}
namespace
{
template <type... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <Functions/FunctionFactory.h>
#include <Functions/FunctionUnaryArithmetic.h>
#include <Common/FieldVisitorConvertToNumber.h>
#include <Common/intExp2.h>
namespace DB
{
namespace ErrorCodes
{
extern const int LOGICAL_ERROR;
extern const int NOT_IMPLEMENTED;
extern const int BAD_ARGUME... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <Functions/IFunction.h>
#include <Functions/FunctionFactory.h>
#include <DataTypes/DataTypesNumber.h>
#inc<|fim_suffix|>Other;
FunctionDocumentation documentation = {description, syntax, arguments, {}, returned_value, examples, introduced_in, category};
factory.registerFunction<FunctionI... | fim | ClickHouse/ClickHouse | cpp |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.