text stringlengths 14 100k | source stringclasses 1
value | repo stringclasses 810
values | language stringclasses 13
values |
|---|---|---|---|
<|fim_suffix|>rAllValueSumImpl
{
public:
static constexpr auto name = "numericIndexedVectorAllValueSum";
template <typename VectorImpl>
static ToType apply(const AggregateFunctionGroupNumericIndexedVectorData<VectorImpl> & lhs)
{
return lhs.vector.getAllValueSum();
}
};
using FunctionNumeri... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|> input_rows_count) const
{
return executeResolveIndexType(index_type, value_type, parameters, arguments, result_type, input_rows_count);
}
ColumnPtr executeResolveIndexType(
const DataTypePtr index_type,
const DataTypePtr value_type,
const Array & parameters,
... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <DataTypes/DataTypeDate.h>
#include <DataTypes/DataTypeDate32.h>
#include <DataTypes/DataTypeDateTime.h>
#include <DataTypes/DataTypeDateTime64.h>
#include <Functions/FunctionFactory.h>
namespace DB
{
namespace ErrorCodes
{
extern const int ILLEGAL_TYPE_OF_ARGUMENT;
}
namespace
{
template ... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>tor generator3;
UInt64 rand_seed = randomSeed();
seed(generator0, rand_seed, random_numbers[0] + reinterpret_cast<intptr_t>(output));
seed(generator1, rand_seed, random_numbers[1] + reinterpret_cast<intptr_t>(output));
seed(generator2, rand_seed, random_numbers[2] + reinterpret_cast<intp... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <Common/TargetSpecific.h>
#include <DataTypes/DataTypesNumber.h>
#include <Columns/ColumnVector.h>
#include <Functions/IFunction.h>
#include <Functions/PerformanceAdaptors.h>
namespace DB
{
namespace ErrorCodes
{
extern const int NUMBER_OF_ARGUMENTS_DOESNT_MATCH;
}
/** Pseud... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>rr", "Array of elements to round `num` down to.", {"Array((U)Int*)", "Array(Float*)"}}
};
FunctionDocumentation::ReturnedValue returned_value = {"Returns a number rounded down to an element in `arr`. If the value is less than the lowest bound, the lowest bound is returned.", {"(U)Int*", "F... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>e;
}
}
if (*it < value)
{
while (it != end && *it <= value)
++it;
if (it != begin)
--it;
}
else
{
... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>ost {}", max_string_size);
/// Shortcuts:
if (haystack_size == 0)
return needle_size;
if (needle_size == 0)
return haystack_size;
if (haystack_size == needle_size && memcmp(haystack, needle, haystack_size) == 0)
return 0;
///... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>ramMinHash_description, ngramMinHash_syntax, ngramMinHash_arguments, {}, ngramMinHash_returned_value, ngramMinHash_examples, ngramMinHash_introduced_in, ngramMinHash_category};
factory.registerFunction<FunctionNgramMinHash>(ngramMinHash_documentation);
FunctionDocumentation::Description ngramMinH... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <Columns/ColumnString.h>
#include <Columns/ColumnTuple.h>
#include <Columns/ColumnVector.h>
#include <DataTypes/DataTypeFactory.h>
#include <DataTypes/DataTypeTuple.h>
#include <DataTypes/DataTypesNumber.h>
#include <DataTypes/DataTypeString.h>
#include <Functions/FunctionHelpers.h>... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Columns/ColumnFixedString.h>
#include <Columns/ColumnString.h>
#include <Columns/ColumnsNumber.h>
#include <DataTypes/DataTypeFixedString.h>
#include <Functions/FunctionFactory.h>
#include <Functions/FunctionHelpers.h>
#include <Functions/IFunction.h>
#include <base/IPv4andIPv6.h>
#include "con... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>f (column_start_pos)
{
if (const ColumnConst * const_column_start_pos = typeid_cast<const ColumnConst *>(&*column_start_pos))
{
is_col_start_pos_const = true;
column_start_position_arg = const_column_st... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#pragma once
#include <Columns/ColumnConst.h>
#include <Columns/ColumnString.h>
#include <Columns/ColumnVector.h>
#include <DataTypes/DataTypeString.h>
#include <Functions/FunctionHelpers.h>
#include <Functions/IFunction.h>
#include <Interpreters/Context_fwd.h>
namespace DB
{
/** Applies regexp re2 and... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>8 = FunctionsStringSimilarity<NgramDistanceImpl<3, UInt32, true, true, true>, NameNgramDistanceUTF8CaseInsensitive>;
using FunctionNgramSearch = FunctionsStringSimilarity<NgramDistanceImpl<4, UInt8, false, false, false>, NameNgramSearch>;
using FunctionNgramSearchCaseInsensitive = FunctionsStringSimilari... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <Columns/ColumnConst.h>
#include <Columns/ColumnString.h>
#include <Columns/ColumnVector.h>
#include <Functions/FunctionHelpers.h>
#include <Functions/IFunction.h>
#include <Interpreters/Context_fwd.h>
namespace DB
{
/** Calculate similarity metrics:
*
* ngramDistance(haystack,... | fim | ClickHouse/ClickHouse | c |
#pragma once
#include <Columns/ColumnString.h>
#include <Columns/ColumnVector.h>
#include <Core/Settings.h>
#include <DataTypes/DataTypesNumber.h>
#include <Functions/FunctionHelpers.h>
#include <Functions/IFunction.h>
#include <Functions/FunctionFactory.h>
#include <Interpreters/Context.h>
namespace DB
{
namespace S... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <numeric>
#include <Columns/ColumnsNumber.h>
#include <Columns/ColumnsDateTime.h>
#include <Columns/ColumnTuple.h>
#include <Columns/IColumn.h>
#include <Core/Types.h>
#include <DataTypes/DataTypeDate.h>
#include <DataTypes/DataTypeDateTime.h>
#include <DataTypes/DataTypeNullable.h>
#include <Da... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>\
return val - (val % delta); \
} \
return t - (t % (delta * DecimalUtils::scaleMultiplier<DateTime64>(scale - (DEF_SCALE)))) ; \
} \
};
TRANSFORM_SUBSECONDS(Millisecond, 3)
TRANSFORM_SUBSECONDS(Microsecond, 6)
TRANSFORM_SUBSECONDS(Nanosecond... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>ysis",
R"(
SELECT
detectTonality('Шарик - хороший пёс'),
detectTonality('Шарик - пёс'),
detectTonality('Шарик - плохой пёс')
)",
"0.44445, 0, -0.3"
}
};
FunctionDocumentation::IntroducedIn introduced_in = {22, 2};
FunctionDocumentation::Category category... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <DataTypes/DataTypeNothing.h>
#include <DataTypes/DataTypesNumber.h>
#include <Functions/FunctionConstantBase.h>
#include <Functions/FunctionFactory.h>
#include <Interpreters/Context.h>
#include <Interpreters/MergeTreeTransaction.h>
#include <Interpreters/MergeTreeTransaction/VersionMetadata.h>
#... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <DataTypes/DataTypeFixedString.h>
#include <Columns/ColumnsNumber.h>
#include <Columns/ColumnString.h>
#include <Common/Volnitsky.h>
#include <Functions/IFunction.h>
#include <Functions/FunctionHelpers.h>
#include <IO/ReadBufferFromMemory.h>
#include <IO/ReadHelpers.h>
/** Functio... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|> "Intermediate result overflow (signed a = {}, signed b = {}, min = {}, max = {})",
a_s, b_s, min, max);
}
return Impl::applyImpl(a, b);
}
#if USE_EMBEDDED_COMPILER
static constexpr bool compilable = false; /// exceptions (and a non... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#pragma once
#include <base/arithmeticOverflow.h>
#include <base/types.h>
#include <Common/FieldVisitorConvertToNumber.h>
#include <Common/VectorWithMemoryTracking.h>
#include <Functions/GatherUtils/Sources.h>
#include <Functions/GatherUtils/Sinks.h>
#include <Core/AccurateComparison.h>
#include <Functio... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>nkVisitorImpl : public VisitorImpl<Derived, ArraySinkVisitor>
{
protected:
~ArraySinkVisitorImpl() = default;
};
}
<|fim_prefix|>#pragma once
#include <Common/Visitor.h>
#include <base/TypeLists.h>
namespace DB::GatherUtils
{
template <<|fim_middle|>typename T>
struct NumericArraySink;
struct Gene... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#pragma once
#include <Common/Visitor.h>
#include <base/TypeLists.h>
namespace DB::GatherUtils
{
template <typename T>
struct NumericArraySource;
struct GenericArraySource;
template <typename ArraySource>
struct NullableArraySource;
template <typename Base>
struct ConstSource;
using NumericArraySour... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Functions/GatherUtils/GatherUtils.h>
namespace DB::GatherUtils
{
void sliceHas(IArraySource & first, IArraySource & second, ArraySearchType searc<|fim_suffix|>rraySearchType::StartsWith:
sliceHasStartsWith(first, second, result);
break;
case ArraySearchType::End... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <type_traits>
#include <Columns/ColumnArray.h>
#include <Columns/ColumnsNumber.h>
#include <Common/VectorWithMemoryTracking.h>
#include <Functions/GatherUtils/IValueSource.h>
#include <Functions/GatherUtils/IArraySource.h>
#include <Functions/GatherUtils/IArraySink.h>
/** These m... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>
struct IArraySink
{
virtual ~IArraySink() = default;
virtual void accept(ArraySinkVisitor &)
{
throw Exception(ErrorCodes::NOT_IMPLEMENTED, "Accept not implemented for {}", demangle(typeid(*this).name()));
}
};
template <typename Derived>
class ArraySinkImpl : public Visitable<D... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#pragma once
#include <Columns/ColumnArray.h>
#include <Functions/GatherUtils/ArraySourceVisitor.h>
namespace DB
{
namespace ErrorCodes
{
extern const int NOT_IMPLEMENTED;
}
namespace GatherUt<|fim_suffix|>isitor> {}; /// NOLINT(bugprone-crtp-constructor-accessibility)
}
}
<|fim_middle|>ils
{
... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#pragma once
#include <Functions/GatherUtils/ValueSourceVisitor.h>
#include <Common/Exception.h>
namespace DB
{
namespace ErrorCodes
{
extern const int NOT_IMPLEMENTED;
}
namespace GatherUtils
{
struct IValueSource
{
virtual ~IValueSourc<|fim_suffix|>r> {}; /// NOLINT(bugprone-crtp-construct... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#pragma once
#include <Functions/GatherUtils/Algorithms.h>
#include <Functions/GatherUtils/ArraySourceVisitor.h>
#include <Functions/GatherUtils/ArraySinkVisitor.h>
#include <Functions/GatherUtils/ValueSourceVisitor.h>
namespace DB
{
namespace ErrorCodes
{
extern const int LOGICAL_ERROR;
}
names... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#pragma once
#include <Functions/GatherUtils/IArraySink.h>
#include <Columns/ColumnVector.h>
#include <Columns/ColumnDecimal.h>
#include <Columns/ColumnArray.h>
#include <Columns/ColumnString.h>
#include <Columns/ColumnFixedString.h>
#include <Columns/ColumnNullable.h>
#include <Common/assert_cast.h>
... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>uct NumericArraySlice
{
const T * data;
size_t size;
};
struct GenericArraySlice
{
const IColumn * elements;
size_t begin;
size_t size;
};
template <typename Slice>
struct NullableSlice : public Slice
{
const UInt8 * null_map = nullptr;
NullableSlice() = default;
Nullabl... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>offset;
using ArraySource::row_num;
using ArraySource::offsets;
using SinkType = NullableArraySink<typename ArraySource::SinkType>;
const NullMap & null_map;
NullableArraySource(const ColumnArray & arr, const NullMap & null_map_)
: ArraySource(arr), null_map(null_map_)
... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#pragma once
#include <Common/Visitor.h>
#include <base/TypeLists.h>
namespace DB::GatherUtils
{
template <typename T>
struct NumericValueSource;
struct GenericValueSource;
template <typename ArraySource>
struct NullableValueSource;
template <typename Base>
struct ConstSource;
using NumericValueSour... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>eSink sink(result->getData(), result->getOffsets(), source.getColumnSize());
concat<NullableSource, NullableSink>(sources, std::move(sink));
}
else
{
result = ColumnArray::create(source.createValuesColumn());
Sink sink(result->getData(), result-... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>ot_null_values = &nullable->getNestedColumn();
is_nullable = true;
}
if (typeid_cast<ColVecType *>(not_null_values))
{
if (is_nullable)
return std::make_unique<NullableArraySink<NumericArraySink<Type>>>(values, offsets, column_size);
... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <Functions/GatherUtils/GatherUtils.h>
#include <Functions/GatherUtils/Sinks.h>
#include <Functions/GatherUtils/Sources.h>
#include <base/TypeList<|fim_suffix|>able = typeid_cast<const ColumnNullable *>(&col.getData()))
{
auto column = ColumnArray::create(column_nullable->getNestedColu... | fim | ClickHouse/ClickHouse | cpp |
#include <Functions/GatherUtils/GatherUtils.h>
#include <Functions/GatherUtils/Sinks.h>
#include <Functions/GatherUtils/Sources.h>
#include <base/TypeLists.h>
namespace DB::GatherUtils
{
/// Creates IValueSource from Column
namespace
{
template <typename... Types>
struct ValueSourceCreator;
template <typename Type,... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <Functions/GatherUtils/GatherUtils.h>
#include <Functions/GatherUtils/Selectors.h>
#include <Functions/GatherUtils/Algorithms.h>
namespace DB::GatherUtils
{
namespace
{
struct ArrayEndsWithSelectArraySourcePair : public ArraySourcePairSelector<ArrayEndsWithSelectArraySourcePair>
{
template... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|><ConstSource<SourceType> &>(second), result, size);
else
arrayAllAny<ArraySearchType::All>(first, second, result, size);
}
}
template <typename Source>
static void selectSourcePair(bool is_first_const, bool is_first_nullable, Source && first,
... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <Functions/GatherUtils/GatherUtils.h>
#include <Functions/GatherUtils/Selectors.h>
#include <Functions/GatherUtils/Algorithms.h>
namespace DB::GatherUtils
{
namespace
{
struct ArrayHasAnySelectArraySourcePair : public ArraySourcePairSelector<ArrayHasAnySelectArraySourcePair>
{
template <ty... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|> second,
UInt8 * result, size_t size)
{
using SourceType = typename std::decay_t<Source>;
if (is_first_nullable)
{
using NullableSource = NullableArraySource<SourceType>;
if (is_first_const)
callFunction... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <Functions/GatherUtils/GatherUtils.h>
#include <Functions/GatherUtils/Selectors.h>
#include <Functions/GatherUtils/Algorithms.h>
namespace DB::GatherUtils
{
namespace
{
struct ArrayPush : public ArrayAndValueSourceSelectorBySink<ArrayPush>
{
template <typename ArraySource, typena<|fim_suff... | fim | ClickHouse/ClickHouse | cpp |
#ifndef __clang_analyzer__ // It's too hard to analyze.
#include <Functions/GatherUtils/GatherUtils.h>
#include <Functions/GatherUtils/Selectors.h>
#include <Functions/GatherUtils/Algorithms.h>
namespace DB::GatherUtils
{
namespace
{
struct ArrayResizeConstant : public ArrayAndValueSourceSelectorBySink<ArrayResizeC... | fim | ClickHouse/ClickHouse | cpp |
#ifndef __clang_analyzer__ // It's too hard to analyze.
#include <Functions/GatherUtils/GatherUtils.h>
#include <Functions/GatherUtils/Selectors.h>
#include <Functions/GatherUtils/Algorithms.h>
namespace DB::GatherUtils
{
namespace
{
struct ArrayResizeDynamic : public ArrayAndValueSourceSelectorBySink<ArrayResizeDy... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#ifndef __clang_analyzer__ // It's too hard to analyze.
#include <Functions/GatherUtils/GatherUtils.h>
#include <Functions/GatherUtils/Selectors.h>
#include <Functions/GatherUtils/Algorithms.h>
namespace DB::GatherUtils
{
namespace
{
struct SliceDynamicOffsetBoundedSelectArraySource : public ArraySour... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#ifndef __clang_analyzer__ // It's too hard to analyze.
#include <Functions/GatherUtils/GatherUtils.h>
#include <Functions/GatherUtils/Selectors.h>
#include <Functions/GatherUtils/Algorithms.h>
namespace DB::GatherUtils
{
namespace
{
struct SliceDynamicOffsetUnboundedSelectArraySource
: public... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>t, const GenericArraySlice & second, size_t first_ind, size_t second_ind)
{
return first.elements->compareAt(first_ind + first.begin, second_ind + second.begin, *second.elements, -1) == 0;
}
}
<|fim_prefix|>#pragma once
#include <Core/AccurateComparison.h>
#include <Functions/GatherUtils/Slices.h>
... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#ifndef __clang_analyzer__ // It's too hard to analyze.
#include <Functions/GatherUtils/GatherUtils.h>
#include <Functions/GatherUtils/Selectors.h>
#include <Functions/GatherUtils/Algorithms.h>
namespace DB::GatherUtils
{
namespace
{
struct SliceFromLeftConstantOffsetBoundedSe<|fim_suffix|>ce &>(sourc... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>= typename std::decay<Source>::type;
using Sink = typename SourceType::SinkType;
if (is_nullable)
{
using NullableSource = NullableArraySource<SourceType>;
using NullableSink = typename NullableSource::SinkType;
auto & nullable_source = static_... | fim | ClickHouse/ClickHouse | cpp |
#ifndef __clang_analyzer__ // It's too hard to analyze.
#include <Functions/GatherUtils/GatherUtils.h>
#include <Functions/GatherUtils/Selectors.h>
#include <Functions/GatherUtils/Algorithms.h>
namespace DB::GatherUtils
{
namespace
{
struct Selector : public ArraySourceSelector<Selector>
{
template <typename So... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#ifndef __clang_analyzer__ // It's too hard to analyze.
#include <Functions/GatherUtils/GatherUtils.h>
#include <Functions/GatherUtils/Selectors.h>
#include <Functions/GatherUtils/Algorithms.h>
namespace DB::GatherUtils
{
namespace
{
struct SliceFromRightConstantOffsetBoundedSelectArraySource
: pu... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#ifndef __clang_analyzer__ // It's too hard to analyze.
#include <Functions/GatherUtils/GatherUtils.h>
#include <Functions/GatherUtils/Selectors.h>
#include <Functions/GatherUtils/Algorithms.h>
namespace DB::GatherUtils
{
namespace
{
struct SliceFromRightConstantOffsetUnboundedSelectArraySource
: ... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>th_column);
}
}
};
}
ColumnArray::MutablePtr sliceFromRightDynamicLength(IArraySource & src, const IColumn & length_column)
{
ColumnArray::MutablePtr res;
Selector::select(src, length_column, res);
return res;
}
}
#endif
<|fim_prefix|>#ifndef __clang_analyzer__ // It's too hard ... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>p);
}
}
#endif
return sliceHasImplAnyAllGenericImpl<search_type, FirstSliceType, SecondSliceType, isEqual>(first, second, first_null_map, second_null_map);
}
}
<|fim_prefix|>#pragma once
#include <Functions/GatherUtils/GatherUtils.h>
#include <Functions/GatherUtils/Slices.h>
#include <... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>> &>(second), result, size);
else
arrayAllAny<ArraySearchType::StartsWith>(first, second, result, size);
}
}
template <typename Source>
static void selectSourcePair(bool is_first_const, bool is_first_nullable, Source && first,
... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>gitude_step * static_cast<Float64>(i),
args.latitude_min + args.latitude_step * static_cast<Float64>(j),
args.precision,
out);
out += length;
++items;
}
}
if (items == 0)
{
geohashEncodeImpl(args.longitud... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>t32 latitude_items = 0;
Float64 longitude_min = 0.0;
Float64 latitude_min = 0.0;
Float64 longitude_step = 0.0;
Float64 latitude_step = 0.0;
uint8_t precision = 0;
};
GeohashesInBoxPreparedArgs geohashesInBoxPrepare(
Float64 longitude_min,
Float64 latitude_min,
Float64 l... | fim | ClickHouse/ClickHouse | c |
#include <Functions/GregorianDate.h>
#include <Common/Exception.h>
#include <IO/ReadBuffer.h>
#include <IO/ReadHelpers.h>
#include <IO/WriteBufferFromString.h>
#include <IO/WriteHelpers.h>
namespace DB
{
namespace ErrorCodes
{
extern const int CANNOT_PARSE_INPUT_ASSERTION_FAILED;
extern const int CANNOT_PAR... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <Core/Types.h>
namespace DB
{
class ReadBuffer;
class WriteBuffer;
/// Proleptic Gregorian calendar date.
class GregorianDate
{
public:
GregorianDate() = default;
void init(ReadBuffer & in);
bool tryInit(ReadBuffer & in);
/** Construct from date in text form 'Y... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include "config.h"
#if USE_SSL
#include <Columns/ColumnString.h>
#include <DataTypes/DataTypeString.h>
#include <Functions/FunctionFactory.h>
#include <Functions/FunctionHelpers.h>
#include <Functions/IFunction.h>
#include <Common/MapWithMemoryTracking.h>
#include <Common/OpenSSLHelpers.h>
#include <Co... | fim | ClickHouse/ClickHouse | cpp |
#pragma once
#include <cstdlib>
// Definition of the class generated by gperf
class HTMLCharacterHash
{
private:
static inline unsigned int hash(const char * str, size_t len);
public:
static const struct NameAndGlyph * Lookup(const char * str, size_t len);
};
// Definition of the struct generated by gperf
s... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|> if (haystack_pos >= haystack_end)
break;
haystack_code_point = UTF8::convertUTF8ToCodePoint(reinterpret_cast<const char *>(haystack_pos), haystack_end - haystack_pos);
}
return needle_pos == needle_end;
}
};
}
<|fim_prefix|>#pragma once
#include <... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>isTokenSeparator(UInt8 c)
{
return isASCII(c) && !isAlphaNumericASCII(c);
}
};
}
<|fim_prefix|>#pragma once
#include <Columns/ColumnString.h>
#include <Common/StringSearcher.h>
#include <Core/ColumnNumbers.h>
namespace DB
{
namespace ErrorCodes
{
extern const int BAD_ARGUMENTS;
... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|> const UInt8 * cur_data = &haystack_data[prev_haystack_offset];
/// Phase 1: find all matches
intervals.clear();
findAllMatches(cur_data, cur_size, searchers, intervals, max_matches_per_row);
if (intervals.empty())
{
... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Functions/FunctionDynamicAdaptor.h>
#include <Functions/FunctionVariantAdaptor.h>
#include <Columns/ColumnConst.h>
#include <Columns/ColumnLowCardinality.h>
#include <Columns/ColumnNothing.h>
#include <Columns/ColumnNullable.h>
#include <Columns/ColumnSparse.h>
#include <Columns/ColumnReplicate... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <Core/ColumnNumbers.h>
#include <Core/ColumnsWithTypeAndName.h>
#include <Core/IResolvedFunction.h>
#include <Core/Names.h>
#include <Core/ValuesWithType.h>
#include <Common/UnorderedSetWithMemoryTracking.h>
#include <DataTypes/IDataType_fwd.h>
#include "config.h"
#include <memory... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>nArgumentSizes(arguments, input_rows_count);
return function->executeImpl(arguments, result_type, input_rows_count);
}
ColumnPtr FunctionToExecutableFunctionAdaptor::executeDryRunImpl(const ColumnsWithTypeAndName & arguments, const DataTypePtr & result_type, size_t input_rows_count) const
{
check... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>orConstantFolding(); }
ColumnPtr getConstantResultForNonConstArguments(const ColumnsWithTypeAndName & arguments_, const DataTypePtr & result_type_) const override
{
return function->getConstantResultForNonConstArguments(arguments_, result_type_);
}
bool isStateful() const overrid... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>taTypeDateTime>(type_ptr))
{
return Transform::FactorTransform::execute(UInt32(left.safeGet<UInt64>()), date_lut)
== Transform::FactorTransform::execute(UInt32(right.safeGet<UInt64>()), date_lut)
? is_monotonic
: is_not_monotonic;
... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|> if (const auto * timezone = dynamic_cast<const TimezoneMixin *>(&type))
date_lut = &timezone->getTimeZone();
if (left.isNull() || right.isNull())
return is_not_monotonic;
const auto * type_ptr = &type;
if (const auto * lc_typ... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>/*arguments*/) const override { return false; }
};
}
<|fim_prefix|>#pragma once
#include <Columns/ColumnConst.h>
#include <Columns/ColumnTuple.h>
#include <Functions/IFunction.h>
#include <Functions/FunctionHelpers.h>
#include <Interpreters/Context_fwd.h>
namespace DB
{
namespace ErrorCodes
{
exter... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>tion<Op, GreaterOrEqualsOp>::value;
static constexpr bool plus = IsSameOperation<Op, PlusImpl>::value;
static constexpr bool minus = IsSameOperation<Op, MinusImpl>::value;
static constexpr bool multiply = IsSameOperation<Op, MultiplyImpl>::value;
static constexpr bool div_floating = IsSam... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>────────────────────────────┬─JSONAllValues(json)──────┐
│ {"a":42} │ ['42'] │
│ {"b":"Hello"} │ ['Hello'] │
│ {"a":[1,2,3],"c":"2020-01-01"} │ ['[1,2,3]','2020-01-01'] │
└──────────────────────────────────────┴─────... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <Columns/ColumnNullable.h>
#include <Columns/ColumnString.h>
#include <Columns/ColumnVector.h>
#include <DataTypes/DataTypeNullable.h>
#include <DataTypes/DataTypesNumber.h>
#include <Functions/FunctionFactory.h>
#include <Functions/FunctionHelpers.h>
#include <Functions/IFunction.h>
#include <In... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <Functions/JSONPath/ASTs/ASTJSONPathQuery.h>
#include <P<|fim_suffix|>ide { return "ASTJSONPath"; }
ASTPtr clone() const override { return make_intrusive<ASTJSONPath>(*this); }
ASTJSONPathQuery * jsonpath_query{};
};
}
<|fim_middle|>arsers/IAST.h>
namespace DB
{
class AS... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#pragma once
#include <Parsers/IAST.h>
namespace DB
{
class ASTJSONPathMemberAccess : public IAST
{
public:
String getID(char) const override { return "ASTJSONPathMemberAccess"; }
ASTPtr clone() const override { return make_intrusive<ASTJSONPathMemberAccess>(*this)<|fim_suffix|>ey.another_key. ... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>"; }
ASTPtr clone() const override { return make_intrusive<ASTJSONPathQuery>(*this); }
};
}
<|fim_prefix|>#pragma once
#include <Parsers/IAST.h>
namespace DB
{
class ASTJSONPathQuery : public IAST
{
public:
String getID(char) con<|fim_middle|>st override { return "ASTJSONPathQuery<|endoftext|> | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>ingle index is represented as <start, start + 1>
VectorWithMemoryTracking<std::pair<UInt32, UInt32>> ranges;
bool is_star = false;
};
}
<|fim_prefix|>#pragma once
#include <vector>
#include <Parsers/IAST.h>
#include <Common/VectorWithMemoryTracking.h>
namespace DB
{
class ASTJSONPathRange : <|f... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#pragma once
#include <Parsers/IAST.h>
namespace DB
{
cla<|fim_suffix|>
ASTPtr clone() const override { return make_intrusive<ASTJSONPathRoot>(*this); }
};
}
<|fim_middle|>ss ASTJSONPathRoot : public IAST
{
public:
String getID(char) const override { return "ASTJSONPathRoot"; }
<|endoftext|> | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#pragma once
#include <Parsers/IAST.h>
namespace DB
{
class ASTJSONPathStar : public IAST
{
public:
String getID(char) const over<|fim_suffix|>STJSONPathStar"; }
ASTPtr clone() const override { return make_intrusive<ASTJSONPathStar>(*this); }
};
}
<|fim_middle|>ride { return "A<|endoftext|> | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>rn current_visitor >= 0;
}
int current_visitor = 0;
ASTPtr query_ptr;
VisitorList<JSONParser> visitors;
};
}
<|fim_prefix|>#pragma once
#include <Functions/JSONPath/Generator/IGenerator.h>
#include <Functions/JSONPath/Generator/VisitorJSONPathMemberAccess.h>
#include <Functions/JSONPath... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|> virtual ~IGenerator() = default;
};
}
<|fim_prefix|>#pragma once
#include <Functions/JSONPath/Generator/IGenerator_fwd.h>
#include <Functions/JSONPath/Generator/VisitorStatus.h>
namespace DB
{
template <typename JSONParser>
class IGenerator
{
public:
IGenerator() = default;
virtual const ch... | fim | ClickHouse/ClickHouse | c |
#pragma once
#include <Functions/JSONPath/Generator/IVisitor.h>
#include <Common/VectorWithMemoryTracking.h>
namespace DB
{
template <typename JSONParser>
class IGenerator;
template <typename JSONParser>
using IVisitorPtr = std::shared_ptr<IVisitor<JSONParser>>;
template <typename JSONParser>
using VisitorList = Ve... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>ply(typename JSONParser::Element & element) const = 0;
/**
* Restores visitor's initial state for later use
*/
virtual void reinitialize() = 0;
virtual void updateState() = 0;
bool isExhausted() { return is_exhausted; }
void setExhausted(bool exhausted) { is_exhausted = e... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#pragma once
#include <Func<|fim_suffix|>t;
element.getObject().find(std::string_view(member_access_ptr->member_name), result);
element = result;
return VisitorStatus::Ok;
}
VisitorStatus visit(typename JSONParser::Element & element) override
{
this->setExhaus... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#pragma once
#include <Functions/JSONPath/ASTs/ASTJSONPathRange.h>
#include <Functions/JSONPath/Generator/IVisitor.h>
#include <Functions/JSONPath/Generator/VisitorStatus.h>
namespace DB
{
template <typename JSONParser>
class VisitorJSONPathRange : public IVisitor<JSONParser>
{
public:
explicit Visi... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#pragma once
#include <Functions/JSONPath/ASTs/ASTJSONPathRoot.h>
#include <Functions/JSONPath/Generator/IVisitor.h>
#include <Functions/JSONPath/Generator/VisitorStatus.h>
namespace DB
{
template <typename JSONParser>
class VisitorJSONPathRoot : public IVisitor<JSONParser>
{
public:
explicit Visito... | fim | ClickHouse/ClickHouse | c |
#pragma once
#include <Functions/JSONPath/ASTs/ASTJSONPathStar.h>
#include <Functions/JSONPath/Generator/IVisitor.h>
#include <Functions/JSONPath/Generator/VisitorStatus.h>
namespace DB
{
template <typename JSONParser>
class VisitorJSONPathStar : public IVisitor<JSONParser>
{
public:
explicit VisitorJSONPathStar(... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#pragma once
namespace D<|fim_suffix|> Exhausted,
Error,
Ignore
};
}
<|fim_middle|>B
{
enum VisitorStatus
{
Ok,
<|endoftext|> | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>for JSONPath
*/
bool ParserJSONPath::parseImpl(Pos & pos, ASTPtr & node, Expected & expected)
{
auto ast_jsonpath = make_intrusive<ASTJSONPath>();
ParserJSONPathQuery parser_jsonpath_query;
/// Push back dot AST and brackets AST to query->children
ASTPtr query;
bool res = parser_jso... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <Parsers/IPa<|fim_suffix|>
bool parseImpl(Pos & pos, ASTPtr & node, Expected & expected) override;
public:
explicit ParserJSONPath() = default;
};
}
<|fim_middle|>rserBase.h>
namespace DB
{
/**
* Entry parser for JSONPath
*/
class ParserJSONPath : public IParserBase
{
... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Functions/JSONPath/ASTs/ASTJSONPathMemberAccess.h>
#include <Functions/JSONPath/Parsers/ParserJSONPathMemberAccess.h>
#include <Parsers/ASTIdentifier.h>
#include <Parsers/ASTIdentifier_fwd.h>
#include <Parsers/ExpressionElementParsers.h>
#include <Parsers/Lexer.h>
#include <Common/StringUtils.h... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>const override { return "ParserJSONPathMemberAccess"; }
bool parseImpl(Pos & pos, ASTPtr & node, Expected & expected) override;
};
}
<|fim_prefix|>#pragma once
#include <Parsers/IParserBase.h>
namespace DB
{
class ParserJSONPathMemberAccess : public IParserBase
{
const ch<|fim_middle|>ar * get... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>rn false;
}
++pos;
auto member_access = make_intrusive<ASTJSONPathMemberAccess>();
node = member_access;
return tryGetIdentifierNameInto(member_name, member_access->member_name);
}
}
<|fim_prefix|>#include <Functions/JSONPath/Parsers/ParserJSONPathMemberSquareBracketAccess.h>
#include ... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <Parsers/IParserBase.h>
// cases
// - [ident]
// - ['ident']
// - ["ident"]
namespace DB
{
class ParserJSONPathMemberSquareBracketAccess : public IParserBase
{
private:
const char * getName() const override { return "ParserJSONPathMe<|fim_suffix|>s"; }
bool parseImpl(Pos & po... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Functions/JSONPath/ASTs/ASTJSONPathQuery.h>
#include <Functions/JSONPath/Parsers/ParserJSONPathQuery.h>
#include <Functions/JSONPath/Parsers/ParserJSONPathRoot.h>
#include <Functions/JSONPath/Parsers/ParserJSONPathMemberAccess.h>
#include <Functions/JSONPath/Parsers/ParserJSONPathMemberSquareBra... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <Parsers/IParserBase.h>
namespace DB
{
class Par<|fim_suffix|>ed & expected) override;
};
}
<|fim_middle|>serJSONPathQuery : public IParserBase
{
protected:
const char * getName() const override { return "ParserJSONPathQuery"; }
bool parseImpl(Pos & pos, ASTPtr & query, Ex... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Functions/JSONPath/ASTs/ASTJSONPathRange.h>
#include <Functions/JSONPath/Parsers/ParserJSONPathQuery.h>
#include <Functions/JSONPath/Parsers/ParserJSONPathRange.h>
#include <Parsers/ASTIdentifier.h>
#include <Parsers/ASTLiteral.h>
#include <Parsers/ExpressionElementParsers.h>
#include <Parsers/... | fim | ClickHouse/ClickHouse | cpp |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.