text stringlengths 14 100k | source stringclasses 1
value | repo stringclasses 810
values | language stringclasses 13
values |
|---|---|---|---|
<|fim_suffix|> y, z
/// -- Tag x: explanation of tag x
/// -- Tag y: explanation of tag y
/// -- Tag z: explanation of tag z
///
/// at the beginning of a multiline query.
/// If there are no test tags in the multiline query the function returns 0.
size_t getTestTagsLength(const String & multiline_query);
}
<|fim_pref... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <sys/types.h>
#include <sys/socket.h>
#include <unistd.h>
#include <iostream>
#include <thread>
#include <atomic>
#include <Poco/Net/StreamSocket.h>
#include <Common/Exception.h>
#include <Common/ShellCommand.h>
#include <IO/ReadHelpers.h>
#include <IO/WriteBufferFromFileDescriptor.h>
#include <... | fim | ClickHouse/ClickHouse | cpp |
#pragma once
#include <base/types.h>
#include <Common/StringUtils.h>
namespace DB
{
/// Replace ASCII C0 control characters (0x00-0x1F), DEL (0x7F), and the UTF-8
/// encoding of C1 controls (U+0080-U+009F, encoded as `0xC2 0x80..0x9F`) with '?'
/// so a hostile server cannot inject terminal escape sequences via fi... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#pragma once
#include <cmath>
#include <cstddef>
#include <limits>
#include <base/types.h>
#include <Common/thread_local_rng.h>
namespace DB
{
/// Scale `interactive_delay` by `sqrt(total_fanout)` with per-connection jitter in `[1.0, 2.0)`,
/// to reduce progress/profile event traffic from distribute... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>55 on Linux; "Europe/Madrid" is 13
/// bytes). Bumping the cap back to `readStringBinary`'s 1 GiB default would
/// re-open the unbounded-allocation vector the helper exists to close.
EXPECT_LE(DBMS_MAX_HELLO_STRING_SIZE, 64u * 1024u);
EXPECT_GE(DBMS_MAX_HELLO_STRING_SIZE, 256u);
}
TEST(S... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>eInteractiveDelayByFanout, ZeroDelayStaysZero)
{
for (size_t fanout : {size_t{0}, size_t{1}, size_t{2}, size_t{100}, size_t{10'000}})
EXPECT_EQ(scaleInteractiveDelayByFanout(0, fanout), 0u);
}
<|fim_prefix|>#include <gtest/gtest.h>
#include <limits>
#include <Client/scaleInteractiveDelayByFa... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>it here, because ucol_open will fallback to default locale for
/// almost all random names.
if (!AvailableCollationLocales::instance().isCollationSupported(base_locale))
throw DB::Exception(DB::ErrorCodes::UNSUPPORTED_COLLATION_LOCALE, "Unsupported collation locale: {}", locale);
coll... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <optional>
#include <string>
#include <boost/noncopyable.hpp>
#include <Common/UnorderedMapWithMemoryTracking.h>
#include <Common/VectorWithMemoryTracking.h>
struct UCollator;
/// Represents available locales for collations.
class AvailableCollationLocales : private boost::nonco... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <IO/WriteHelpers.h>
#include <Columns/ColumnAggregateFunction.h>
#include <DataTypes/IDataType.h>
#include <AggregateFunctions/IAggregateFunction.h>
#include <Columns/ColumnsCommon.h>
#include <Columns/MaskOperations.h>
#include <IO/Operators.h>
#include <IO/ReadBufferFromString.h>
#include <IO/... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>alValues is not supported for ColumnAggregateFunction");
}
double getRatioOfDefaultRows(double) const override
{
return 0.0;
}
UInt64 getNumberOfDefaultRows() const override
{
return 0;
}
void getIndicesOfNonDefaultRows(Offsets &, size_t, size_t) const ov... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>able_elems.getNullMapData(), getOffsets(), res_null_map->getData(), filt, result_size_hint);
return ColumnArray::create(
ColumnNullable::create(
filtered_array_of_nested.getDataPtr(),
std::move(res_null_map)),
filtered_offsets);
}
ColumnPtr ColumnArray::filter... | fim | ClickHouse/ClickHouse | cpp |
#pragma once
#include <Columns/IColumn.h>
#include <Columns/IColumnImpl.h>
#include <Columns/ColumnVector.h>
#include <Core/Defines.h>
#include <Common/typeid_cast.h>
#include <Common/assert_cast.h>
namespace DB
{
/** A column of array values.
* In memory, it is represented as one column of a nested type, whose s... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>oid toBLOB(
BLOB & blob,
ColumnWithTypeAndName wrapped_column,
CompressionCodecPtr codec,
UInt64 client_revision,
const std::optional<FormatSettings> & format_settings)
{
WriteBufferFromVector<BLOB> wbuf(blob);
CompressedWriteBuffer compressed_bu... | fim | ClickHouse/ClickHouse | c |
#include <Columns/ColumnCompressed.h>
#include <Common/formatReadable.h>
#pragma clang diagnostic ignored "-Wold-style-cast"
#include <lz4.h>
namespace DB
{
namespace ErrorCodes
{
extern const int CANNOT_COMPRESS;
extern const int CANNOT_DECOMPRESS;
}
std::shared_ptr<Memory<>> ColumnCompressed::compressB... | fim | ClickHouse/ClickHouse | cpp |
#pragma once
#include <optional>
#include <Core/Field.h>
#include <Columns/IColumn.h>
#include <Common/Exception.h>
#include <IO/BufferWithOwnMemory.h>
namespace DB
{
namespace ErrorCodes
{
extern const int LOGICAL_ERROR;
}
/** Wrapper for compressed column data.
* The only supported operations are:
* - d... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <IO/WriteHelpers.h>
#include <Columns/ColumnConst.h>
#include <Columns/ColumnsCommon.h>
#include <Common/Exception.h>
#include <Common/HashTable/Hash.h>
#include <Common/iota.h>
#include <Common/typeid_cast.h>
#include <base/defines.h>
#if defined(MEMORY_SANITIZER)
#include <sanitizer/msan... | fim | ClickHouse/ClickHouse | cpp |
#pragma once
#include <Columns/IColumn.h>
#include <Core/Field.h>
#include <Common/PODArray.h>
#include <Common/assert_cast.h>
#include <Common/typeid_cast.h>
namespace DB
{
/** ColumnConst contains another column with single element,
* but looks like a column with arbitrary amount of same elements.
*/
class C... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Common/Exception.h>
#include <Common/FieldVisitorToString.h>
#include <Common/HashTable/HashSet.h>
#include <Common/HashTable/Hash.h>
#include <Common/RadixSort.h>
#include <Common/SipHash.h>
#include <Common/assert_cast.h>
#include <Common/iota.h>
#include <Core/DecimalFunctions.h>
#include <C... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>st;
ColumnPtr replicate(const IColumn::Offsets & offsets) const final;
void getExtremes(Field & min, Field & max, size_t start, size_t end) const final;
bool structureEquals(const IColumn & rhs) const final
{
if (auto rhs_concrete = typeid_cast<const ColumnDecimal<T> *>(&rhs))
... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>n();
const size_t discr = variant_col.globalDiscriminatorAt(row_num);
if (discr == ColumnVariant::NULL_DISCRIMINATOR)
return nullptr;
if (discr == getSharedVariantDiscriminator())
{
const auto value = getSharedVariant().getDataAt(variant_col.offsetAt(row_num));
Rea... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <Columns/ColumnString.h>
#include <Columns/ColumnVariant.h>
#include <Columns/ColumnVector.h>
#include <Columns/IColumn.h>
#include <DataTypes/IDataType.h>
#include <Common/UnorderedMapWithMemoryTracking.h>
#include <Common/UnorderedSetWithMemoryTracking.h>
namespace DB
{
/**
* ... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#pragma once
#include <Columns/IColumn.h>
#include <Common/PODArray.h>
namespace DB
{
/** Allows to access internal array of fixed-size column without cast to concrete type.
* We will inherit ColumnVector and ColumnFixedString from this class instead of IColumn.
* Assumes data layout of ColumnVect... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>{} are out of bound "
"in ColumnFixedString::insertRangeFrom method (size() = {}).",
toString(start), toString(length), toString(src_concrete.size()));
size_t old_size = chars.size();
chars.resize(old_size + length * n);
memcpy(chars.data() + ol... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>nst String & string) { insertData(string.c_str(), string.size()); }
Chars & getChars() { return chars; }
const Chars & getChars() const { return chars; }
size_t getN() const { return n; }
};
}
<|fim_prefix|>#pragma once
#include <Common/PODArray.h>
#include <base/memcmpSmall.h>
#include <Co... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Interpreters/ExpressionActions.h>
#include <Columns/ColumnFunction.h>
#include <Columns/ColumnsCommon.h>
#include <Columns/validateColumnType.h>
#include <Common/HashTable/Hash.h>
#include <Common/PODArray.h>
#include <Common/SipHash.h>
#include <Common/ProfileEvents.h>
#include <Common/assert_c... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>hrow Exception(ErrorCodes::NOT_IMPLEMENTED, "getPermutation is not implemented for {}", getName());
}
void updatePermutation(IColumn::PermutationSortDirection, IColumn::PermutationSortStability,
size_t, int, Permutation &, EqualRanges &) const override
{
throw ... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|> {
auto & indexes_data = getIndexesData<CurIndexType>();
indexes_data.resize_fill(indexes_data.size() + length, static_cast<CurIndexType>(index));
};
callForType(std::move(insert), size_of_type);
checkSizeOfType();
}
void ColumnIndex::insertIndexesRange(const IColumn & colu... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <optional>
#include <Columns/IColumn.h>
#include <Columns/ColumnsNumber.h>
namespace DB
{
/// Wrapper around ColumnVector to store indexes.
/// Supports dynamic change of underlying index type (UInt8 -> UInt16 -> UInt32 -> UInt64).
class ColumnIndex
{
public:
ColumnIndex();
... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Columns/ColumnLazy.h>
#include <Columns/ColumnsCommon.h>
#include <Columns/IColumnImpl.h>
#include <Core/Field.h>
#include <Common/assert_cast.h>
#include <Common/typeid_cast.h>
#include <DataTypes/DataTypesNumber.h>
#include <DataTypes/DataTypeTuple.h>
namespace DB
{
namespace ErrorCodes
{
... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <Columns/IColumn.h>
#include <Columns/IColumnImpl.h>
#include <Common/PODArray.h>
#include <Common/assert_cast.h>
#include <Core/Field.h>
#include <DataTypes/Serializations/ISerialization.h>
namespace DB
{
/**
* ColumnLazy is not used to actually store specific column data but ra... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>es) const
{
bool ascending = direction == IColumn::PermutationSortDirection::Ascending;
auto comparator = [this, &collator, ascending, stability, nan_direction_hint](size_t lhs, size_t rhs)
{
auto nested_column = getDictionary().getNestedColumn();
size_t lhs_index = getIndexes... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>bcolumnRecursively(RecursiveColumnCallback callback) const override
{
/** It is important to have both const and non-const versions here.
* The behavior of ColumnUnique::forEachSubcolumnRecursively differs between const and non-const versions.
* The non-const version will u... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Columns/ColumnArray.h>
#include <Columns/ColumnMap.h>
#include <Columns/ColumnTuple.h>
#include <Columns/ColumnCompressed.h>
#include <IO/WriteBufferFromString.h>
#include <IO/Operators.h>
#include <Common/typeid_cast.h>
#include <Common/assert_cast.h>
#include <Core/Field.h>
namespace DB
{
n... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>ixDynamicStructure(); }
const StatisticsPtr & getStatistics() const { return statistics; }
StatisticsPtr getOrCalculateStatistics() const;
void setStatistics(const StatisticsPtr & statistics_) { statistics = statistics_; }
StatisticsPtr calculateStatisticsForRange(size_t start, size_t end... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>onst override
{
return typeid(rhs) == typeid(ColumnNothing);
}
};
}
<|fim_prefix|>#pragma once
#include <Columns/IColumnDummy.h>
namespace DB
{
class ColumnNothing final : public COWHelper<IColumnDummy, ColumnNothing>
{
private:
friend class COWHelper<IColumnDummy, ColumnNothing>;... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Common/Arena.h>
#include <Common/HashTable/Hash.h>
#include <Common/HashTable/StringHashSet.h>
#include <Common/SipHash.h>
#include <Common/assert_cast.h>
#include <Columns/ColumnNullable.h>
#include <Columns/ColumnConst.h>
#include <Columns/ColumnCompressed.h>
#include <Columns/ColumnLowCardina... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <Columns/IColumn.h>
#include <Columns/ColumnsNumber.h>
#include <Common/typeid_cast.h>
#include <Common/assert_cast.h>
#include "config.h"
class Collator;
namespace DB
{
using NullMap = ColumnUInt8::Container;
using ConstNullMapPtr = const NullMap *;
/// Class that specifies n... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#pragma once
#include <Columns/IColumn.h>
#include <Columns/ColumnVector.h>
#include <Columns/ColumnArray.h>
#include <Columns/ColumnTuple.h>
#include <Columns/ColumnString.h>
#include <DataTypes/IDataType.h>
#include <DataTypes/Serializations/SerializationDynamic.h>
#include <Common/SetWithMemoryTracki... | fim | ClickHouse/ClickHouse | c |
#include <Columns/ColumnCompressed.h>
#include <Columns/ColumnFixedString.h>
#include <Columns/ColumnQBit.h>
#include <Columns/ColumnTuple.h>
#include <DataTypes/DataTypeQBit.h>
#include <DataTypes/Serializations/SerializationQBit.h>
#include <IO/Operators.h>
namespace DB
{
ColumnQBit::ColumnQBit(MutableColumnPtr &... | fim | ClickHouse/ClickHouse | cpp |
#pragma once
#include <Columns/ColumnTuple.h>
#include <Columns/IColumn.h>
#include <Core/Field.h>
#include <Common/assert_cast.h>
namespace DB
{
/** Column that represents bit-transposed vectors for efficient vector search operations.
*
* This column type stores array data in a bit-transposed layout, where bits... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>ixed() > 8);
}
}
<|fim_prefix|>#include <Columns/ColumnCompressed.h>
#include <Columns/ColumnConst.h>
#include <Columns/ColumnReplicated.h>
#include <Common/UnorderedSetWithMemoryTracking.h>
#include <Common/typeid_cast.h>
namespace DB
{
namespace ErrorCodes
{
extern const int SIZES_OF_COLUMNS_DOE... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <Columns/IColumn.h>
#include <Columns/ColumnIndex.h>
#include <Common/UnorderedMapWithMemoryTracking.h>
class Collator;
namespace DB
{
/** Column for replicated representation.
* It stores original column and indexes in this column.
* Used to perform lazy column replication.... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#pragma once
#include <Interpreters/PreparedSets.h>
#include <Columns/IColumnDummy.h>
#include <Core/Field.h>
namespace DB
{
class Set;
using ConstSetPtr = std::shared_ptr<const Set>;
/** A column containing multiple values in the `IN` section.
* Behaves like a constant-column (because the set is ... | fim | ClickHouse/ClickHouse | c |
#include <Columns/ColumnSparse.h>
#include <Columns/ColumnCompressed.h>
#include <Columns/ColumnConst.h>
#include <Columns/ColumnsCommon.h>
#include <Columns/ColumnTuple.h>
#include <Columns/ColumnReplicated.h>
#include <Common/HashTable/Hash.h>
#include <Common/SipHash.h>
#include <Common/iota.h>
#include <algorithm... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <Columns/IColumn.h>
#include <Columns/ColumnsNumber.h>
#include <Common/assert_cast.h>
class Collator;
namespace DB
{
/** Column for spare representation.
* It stores column with non-default values and column
* with their sorted positions in original column. Column with
* ... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Columns/ColumnString.h>
#include <Columns/Collator.h>
#include <Columns/ColumnsCommon.h>
#include <Columns/ColumnCompressed.h>
#include <Columns/ColumnsNumber.h>
#include <Common/Arena.h>
#include <Common/HashTable/StringHashSet.h>
#include <Common/HashTable/Hash.h>
#include <Common/SipHash.h>
... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <cstring>
#include <IO/WriteHelpers.h>
#include <Columns/IColumn.h>
#include <Columns/IColumnImpl.h>
#include <Common/PODArray.h>
#include <Common/memcpySmall.h>
#include <base/memcmpSmall.h>
#include <Common/assert_cast.h>
#include <Core/Field.h>
#include <base/defines.h>
class... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#pragma once
#include <cstring>
#include <Common/Exception.h>
#include <Columns/ColumnString.h>
#include <Columns/ColumnFixedString.h>
#include <IO/WriteBufferFromVector.h>
namespace DB
{
namespace ErrorCodes
{
extern const int TOO_LARGE_STRING_SIZE;
}
namespace ColumnStringHelpers
{
/** Simplifies ... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Columns/ColumnTuple.h>
#include <Columns/ColumnCompressed.h>
#include <Columns/IColumnImpl.h>
#include <Core/Field.h>
#include <Processors/Transforms/ColumnGathererTransform.h>
#include <IO/Operators.h>
#include <IO/WriteBufferFromString.h>
#include <Common/Arena.h>
#include <Common/HashTable/H... | fim | ClickHouse/ClickHouse | cpp |
#pragma once
#include <Columns/IColumn.h>
namespace DB
{
/** Column, that is just group of few another columns.
*
* For constant Tuples, see ColumnConst.
* Mixed constant/non-constant columns is prohibited in tuple
* for implementation simplicity.
*/
class ColumnTuple final : public COWHelper<IColumnHelp... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Columns/ColumnUnique.h>
#include <Common/Exception.h>
#include <Common/SipHash.h>
namespace DB
{
namespace ErrorCodes
{
extern const int NOT_IMPLEMENTED;
}
void throwNotImplementedForColumnUnique(const char * method)
{
throw Exception(ErrorCodes::NOT_IMPLEMENTED, "Method {} is not su... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>ndex();
// NaN can contain different sign or mantissa bits, but we need to consider all NaNs equal.
if constexpr (is_float_vector_v<ColumnType>)
{
if (isNaN(x.safeGet<typename ColumnType::ValueType>()))
{
auto nan = NaNOrZero<typename ColumnType::ValueType>();
... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Columns/ColumnVariant.h>
#include <Columns/ColumnCompressed.h>
#include <Columns/ColumnsCommon.h>
#include <Columns/ColumnsNumber.h>
#include <Core/Field.h>
#include <Processors/Transforms/ColumnGathererTransform.h>
#include <IO/Operators.h>
#include <IO/WriteBufferFromString.h>
#include <Commo... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <Columns/IColumn.h>
#include <Columns/ColumnVector.h>
#include <DataTypes/Serializations/ISerialization.h>
namespace DB
{
struct FormatSettings;
/**
* Column for storing Variant(...) type values.
* Variant type represents a union of other data types.
* For example, type Varian... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>in;
/// Thresholds on size. Lower threshold is arbitrary. Upper threshold is chosen by the type for histogram counters.
if (range_size >= 256 && range_size <= std::numeric_limits<UInt32>::max() && use_radix_sort)
{
bool try_sort = trySort(begin, end, pr... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|> ///
/// std::conditional_t selects an unsigned integer type of the same size as T,
/// satisfying the requirement of std::bit_cast that both types have equal size.
/// Unsigned integers are chosen because their value equals their bit pattern,
/// making ... | fim | ClickHouse/ClickHouse | c |
#include <Columns/IColumn.h>
#include <Columns/ColumnVector.h>
#include <Common/Exception.h>
#include <Common/typeid_cast.h>
#include <Common/HashTable/HashSet.h>
#include <bit>
#include <cstring>
#include <Columns/ColumnsCommon.h>
namespace DB
{
#if defined(__SSE2__)
/// Transform 64-byte mask to 64-bit mask.
stati... | fim | ClickHouse/ClickHouse | cpp |
#pragma once
#include <Columns/IColumn.h>
#include <Common/PODArray.h>
#if defined(__AVX512F__) || defined(__AVX512BW__) || defined(__AVX__) || defined(__AVX2__)
#include <immintrin.h>
#endif
#if defined(__aarch64__) && defined(__ARM_NEON)
# include <arm_neon.h>
#endif
/// Common helper methods for implementation ... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>venience typedefs for columns of SQL types Date, Date32, DateTime and DateTime64. */
using ColumnDate = DataTypeDate::ColumnType;
using ColumnDate32 = DataTypeDate32::ColumnType;
using ColumnDateTime = DataTypeDateTime::ColumnType;
using ColumnDateTime64 = DataTypeDateTime64::ColumnType;
using ColumnTime... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>= ColumnVector<IPv4>;
using ColumnIPv6 = ColumnVector<IPv6>;
}
<|fim_prefix|>#pragma once
#include <base/types.h>
#include <Colum<|fim_middle|>ns/ColumnVector.h>
namespace DB
{
/** Columns with numbers. */
using ColumnUInt8 = ColumnVector<UInt8>;
using ColumnUInt16 = ColumnVector<UInt16>;
using Colu... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Common/Exception.h>
#include <Common/typeid_cast.h>
#include <Common/assert_cast.h>
#include <Columns/FilterDescription.h>
#include <Columns/ColumnsCommon.h>
#include <Columns/ColumnsNumber.h>
#include <Columns/ColumnNullable.h>
#include <Columns/ColumnConst.h>
#include <Columns/ColumnSparse.h>
... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <Columns/IColumn_fwd.h>
#include <Common/PODArray_fwd.h>
namespace DB
{
template <class> class ColumnVector;
using ColumnUInt64 = ColumnVector<UInt64>;
using IColumnFilter = PaddedPODArray<UInt8>;
bool tryConvertAnyColumnToBool(const IColumn & column, IColumnFilter & res);
/// S... | fim | ClickHouse/ClickHouse | c |
#include <Columns/IColumn.h>
#include <Columns/ColumnAggregateFunction.h>
#include <Columns/ColumnArray.h>
#include <Columns/ColumnBLOB.h>
#include <Columns/ColumnCompressed.h>
#include <Columns/ColumnConst.h>
#include <Columns/ColumnDecimal.h>
#include <Columns/ColumnDynamic.h>
#include <Columns/ColumnFixedString.h>
... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|> const = 0;
/// Returns indices of values in column, that not equal to default value of column.
virtual void getIndicesOfNonDefaultRows(Offsets & indices, size_t from, size_t limit) const = 0;
/// Returns column with @total_size elements.
/// In result column values from current column a... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>mit) const
{
if (s != perm.size())
throw Exception(ErrorCodes::SIZES_OF_COLUMNS_DOESNT_MATCH, "Size of permutation doesn't match size of column.");
return cloneDummy(limit ? std::min(s, limit) : s);
}
ColumnPtr IColumnDummy::index(const IColumn & indexes, size_t limit) const
{
if (in... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>rride;
void expand(const IColumn::Filter & mask, bool inverted) override;
ColumnPtr permute(const Permutation & perm, size_t limit) const override;
ColumnPtr index(const IColumn & indexes, size_t limit) const override;
void getPermutation(IColumn::PermutationSortDirection /*direction*/... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#pragma once
/**
* This file implements template methods of IColumn that depend on other types
* we don't want to include.
* Currently, getPermutationImpl and updatePermutationImpl depend on PODArray
* implementation.
*/
#include <algo<|fim_suffix|> 0;
else
return res > 0;
... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>for example).
/// Parameter length could be ignored if column values have fixed size.
virtual size_t uniqueInsertData(const char * pos, size_t length) = 0;
virtual size_t getDefaultValueIndex() const = 0; /// Nullable ? getNullValueIndex : getNestedTypeDefaultValueIndex
virtual size_t ge... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>std::vector<MutableColumnPtr>; // STYLE_CHECK_ALLOW_STD_CONTAINERS
using ColumnRawPtrs = std::vector<const IColumn *>; // STYLE_CHECK_ALLOW_STD_CONTAINERS
}
<|fim_prefix|>#pragma once
#include <Common/COW.h>
#include <Common/VectorWithMemoryTracking.h>
#include <memory>
#include <vector>
namespace DB
{... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Columns/MaskOperations.h>
#include <Columns/ColumnFunction.h>
#include <Columns/ColumnNullable.h>
#include <Columns/ColumnNothing.h>
#include <Columns/ColumnsCommon.h>
#include <Columns/ColumnConst.h>
#include <Columns/ColumnLowCardinality.h>
#include <DataTypes/IDataType.h>
#include <algorithm... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <Core/ColumnWithTypeAndName.h>
#include <Core/ColumnsWithTypeAndName.h>
#include <Core/Field.h>
#include <Common/PODArray.h>
namespace DB
{
/// Expand data by mask. After expanding data will satisfy the following: if we filter data
/// by given mask, we get initial data. In places... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>& elem) { return elem.index; }
};
}
<|fim_prefix|>#pragma once
#include <Common/RadixSort.h>
namespace DB
{
tem<|fim_middle|>plate <typename T>
struct ValueWithIndex
{
T value;
UInt32 index;
};
template <typename T>
struct RadixSortTraits : RadixSortNumTraits<T>
{
using Element = ValueWit... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#pragma once
#include <Common/Exception.h>
#include <Common/HashTable/Hash.h>
#include <Common/HashTable/HashTable.h>
#include <Common/HashTable/HashTableAllocator.h>
#include <Columns/ColumnString.h>
#include <Columns/ColumnsNumber.h>
#include <Common/assert_cast.h>
#include <base/range.h>
#include <bas... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <cstddef>
#include <Columns/IColumn.h>
#include <Core/Block.h>
#include <DataTypes/DataTypeArray.h>
#include <DataTypes/DataTypeFactory.h>
#include <DataTypes/DataTypeNullable.h>
#include <DataTypes/IDataType.h>
#include <base/types.h>
#include <benchmark/benchmark.h>
using namespace DB;
static... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>/// Microbenchmark for IColumn::computeHashInto.
///
/// Measures per-row throughput for the hash-production step used by
/// hash-partitioning operators (e.g. BufferedShardByHashTransform).
///
/// Each benchmark name encodes: <ColumnType>_K<K>_B<batch>
/// K = number of key columns chained
/// B = b... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <Columns/getLeastSuperColumn.h>
#include <Columns/IColumn.h>
#include <Common/Exception.h>
#include <Columns/ColumnConst.h>
#include <Common/assert_cast.h>
#include <DataTypes/getLeastSupertype.h>
namespace DB
{
namespace ErrorCodes
{
extern const int LOGICAL_ERROR;
}
static bool sameConstant... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>pe = false);
}
<|fim_prefix|>#pragma once
#include <Common/<|fim_middle|>VectorWithMemoryTracking.h>
#include <Core/ColumnWithTypeAndName.h>
namespace DB
{
/// getLeastSupertype + related column changes with an option to use variant as common type
ColumnWithTypeAndName getLeastSuperColumn(const Vecto... | fim | ClickHouse/ClickHouse | c |
#include <base/types.h>
#include <AggregateFunctions/DDSketch.h>
#include <AggregateFunctions/AggregateFunctionFactory.h>
#include <AggregateFunctions/IAggregateFunction.h>
#include <Columns/ColumnAggregateFunction.h>
#include <Columns/ColumnsNumber.h>
#include <DataTypes/DataTypesNumber.h>
#include <IO/ReadBufferFromM... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>
for (size_t i = 0; i < 6; ++i)
{
threads.emplace_back([&]
{
for (size_t j = 0; j < 10000; ++j)
ASSERT_EQ(column_lc->dumpStructure(), expected_structure);
});
}
for (auto & t : threads)
t.join();
}
<|fim_prefix|>#include <Columns... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <Columns/ColumnDynamic.h>
#include <Columns/ColumnString.h>
#include <IO/ReadBufferFromString.h>
#include <gtest/gtest.h>
#include <Common/Arena.h>
using namespace DB;
TEST(ColumnDynamic, CreateEmpty)
{
auto column = ColumnDynamic::create(254);
ASSERT_TRUE(column->empty());
ASSERT_E... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>(deserializeFieldFromSharedData(shared_data_values, 1), Field("Str3"));
ASSERT_EQ(shared_data_offsets[5] - shared_data_offsets[4], 2);
ASSERT_EQ((*shared_data_paths)[2], "a.d");
ASSERT_EQ(deserializeFieldFromSharedData(shared_data_values, 2), Field("Str22"));
ASSERT_EQ((*shared_data_paths)... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>mn::Offsets offsets;
column->getIndicesOfNonDefaultRows(offsets, 0, column->size());
ASSERT_EQ(offsets.size(), 10);
ASSERT_EQ(offsets, IColumn::Offsets({0, 1, 2, 3, 5, 6, 7, 8, 10, 11}));
}
<|fim_prefix|>#include <Columns/ColumnReplicated.h>
#include <Columns/ColumnString.h>
#include <Columns/... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <Columns/ColumnSparse.h>
#include <Columns/ColumnsNumber.h>
#include <Common/Exception.h>
#include <Common/iota.h>
#include <Common/randomSeed.h>
#include <pcg_random.hpp>
#include <gtest/gtest.h>
#include <algorithm>
#include <numeric>
#include <Common/FieldVisitors.h>
using namespace DB;
s... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>ity_data_type = std::make_shared<DataTypeLowCardinality>(nullable_data_type);
auto create_column = [&]() { return low_cardinality_data_type->createColumn(); };
assertColumnPermutations(create_column, IndexInRangeNullableTransform<IndexInRangeInt64Transform>());
assertColumnPermut... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>ColumnString, CompressibleCharsAndCompressibleOffsets)
{
auto col = ColumnString::create();
auto & chars = col->getChars();
auto & offsets = col->getOffsets();
chars.resize(column_size * bytes_per_string);
for (size_t i = 0; i < column_size; ++i)
{
static const uint64_t val... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <Columns/ColumnTuple.h>
#include <Columns/ColumnsNumber.h>
#include <Columns/ColumnFixedString.h>
#include <gtest/gtest.h>
#include <base/types.h>
#include <Common/CurrentThread.h>
#include <Common/Exception.h>
#include <Common/MemoryTracker.h>
#include <Common/ThreadStatus.h>
#include <Common/a... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>tring>::create(data_type);
auto idx = column_unique->uniqueInsertRangeFrom(column, 0, num_values);
const char * pos_string = nullptr;
const char * pos_lc = nullptr;
for (size_t i = 0; i < num_values; ++i)
{
auto ref_string = column.serializeValueIntoAre... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <Columns/ColumnVariant.h>
#include <Columns/ColumnVector.h>
#include <Columns/ColumnString.h>
#include <Columns/ColumnsNumber.h>
#include <gtest/gtest.h>
using namespace DB;
TEST(ColumnVariant, CreateFromEmptyColumns)
{
MutableColumns columns;
columns.push_back(ColumnUInt32::create());
... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>rows)));
}
}
catch (const Exception & e)
{
FAIL() << e.displayText();
}
}
TEST(ColumnVector, Index)
{
testIndex<UInt8, UInt8>();
testIndex<UInt16, UInt8>();
testIndex<UInt16, UInt16>();
}
<|fim_prefix|>#include <limits>
#include <type_traits>
#include <typeinfo... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>o offsets = ColumnArray::ColumnOffsets::create();
UInt64 off = 0;
for (size_t i = 0; i < rows; ++i)
{
data->insert(static_cast<UInt64>(10));
data->insert(static_cast<UInt64>(20));
data->insert(static_cast<UInt64>(30));
off += 3;
... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <Columns/ColumnLowCardinality.h>
#include <Columns/ColumnsNumber.h>
#include <DataTypes/DataTypesNumber.h>
#include <DataTypes/DataTypeLowCardinality.h>
#include <gtest/gtest.h>
using namespace DB;
template <typename T>
void testLowCardinalityNumberInsert(const DataTypePtr & data_type)
{
... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>ol))
{
if (const auto * type_tuple = typeid_cast<const DataTypeTuple *>(&type))
{
const auto & type_elements = type_tuple->getElements();
if (col_tuple->tupleSize() != type_elements.size())
return false;
for (size_t i = 0; i < col_tup... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <Columns/IColumn.h>
#include <DataTypes/IDataType.h>
namespace DB
{
/// Recursively checks that a column's structure matches its declared DataType.
///<|fim_suffix|>s.
bool columnMatchesType(const IColumn & column, const IDataType & type);
}
<|fim_middle|> Returns true if the col... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#pragma once
#include <atomic>
#include <memory>
#include <Common/ActionLock.h>
namespace DB
{
/// An atomic variable th<|fim_suffix|> alive)
friend class ActionLock;
[[nodiscard]] ActionLock cancel() { return ActionLock(*this); }
/// Cancel the actions forever.
void cancelForever() { ... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Common/ActionLock.h>
#include <Common/ActionBlocker.h<|fim_suffix|>+(*counter);
}
ActionLock::ActionLock(ActionLock && other) noexcept
{
*this = std::move(other);
}
ActionLock & ActionLock::operator=(ActionLock && other) noexcept
{
auto lock_lhs = this->counter_ptr.lock();
counter... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <memory>
#include <atomic>
namespace DB
{
class ActionBlocker;
using StorageActionBlockType = size_t;
/// Blocks related action while a ActionLock instance exists
/// ActionBlocker could be destroyed before the lock, in this case ActionLock will safely do nothing in its destructo... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Common/AggregatedMetrics.h>
#include <Common/CurrentMetrics.h>
#include <base/defines.h>
#include <algorithm>
#include <atomic>
#include <mutex>
#include <tuple>
namespace CurrentMetrics
{
extern const Metric SharedMergeTreeMaxActiveReplicas;
extern const Metric SharedMergeTreeMaxInac... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|> std::atomic<CurrentMetrics::Value> accounted_value = 0;
};
}
<|fim_prefix|>#pragma once
#include <Common/CurrentMetrics.h>
#include <atomic>
/** Allows to aggregate partially changing values into single CurrentMetric.
* Destination CurrentMetric will be updated instantly after changes will be appli... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Common/AlignedBuffer.h>
#include <Common/Exception.h>
#include <Common/ErrnoException.h>
#include <Common/formatReadable.h>
namespace DB
{
namespace ErrorCodes
{
extern const int CANNOT_ALLOCATE_MEMORY;
}
void AlignedBuffer::alloc(size_t size, size_t alignment)
{
void * new_buf = n... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>ar *>(buf); }
};
}
<|fim_prefix|>#pragma once
#include <cstdlib>
#include <utility>
#include <boost/noncopyable.hpp>
namespace DB
{
/** Aligned piece of memory.
<|fim_middle|> * It can only be allocated and destroyed.
* MemoryTracker is not used. AlignedBuffer is intended for small pieces of memo... | fim | ClickHouse/ClickHouse | c |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.