text stringlengths 14 100k | source stringclasses 1
value | repo stringclasses 810
values | language stringclasses 13
values |
|---|---|---|---|
<|fim_prefix|>#pragma once
namespace DB
{
enum class UserDefinedSQLObjectType : uint8_t
{
<|fim_suffix|>Function
};
}
<|fim_middle|> <|endoftext|> | fim | ClickHouse/ClickHouse | c |
#include <Functions/UserDefined/UserDefinedSQLObjectsBackup.h>
#include <Backups/BackupEntriesCollector.h>
#include <Backups/BackupEntryFromMemory.h>
#include <Backups/IBackup.h>
#include <Backups/IBackupCoordination.h>
#include <Backups/IRestoreCoordination.h>
#include <Backups/RestorerFromBackup.h>
#include <Functio... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|> object_type);
}
<|fim_prefix|>#pragma once
#include <Parsers/IAST_fwd.h>
#include <base/types.h>
#include <vector>
#include <Common/VectorWithMemoryTracking.h>
namespace DB
{
class BackupEntriesCollector;
class RestorerFromBackup;
enum class UserDefinedSQLObjectType : uint8_t;
class IBackupEntry;
us... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>
void UserDefinedSQLObjectsDiskStorage::createDirectory()
{
std::error_code create_dir_error_code;
fs::create_directories(dir_path, create_dir_error_code);
if (!fs::exists(dir_path) || !fs::is_directory(dir_path) || create_dir_error_code)
throw Exception(ErrorCodes::DIRECTORY_DOESNT_... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <atomic>
#include <Functions/UserDefined/UserDefinedSQLObjectsStorageBase.h>
#include <Common/Logger_fwd.h>
#include <Interpreters/Context_fwd.h>
#include <Parsers/IAST_fwd.h>
namespace DB
{
/// Loads user-defined sql objects from a specified folder.
class UserDefinedSQLObjectsDi... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|> object_name_to_create_object_map[object_name] = create_object_query;
return stored;
}
bool UserDefinedSQLObjectsStorageBase::removeObject(
const ContextPtr & current_context,
UserDefinedSQLObjectType object_type,
const String & object_name,
bool throw_if_not_exis... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>_exists,
const Settings & settings) = 0;
virtual bool removeObjectImpl(
const ContextPtr & current_context,
UserDefinedSQLObjectType object_type,
const String & object_name,
bool throw_if_not_exists) = 0;
using WithContext::getContext;
std::unique_loc... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>
void UserDefinedSQLObjectsZooKeeperStorage::createRootNodes(const zkutil::ZooKeeperPtr & zookeeper)
{
zookeeper->createAncestors(zookeeper_path);
zookeeper->createIfNotExists(zookeeper_path, "");
}
bool UserDefinedSQLObjectsZooKeeperStorage::storeObjectImpl(
const ContextPtr & /*current_con... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>Keeper/ZooKeeperCachingGetter.h>
namespace DB
{
/// Loads user-defined sql objects from ZooKeeper.
class UserDefinedSQLObjectsZooKeeperStorage : public UserDefinedSQLObjectsStorageBase
{
public:
UserDefinedSQLObjectsZooKeeperStorage(const ContextPtr & global_context_, const String & zookeeper_path_... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Functions/UserDefined/UserDefinedWebAssembly.h>
#include <Functions/UserDefined/UserDefinedWebAssemblyScriptAbi.h>
#include <Functions/UserDefined/UserDefinedWebAssemblyTypeHelpers.h>
#include <ranges>
#include <base/hex.h>
#include <Columns/ColumnVector.h>
#include <DataTypes/DataTypesNumber... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>_,
const DataTypes & arguments_,
const DataTypePtr & result_type_,
WasmAbiVersion abi_type,
WebAssemblyFunctionSettings function_settings_,
bool is_deterministic_ = false);
const String & getInternalFunctionName() const { return function_name; }
const DataT... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>lic:
template <typename... Args>
explicit UserDefinedWebAssemblyFunctionAssemblyScript(Args &&... args)
: UserDefinedWebAssemblyFunction(std::forward<Args>(args)...)
{
checkSignature();
}
void checkFunction(const WasmFunctionDeclaration & expected) const
{
... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <Functions/UserDefined/UserDefinedWebAssembly.h>
namespace DB
{
/// Construct the AssemblyScript-flavoured ABI implementation for a WebAssembly UDF.
///
/// The resulting `UserDefinedWebAssemblyFunction` invokes the user's exported function once
/// per row, mapping ClickHouse `St... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Functions/UserDefined/UserDefinedWebAssemblyTypeHelpers.h>
namespace DB::WebAssembly
{
std::optio<|fim_suffix|>::F64)) return true;
return false;
}
}
<|fim_middle|>nal<WasmValKind> wasmKindForDataType(const IDataType * type)
{
std::optional<WasmValKind> kind;
tryExecuteForNumericT... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|> { using Type = uint32_t; };
template <> struct WasmStorageType<UInt16> { using Type = uint32_t; };
template <typename T>
constexpr WasmValKind wasmKindFor()
{
return WasmValTypeToKind<typename WasmStorageType<T>::Type>::value;
}
/// Iterate over the numeric types we accept on the WASM ABI boundary... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Functions/UserDefined/createUserDefinedSQLObjectsStorage.h>
#include <Functions/UserDefined/UserDefinedSQLObjectsDiskStorage.h>
#inclu<|fim_suffix|>DefinedSQLObjectsDiskStorage>(global_context, path);
}
}
<|fim_middle|>de <Functions/UserDefined/UserDefinedSQLObjectsZooKeeperStorage.h>
#include ... | fim | ClickHouse/ClickHouse | cpp |
#pragma once
#include <Interpreters/Context_fwd.h>
namespace DB
{
class IUserDefinedSQLObjectsStorage;
std::unique_ptr<IUserDefinedSQLObjectsStorage> createUserDefinedSQLObjectsStorage(const ContextMutablePtr & global_context);
}
<|endoftext|> | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#pragma once
#include <base/types.h>
// Contains types declarations and wrappers for GCC vector extension.
namespace DB::VectorExtension
{
using UInt64x2 = UInt64 __attribute__ ((vector_size (sizeof(UInt64) * 2)));
using UInt64x4 = UInt64 __attribute__ ((vector_size (sizeof(UInt64) * 4)));
using UInt64... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Functions/FunctionFactory.h>
#include <Functions/FunctionUnaryArithmetic.h>
#include <DataTypes/NumberTraits.h>
#include <Common/FieldVisitorConvertToNumber.h>
namespace DB
{
namespace ErrorCodes
{
extern const int LOGICAL_ERROR;
}
template <typename A>
struct AbsImpl
{
using ResultType =... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>ocumentation::Category::Mathematical;
FunctionDocumentation documentation = {description, syntax, arguments, {}, returned_value, examples, introduced_in, category};
factory.registerFunction<FunctionAcos>(documentation, FunctionFactory::Case::Insensitive);
}
}
<|fim_prefix|>#include <Functions/Fu... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|> factory.registerFunction<FunctionAcosh>(documentation);
}
}
<|fim_prefix|>#include <Functions/FunctionFactory.h>
#include <Functions/FunctionMathUnary.h>
namespace DB
{
namespace
{
struct AcoshName
{
static constexpr auto name = "acosh";
};
using FunctionAcosh = FunctionMa<|fim_middle|>thUnary<U... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <Functions/FunctionFactory.h>
#include <Functions/FunctionDateOrDateTimeAddInterval.h>
namespace DB
{
using FunctionAddDays = FunctionDateOrDateTimeAddInterval<AddDaysImpl>;
REGISTER_FUNCTION(AddDays)
{
FunctionDocumentation::Description description = R"(
Adds a specified number of days t... | fim | ClickHouse/ClickHouse | cpp |
#include <Functions/FunctionFactory.h>
#include <Functions/FunctionDateOrDateTimeAddInterval.h>
namespace DB
{
using FunctionAddHours = FunctionDateOrDateTimeAddInterval<AddHoursImpl>;
REGISTER_FUNCTION(AddHours)
{
FunctionDocumentation::Description description = R"(
Adds a specified number of hours to a date, ... | fim | ClickHouse/ClickHouse | cpp |
#include <Functions/FunctionFactory.h>
#include <Functions/FunctionDateOrDateTimeAddInterval.h>
namespace DB
{
using FunctionAddMicroseconds = FunctionDateOrDateTimeAddInterval<AddMicrosecondsImpl>;
REGISTER_FUNCTION(AddMicroseconds)
{
FunctionDocumentation::Description description = R"(
Adds a specified number... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>-01 00:00:01.000 β
βββββββββββββββββββββββββββββββββββ΄βββββββββββββββββββββββββββββββββββββββββ
)"},
{"Using alternative INTERVAL syntax", R"(
SELECT dateAdd('1998-06-16'::DateTime, INTERVAL 10 millisecond)
)",
R"(
ββplus(CAST('1β―second(10))ββ
β 1998-06-16 00:00:00.010 β
β... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <Functions/FunctionFactory.h>
#include <Functions/FunctionDateOrDateTimeAddInterval.h>
namespace DB
{
using FunctionAddMinutes = FunctionDateOrDateTimeAddInterval<AddMinutesImpl>;
REGISTER_FUNCTION(AddMinutes)
{
FunctionDocumentation::Description description = R"(
Adds a specified number ... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <Functions/FunctionFactory.h>
#include <Functions/FunctionDateOrDateTimeAddInterval.h>
namespace DB
{
using FunctionAddMonths = FunctionDateOrDateTimeAddInterval<AddMonthsImpl>;
REGISTER_FUNCTION(AddMonths)
{
FunctionDocumentation::Description descripti<|fim_suffix|>ription, syntax, argum... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>econds_with_date_time_stringββ
β 2024-01-01 00:00:00.000001000 β 2024-01-01 00:00:00.000001000 β
ββββββββββββββββββββββββββββββββββ΄ββββββββββββββββββββββββββββββββββββββββ
)"},
{"Using alternative INTERVAL syntax", R"(
SELECT dateAdd('1998-06-16'::DateTime, INTERVAL 1000 nanosecon... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>e('2024-01-01') AS date,
toDateTime('2024-01-01 00:00:00') AS date_time,
'2024-01-01 00:00:00' AS date_time_string
SELECT
addQuarters(date, 1) AS add_quarters_with_date,
addQuarters(date_time, 1) AS add_quarters_with_date_time,
addQuarters(date_time_string, 1) AS add_quarters_with_date... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>TERVAL syntax", R"(
SELECT dateAdd('1998-06-16'::Date, INTERVAL 10 second)
)",
R"(
ββdateAdd('1998-06-16'::Date, INTERVAL 10 second)ββ
β 1998-06-16 00:00:10 β
βββββββββββββββββββββββββββββββββββββββββββββββββββ
)"}
};
FunctionDocumentation::Intro... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <Functions/FunctionFactory.h>
#include <Functions/FunctionDateOrDateTimeAddInterval.h>
namespace DB
{
using FunctionAddWeeks = FunctionDateOrDateTimeAddInterval<AddWeeksImpl>;
REGISTER_FUNCTION(AddWeeks)
{
FunctionDocumentation::Description description = R"(
Adds a specified number of wee... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>ation = {description, syntax, arguments, {}, returned_value, examples, introduced_in, category};
factory.registerFunction<FunctionAddYears>(documentation);
}
}
<|fim_prefix|>#include <Functions/FunctionFactory.h>
#include <Functions/FunctionDateOrDateTimeAddInterval.h>
namespace DB
{
using Func... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#if (defined(__ELF__) && !defined(OS_FREEBSD)) || defined(OS_DARWIN)
#include <Common/Dwarf.h>
#include <Columns/ColumnString.h>
#include <DataTypes/DataTypeString.h>
#include <Functions/FunctionFactory.h>
#include <IO/WriteBufferFromArena.h>
#include <IO/WriteHelpers.h>
#include <Interpreters/Context.h>... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>
if (dwarf_it->second.findAddress(dwarf_addr, location, locationInfoMode, frames))
{
setResult(result, location, frames);
return result;
}
return {object->name};
}
return {};
}
ResultT implCached(uintp... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|> β
β 626293730 β ['./build_normal_debug/./src/Processors/Executors/ExecutionThreadContext.cpp:63'] β
β 626169525 β ['./build_nor... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#if defined(__ELF__) && !defined(OS_FREEBSD)
# define HAS_SYMBOL_INDEX 1
#elif defined(OS_DARWIN)
# define HAS_SYMBOL_INDEX 1
#endif
#if defined(HAS_SYMBOL_INDEX)
#include <Common/SymbolIndex.h>
#include <Columns/ColumnString.h>
#include <Columns/ColumnsNumber.h>
#include <DataTypes/DataTypeString.... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|> |
+------------------------+
1 row in set (0.00 sec)
SELECT aes_decrypt_mysql('aes-256-ofb', unhex('24E9E4966469'), '123456789101213141516171819202122', 'iviviviviviviviv123456') AS plaintext
)",
R"(
ββplaintextββ
β Secret β
βββββββββββββ
)"
}
};
FunctionDocum... | fim | ClickHouse/ClickHouse | cpp |
#include "config.h"
#if USE_SSL
#include <Functions/FunctionFactory.h>
#include <Functions/FunctionsAES.h>
namespace DB
{
namespace
{
struct EncryptMySQLModeImpl
{
static constexpr auto name = "aes_encrypt_mysql";
static constexpr auto compatibility_mode = OpenSSLDetails::CompatibilityMode::MySQL;
};
}
RE... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>categories_arg_index].column);
auto categories = (*col_categories.getDataColumnPtr())[0].safeGet<Array>();
for (const auto & category : categories)
enum_array->add(category.safeGet<String>());
Poco::JSON::Object::Ptr category_prop = new Poco::JSON::Object;
cate... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>bed>(FunctionDocumentation{
.description = R"(
Generates an embedding vector for the given text using the configured AI provider.
The function sends the text to the configured embedding endpoint and returns the resulting vector as `Array(Float32)`.
Within a single block of rows, inputs are groupe... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|> /// "name": "extraction",
/// "strict": true,
/// "schema": {
/// "type": "object",
/// "properties": { "result": {"type": ["string", "null"]} },
/// "required": ["result"],
/// "additionalProperties": false
/// }
/... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <Functions/FunctionBaseAI.h>
#include <Functions/FunctionFactory.h>
#include <Functions/FunctionHelpers.h>
#include <Columns/ColumnString.h>
#include <Columns/ColumnConst.h>
#include <DataTypes/DataTypeString.h>
#include <DataTypes/IDataType.h>
#include <Common/Exception.h>
namespace DB
{
names... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>equest failed and `ai_function_throw_on_error` is disabled.", {"String"}},
.examples = {
{"Translate to French", "SELECT aiTranslate('ai_credentials', 'Hello, world!', 'French')", "Bonjour le monde!"},
{"Translate to Japanese with style instructions", "SELECT aiTranslate('a... | fim | ClickHouse/ClickHouse | cpp |
#include <Functions/FunctionTokens.h>
#include <Functions/FunctionFactory.h>
#include <Common/StringUtils.h>
namespace DB
{
/** Functions that split strings into an array of strings or vice versa.
*
* alphaTokens(s[, max_substrings]) - select from the string subsequence `[a-zA-Z]+`.
*/
namespace
{
... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>s::ILLEGAL_COLUMN, "Illegal column {} of argument of function {}", arguments[0].column->getName(), getName());
}
};
}
REGISTER_FUNCTION(AppendTrailingCharIfAbsent)
{
FunctionDocumentation::Description description = R"(
Appends character `c` to string `s` if `s` is non-empty and does not end with... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|> * FunctionArea<SphericalPoint>::name = "areaSpherical";
REGISTER_FUNCTION(Area)
{
{
FunctionDocumentation::Description description = R"(
Returns the area of the object.
)";
FunctionDocumentation::Syntax syntax = "areaCartesian(object)";
FunctionDocumentation::Argu... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>
ErrorCodes::SIZES_OF_ARRAYS_DONT_MATCH,
"Arrays passed to {} must have equal size. Argument {} has size {} which differs with the size of another argument, {}",
getName(),
i + 1,
... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Columns/ColumnArray.h>
#include <Columns/ColumnFunction.h>
#include <Columns/ColumnMap.h>
#include <Columns/ColumnTuple.h>
#include <Columns/ColumnConst.h>
#include <DataTypes/DataTypeArray.h>
#include <DataTypes/DataTypeFunction.h>
#include <DataTypes/DataTypeMap.h>
#include <DataTypes/DataTyp... | fim | ClickHouse/ClickHouse | cpp |
#include <Columns/ColumnArray.h>
#include <Columns/ColumnConst.h>
#include <Columns/ColumnDecimal.h>
#include <Columns/ColumnFixedString.h>
#include <Columns/ColumnNullable.h>
#include <Columns/ColumnString.h>
#include <Columns/ColumnTuple.h>
#include <Core/Settings.h>
#include <DataTypes/DataTypeArray.h>
#include <Dat... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <Columns/ColumnArray.h>
#include <Columns/ColumnVector.h>
#include <DataTypes/DataTypeArray.h>
#include <DataTypes/DataTypesNumber.h>
#include <Functions/FunctionFactory.h>
#include <Functions/FunctionHelpers.h>
namespace DB
{
namespace ErrorCodes
{
extern const int BAD_ARGUMENTS;
extern const... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <base/defines.h>
#include <Columns/IColumn.h>
#include <Columns/ColumnConst.h>
#include <Columns/ColumnArray.h>
#include <Columns/ColumnDecimal.h>
#include <Core/callOnTypeIndex.h>
#include <DataTypes/DataTypeDate.h>
#include <DataTypes/DataTypesDecimal.h>
#include <DataTypes/DataTypesNumber.h... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <Functions/array/arrayAll.h>
#include <Functions/FunctionFactory.h>
namespace DB
{
namespace ErrorCodes
{
extern const int ILLEGAL_COLUMN;
}
ColumnPtr ArrayAllImpl::execute(const ColumnArray & array, C<|fim_suffix|>yAll(x, y -> x=y, [1, 2, 3], [1, 1, 1])", "0"}
};
FunctionDocumenta... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>All>;
}
<|fim_prefix|>#pragma once
#include <DataTypes/DataTypesNumber.h>
#include <Functions/array/FunctionArrayMapped.h>
namespace DB
{
/**<|fim_middle|> arrayAll(x1,...,xn -> expression, array1,...,arrayn) - is the expression true for all elements of the array.
* An overload of the form f(array) ... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Columns/ColumnArray.h>
#include <Columns/ColumnDecimal.h>
#include <Columns/ColumnNothing.h>
#include <Columns/ColumnVector.h>
#include <Columns/ColumnsNumber.h>
#include <Columns/IColumn.h>
#include <Core/DecimalFunctions.h>
#include <DataTypes/DataTypeArray.h>
#include <DataTypes/DataTypeNothi... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <Columns/ColumnDecimal.h>
#include <Columns/ColumnsNumber.h>
#include <Common/HashTable/HashTable.h>
#include <DataTypes/DataTypesNumber.h>
#include <Functions/FunctionFactory.h>
#include <Functions/array/FunctionArrayMapped.h>
namespace DB
{
/// arrayCompact(['a', 'a', 'b', 'b', 'a']) = ['a... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <Functions/array/arrayConcat.h>
#include <Functions/FunctionFactory.h>
#include <Functions/GatherUtils/GatherUtils.h>
#include <DataTypes/DataTypeArray.h>
#include <DataTypes/getLeastSupertype.h>
#include <Interpreters/castColumn.h>
#include <Columns/ColumnArray.h>
#include <Columns/ColumnConst.h... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <<|fim_suffix|>>(); }
String getName() const override { return name; }
bool isVariadic() const override { return true; }
size_t getNumberOfArguments() const override { return 0; }
bool isSuitableForShortCircuitArgumentsExecution(const DataTypesWithConstInfo & /*arg... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Columns/ColumnsNumber.h>
#include <DataTypes/DataTypesNumber.h>
#include <Functions/FunctionFactory.h>
#include <Functions/array/FunctionArrayMapped.h>
namespace DB
{
namespace ErrorCodes
{
extern const int ILLEGAL_COLUMN;
}
/** arrayCount(x1,...,xn -> expression, array1,...,arrayn) - fo... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <Columns/ColumnDecimal.h>
#include <Columns/ColumnsNumber.h>
#include <DataTypes/DataTypesDecimal.h>
#include <DataTypes/DataTypesNumber.h>
#include <Functions/FunctionFactory.h>
#include <Functions/array/FunctionArrayMapped.h>
namespace DB
{
namespace ErrorCodes
{
extern const int ILLEGAL... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>e_shared<DataTypeArray>(std::make_shared<DataTypeInt256>());
UNREACHABLE();
}
if (which.isFloat())
return std::make_shared<DataTypeArray>(std::make_shared<DataTypeFloat64>());
if (which.isDecimal())
{
UInt32 scale = getDecimalScale(*exp... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <Columns/ColumnDecimal.h>
#include <Columns/ColumnsNumber.h>
#include <DataTypes/DataTypesDecimal.h>
#include <DataTypes/DataTypesNumber.h>
#include <Functions/FunctionFactory.h>
#include <Functions/array/FunctionArrayMapped.h>
namespace DB
{
namespace ErrorCodes
{
extern const int ILLEGA... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>);
}
/// const-left mirror of executeDistanceMixedImpl. Same MULTITARGET strategy:
/// common pairs get x86_64_v3/v4 instances, other pairs reuse the baseline.
MULTITARGET_FUNCTION_X86_V4_V3(
MULTITARGET_FUNCTION_HEADER(
template <typename Kernel, typename ResultType, typename LeftType, typename Righ... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <Functions/IFunction.h>
#include <Functions/FunctionFactory.h>
#include <Functions/FunctionHelpers.h>
#include <DataTypes/DataTypeArray.h>
#include <DataTypes/DataTypeNullable.h>
#include <Columns/ColumnArray.h>
#include <Columns/ColumnNullable.h>
#include <Columns/ColumnString.h>
#include <Commo... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <Columns/ColumnArray.h>
#include <Columns/ColumnVector.h>
#include <DataTypes/DataTypeArray.h>
#include <DataTypes/DataTypesNumber.h>
#include <DataTypes/NumberTraits.h>
#include <Functions/FunctionFactory.h>
#include <Functions/FunctionHelpers.h>
#include <Functions/IFunction.h>
#include <Functi... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>rue>(
col_nested->getChars(),
col_array->getOffsets(),
col_nested->getOffsets(),
-(UInt64(index.safeGet<Int64>()) + 1),
col_res->getChars(),
col_res->getOffsets(),
builder);
}
else
throw Exception(ErrorCode... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>ββ΄ββββββ
)"}};
FunctionDocumentation::IntroducedIn introduced_in = {1, 1};
FunctionDocumentation::Category category = FunctionDocumentation::Category::Array;
FunctionDocumentation documentation = {description, syntax, arguments, {}, returned_value, examples, introduced_in, category};
... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <Functions/array/arrayEnumerateExtended.h>
#include <Functions/FunctionFactory.h>
namespace DB
{
class FunctionArrayEnumerateDense final : public FunctionArrayEnumerateExtended<FunctionArrayEnumerateDense>
{
using Base = FunctionArrayEnumerateExtended<Functi<|fim_suffix|>;
FunctionDoc... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>
<|fim_prefix|>#include <Functions/FunctionFactory.h>
#include <Functions/array/arrayEnumerateRanked.h>
namespace DB
{
class FunctionArrayEnumerateDenseRanked final : public FunctionArrayEnumerateRankedExtended<FunctionArrayEnumerateDenseRanked>
{
using Base = FunctionArrayEnumerateRankedExtended<F... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|><Derived>::executeNumber(
const ColumnArray::Offsets & offsets, const IColumn & data, const NullMap * null_map, ColumnUInt32::Container & res_values) const
{
const auto * nested = checkAndGetColumn<ColumnVector<T>>(&data);
if (!nested)
return false;
executeMethod<MethodOneNumber<T... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Columns/ColumnConst.h>
#include <Functions/array/arrayEnumerateRanked.h>
#include <Common/SipHash.h>
#include <Common/assert_cast.h>
namespace DB
{
namespace ErrorCodes
{
extern const int BAD_ARGUMENTS;
}
UInt128 hash128depths(const VectorWithMemoryTracking<size_t> & indices, const Colum... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <Columns/ColumnArray.h>
#include <Columns/ColumnsNumber.h>
#include <DataTypes/DataTypeArray.h>
#include <DataTypes/DataTypesNumber.h>
#include <DataTypes/getLeastSupertype.h>
#include <Functions/FunctionHelpers.h>
#include <Functions/IFunction.h>
#include <Interpreters/Context_fwd.h... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Functions/array/arrayEnumerateExtended.h>
#include <Functions/FunctionFactory.h>
namespace DB
{
class FunctionArrayEnumerateUniq final : public FunctionArrayEnumerateExtended<FunctionArrayEnumerateUniq>
{
using Base = FunctionArrayEnumerateExtended<FunctionArrayEnumerateUniq>;
public:
... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|> 2, 3], [2, 2, 1], [3]], 2);
)", "[[1, 1, 1], [2, 3, 2], [2]]"
},
{"Example 4", R"(
-- Changing clear_depth=2, results in elements being enumerated separately for each row.
SELECT arrayEnumerateUniqRanked(2,[[1, 2, 3],[2, 2, 1],[3]], 2);
)", "[[1, 1, 1], [1, 2, 1], [1]]"},
};
F... | fim | ClickHouse/ClickHouse | cpp |
#include <base/types.h>
#include <Columns/ColumnArray.h>
#include <Columns/ColumnFixedString.h>
#include <Columns/ColumnNullable.h>
#include <Columns/ColumnsNumber.h>
#include <Columns/ColumnString.h>
#include <Columns/ColumnVector.h>
#include <Columns/IColumn.h>
#include <Common/assert_cast.h>
#include <Common/Except... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|> least one element, `0` otherwise", {"UInt8"}};
FunctionDocumentation::Examples examples = {{"Usage example", "SELECT arrayExists(x, y -> x=y, [1, 2, 3], [0, 0, 0])", "0"}};
FunctionDocumentation::IntroducedIn introduced_in = {1, 1};
FunctionDocumentation::Category category = FunctionDocumenta... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>tic ColumnPtr execute(const ColumnArray & array, ColumnPtr mapped);
};
struct NameArrayExists { static constexpr auto name = "arrayExists"; };
using FunctionArrayExists = FunctionArrayMapped<ArrayExistsImpl, NameArrayExists>;
}
<|fim_prefix|>#pragma once
#include <DataTypes/DataTypesNumber.h>
#include ... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>ND x < z, [5, 3, 6, 2], [4, 7, 1, 3], [10, 2, 8, 5]) AS res;", "[5, 6, 6, 2]"}
};
FunctionDocumentation::IntroducedIn introduced_in_reverse = {20, 1};
FunctionDocumentation::Category category_reverse = FunctionDocumentation::Category::Array;
FunctionDocumentation documentation_reverse = {d... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>:Array;
FunctionDocumentation documentation = {description, syntax, arguments, {}, returned_value, examples, introduced_in, category};
factory.registerFunction<FunctionArrayFilter>(documentation);
}
}
<|fim_prefix|>#include <Functions/array/arrayFilter.h>
#include <Functions/FunctionFactory.h>
... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <Functions/array/FunctionArrayMapped.h>
namespace DB
{
/** arrayFilter(x -> predicate, array) - leave in the array only the elements for which the expression is true.
*/
struct ArrayFilterImpl
{
static bool needBoolean() { return true; }
static bool needExpression() { r... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>ctionDocumentation documentation_last_null = {description_last_null, syntax_last_null, arguments_last_null, {}, returned_value_last_null, examples_last_null, introduced_in_last_null, category_last_null};
factory.registerFunction<FunctionArrayLastOrNull>(documentation_last_null);
}
}
<|fim_prefix|>#... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>y(T)`](/sql-reference/data-types/array)."},
{"[, cond1_arr, ... , condN_arr]", "Optional. N condition arrays providing additional arguments to the lambda function. [`Array(T)`](/sql-reference/data-types/array)."}
};
FunctionDocumentation::ReturnedValue returned_value_first = {"Returns the ... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <Functions/IFunction.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_TYPE_OF_ARGUMENT;
extern const int ILLEGAL_COLUMN;
... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>c.2, acc.2 + acc.1),range(number),(1::Int64, 0::Int64)).1 AS fibonacci FROM numbers(1,10);)",
R"(
ββfibonacciββ
β 0 β
β 1 β
β 1 β
β 2 β
β 3 β
β 5 β
β 8 β
β 13 β
β 21 β
β 34 β
βββββββββββββ
)"
},
{
"Example using multiple arrays",... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>lumn = nullable->getNullMapColumnPtr();
null_map.type = std::make_shared<DataTypeUInt8>();
}
else
{
auto & data = source_columns[0];
data = arguments[0];
}
if (arg_nullable)
{
auto & arg = source_columns[1];
... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Functions/IFunction.h>
#include <Functions/FunctionFactory.h>
#include <Functions/FunctionHelpers.h>
#include <DataTypes/DataTypeArray.h>
#include <DataTypes/DataTypeNothing.h>
#include <DataTypes/DataTypesNumber.h>
#include <DataTypes/DataTypesDecimal.h>
#include <DataTypes/DataTypeDate.h>
#inc... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <Columns/ColumnArray.h>
#include <Columns/IColumn.h>
#include <DataTypes/DataTypeArray.h>
#include <DataTypes/DataTypesNumber.h>
#include <DataTypes/IDataType.h>
#include <Functions/FunctionFactory.h>
#include <Functions/FunctionHelpers.h>
#include <DataTypes/DataTypeNothing.h>
#include <Core/Col... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>yJoin(arr)";
FunctionDocumentation::Arguments arguments = {
{"arr", "An array to unfold.", {"Array(T)"}}
};
FunctionDocumentation::ReturnedValue returned_value = {"Returns a set of rows unfolded from `arr`."};
FunctionDocumentation::Examples examples = {
{"Basic usage", R"(... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <Columns/ColumnArray.h>
#include <Columns/ColumnDecimal.h>
#include <Columns/ColumnFixedString.h>
#include <Columns/ColumnNullable.h>
#include <Columns/ColumnString.h>
#include <Columns/ColumnTuple.h>
#include <Common/levenshteinDistance.h>
#include <Common/PODArray.h>
#include <Common/iota.h>
#i... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <Functions/array/arrayMap.h>
#include <Functions/FunctionFactory.h>
namespace DB
{
REGISTER_FUNCTION(ArrayMap)
{
FunctionDocumentation::Description description = R"(
Returns an array obtained <|fim_suffix|>duced_in = {1, 1};
FunctionDocumentation::Category category = FunctionDocumentati... | fim | ClickHouse/ClickHouse | cpp |
#pragma once
#include <Functions/array/FunctionArrayMapped.h>
namespace DB
{
/** arrayMap(x1, ..., xn -> expression, array1, ..., arrayn) - apply the expression to each element of the array (or set of parallel arrays).
*/
struct ArrayMapImpl
{
/// true if the expression (for an overload of f(expression, arrays... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>sWithTypeAndName & arguments) const override
{
const auto * array_type = checkAndGetDataType<DataTypeArray>(arguments[0].type.get());
if (!array_type)
throw Exception(ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT, "Argument of function {} must be array.", getName());
switch... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>to & type_predicted, const auto & type_labels)
{
using TypePredicted = typename std::decay_t<decltype(type_predicted)>::FieldType;
const ColumnVector<TypePredicted> * array_predicted_data = checkAndGetColumn<ColumnVector<TypeP... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|> false; }
private:
bool pop_front;
const char * name;
};
}
<|fim_prefix|>#pragma once
#include <Functions/IFunction.h>
#include <Functions/GatherUtils/GatherUtils.h>
#include <DataTypes/DataTypeArray.h>
#include <Columns/ColumnArray.h>
#include <Columns/ColumnCons<|fim_middle|>t.h>
#include <Com... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>mentation = {description, syntax, arguments, {}, returned_value, examples, introduced_in, category};
factory.registerFunction<FunctionArrayPopBack>(documentation);
}
}
<|fim_prefix|>#include <Functions/array/arrayPop.h>
#include <Functions/FunctionFactory.h>
namespace DB
{
class FunctionArrayPopB... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <Functions/array/arrayPop.h>
#include <Functions/FunctionFactory.h>
namespace DB
{
class FunctionArrayPopFront final : public FunctionArrayPop
{
public:
static constexpr auto name = "arrayPopFront";
static FunctionPtr create(ContextPtr) { return std::make_shared<FunctionArrayPopFront>(... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>(!arguments[1].type->equals(*return_nested_type))
appended_column = castColumn(arguments[1], return_nested_type);
std::unique_ptr<GatherUtils::IArraySource> array_source;
std::unique_ptr<GatherUtils::IValueSource> value_source;
size_t size = array_column->size();
... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Functions/array/arrayPush.h>
#include <Functions/FunctionFactory.h>
namespace DB
{
class FunctionArrayPushBack final : public FunctionArrayPush
{
public:
static constexpr auto name = "arrayPushBack";
static FunctionPtr create(ContextPtr) { return std::make_shared<FunctionArrayPushBack... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <Functions/array/arrayPush.h>
#include <Functions/FunctionFactory.h>
namespace DB
{
class FunctionArrayPushFront final : public FunctionArrayPush
{
public:
static constexpr auto name = "arrayPushFront";
static FunctionPtr create(ContextPtr) { return std::make_shared<FunctionArrayPushF... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <Columns/ColumnArray.h>
#include <Columns/ColumnsNumber.h>
#include <Common/iota.h>
#include <Common/randomSeed.h>
#include <Common/VectorWithMemoryTracking.h>
#include <DataTypes/DataTypeArray.h>
#include <Functions/FunctionFactory.h>
#include <Functions/FunctionHelpers.h>
#include <Functions/IF... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>does. Resolve the aggregate function with the original types
/// so it matches what executeImpl will receive (also Nullable, since the IFunction also
/// has useDefaultImplementationForNulls() = false).
auto aggregate_function = resolveAggregateFunction(arguments);
auto fun... | fim | ClickHouse/ClickHouse | cpp |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.