text stringlengths 14 100k | source stringclasses 1
value | repo stringclasses 810
values | language stringclasses 13
values |
|---|---|---|---|
<|fim_prefix|>#pragma once
#include <DataTypes/IDataType.h>
#include <DataTypes/DataTypesBinaryEncoding.h>
#include <array>
#include <unordered_map>
namespace DB
{
/// Cache of simple (parameterless) data types and their serializations,
/// pre-filled at construction time. Avoids repeated DataTypeFactory lookups
//... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>verted_value < std::numeric_limits<ToNativeType>::min()
|| converted_value > std::numeric_limits<ToNativeType>::max();
bool overflow = mul_overflow | range_overflow;
if constexpr (has_nullmap)
{
nullmap[i] = overflow;
... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <base/arithmeticOverflow.h>
#include <base/extended_types.h>
#include <Common/typeid_cast.h>
#include <base/Decimal.h>
#include <DataTypes/IDataType.h>
#include <DataTypes/DataTypeDate.h>
#include <DataTypes/DataTypeDate32.h>
#include <DataTypes/DataTypeDecimalBase.h>
#include <Data... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <DataTypes/DataTypesNumber.h>
#include <DataTypes/DataTypeFactory.h>
#include <Parsers/IAST.h>
namespace DB
{
namespace ErrorCodes
{
extern const int NUMBER_OF_ARGUMENTS_DOESNT_MATCH;
}
template <typename T>
static DataTypePtr createNumericDataType(const ASTPtr & arguments)
{
if (ar... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>eFloat64 = DataTypeNumber<Float64>;
using DataTypeUInt128 = DataTypeNumber<UInt128>;
using DataTypeInt128 = DataTypeNumber<Int128>;
using DataTypeUInt256 = DataTypeNumber<UInt256>;
using DataTypeInt256 = DataTypeNumber<Int256>;
bool isUInt64ThatCanBeInt64(const DataTypePtr & type);
/// Function helper ... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>).second;
T max_val = values.back().second;
if (value < min_val || value > max_val)
return false;
/// Cast to Int32 first to avoid signed overflow
size_t arr_idx = static_cast<size_t>(static_cast<Int32>(value) - static_cast<Int32>(min_val));
uint16_t idx... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>
/// Get name for value, returns false if not found
bool getNameForValue(T value, std::string_view & result) const;
/// Get value for name, throws if not found
T getValue(std::string_view field_name) const;
/// Get value for name, returns false if not found
bool tryGetValue(T & ... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <DataTypes/FieldToDataType.h>
#include <DataTypes/DataTypeTuple.h>
#include <DataTypes/DataTypeMap.h>
#include <DataTypes/DataTypeObject.h>
#include <DataTypes/DataTypesNumber.h>
#include <DataTypes/DataTypesDecimal.h>
#include <DataTypes/DataTypeSt<|fim_suffix|>t256 &) const
{
return std::ma... | fim | ClickHouse/ClickHouse | cpp |
#pragma once
#include <memory>
#include <Core/Types.h>
#include <Core/Field.h>
#include <Common/FieldVisitors.h>
#include <DataTypes/getLeastSupertype.h>
namespace DB
{
class IDataType;
using DataTypePtr = std::shared_ptr<const IDataType>;
/** For a given Field returns the minimum data type that allows this value... | fim | ClickHouse/ClickHouse | c |
#include <cstddef>
#include <Columns/IColumn.h>
#include <Columns/ColumnConst.h>
#include <Columns/ColumnSparse.h>
#include <Columns/ColumnReplicated.h>
#include <Common/checkStackSize.h>
#include <Common/Exception.h>
#include <Common/quoteString.h>
#include <Common/SipHash.h>
#include <IO/WriteHelpers.h>
#include <... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>rent data type. Throw an exception if `canBePromoted() == false`.
*/
virtual DataTypePtr promoteNumericType() const;
/** Directly insert default value into a column. Default implementation use method IColumn::insertDefault.
* This should be overridden if data type default value differ... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>s::NOT_IMPLEMENTED, "Method insertDefaultInto is not implemented for data type {}", getName());
}
bool haveSubtypes() const override { return false; }
bool cannotBeStoredInTables() const override { return true; }
void updateHashImpl(SipHash &) const override {}
SerializationPtr doGe... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#pragma once
#include <memory>
#include<|fim_suffix|>nstInfo>;
}
<|fim_middle|> <vector>
namespace DB
{
class IDataType;
using DataTypePtr = std::shared_ptr<const IDataType>;
using DataTypes = std::vector<DataTypePtr>;
struct DataTypeWithConstInfo
{
DataTypePtr type;
bool is_const;
};
using ... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <DataTypes/Native.h>
#include <Columns/ColumnDecimal.h>
#if USE_EMBEDDED_COMPILER
# if defined(__powerpc64__)
# undef CR1
# undef CR2
# undef CR3
# endif
# include <llvm/IR/IRBuilder.h>
# include <DataTypes/DataTypeDateTime64.h>
# include <DataTypes/DataType... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include "config.h"
#include <DataTypes/DataTypesDecimal.h>
#if USE_EMBEDDED_COMPILER
# include <Common/Exception.h>
# include <Core/ValueWithType.h>
# include <DataTypes/IDataType.h>
namespace llvm
{
class IRBuilderBase;
class Type;
class Value;
class Constant;
}
... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>olumnArray &>(*block.getByPosition(it->second).column);
const ColumnArray & another_array_column = assert_cast<const ColumnArray &>(*elem.column);
if (!first_array_column.hasEqualOffsets(another_array_column))
throw Exception(ErrorCodes::SIZ... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <Core/Block.h>
#include <Core/Block_fwd.h>
#include <Core/Names.h>
#include <Core/NamesAndTypes.h>
#include <map>
#include <utility>
namespace DB
{
class ColumnsDescription;
class DataTypeTuple;
namespace Nested
{
std::string concatenateName(const std::string & nested_table... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>xtractedSubcolumnsBeInsideNullable(removeLowCardinality(type));
}
DataTypePtr makeExtractedSubcolumnsNullableOrLowCardinalityNullableSafe(const DataTypePtr & type)
{
if (!canExtractedSubcolumnsBeInsideNullableOrLowCardinalityNullable(type))
return type;
return makeNullableOrLowCardinalit... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|> SerializationPtr create(const SerializationPtr & prev_serialization, const DataTypePtr & prev_type) const override;
ColumnPtr create(const ColumnPtr & prev) const override;
};
}
<|fim_prefix|>#pragma once
#include <Columns/ColumnNullable.h>
#include <Core/Types.h>
#include <DataTypes/Serializatio... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#pragma once
#include <type_traits>
#include <Core/Types.h>
namespace DB
{
/** Allows get the res<|fim_suffix|> has_signed = is_signed_v<A> || is_signed_v<B>;
static constexpr bool has_unsigned = !is_signed_v<A> || !is_signed_v<B>;
static constexpr size_t max_size_of_unsigned_integer = max(i... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#pragma once
#include <atomic>
#include <exception>
#include <functional>
namespace DB
{
/// Simple task that ca<|fim_suffix|>exception;
};
}
<|fim_middle|>n be executed and waited by several threads.
class DeserializationTask
{
public:
explicit DeserializationTask(std::function<void()> deseriali... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Columns/ColumnBLOB.h>
#include <Columns/ColumnSparse.h>
#include <Columns/ColumnReplicated.h>
#include <Columns/IColumn.h>
#include <Compression/CompressionFactory.h>
#include <Common/Exception.h>
#include <DataTypes/NestedUtils.h>
#include <DataTypes/Serializations/ISerialization.h>
#include <D... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>ubcolumn(const SubstreamPath & path);
/// In old versions we could escape file names for some specific substreams differently and it can lead
/// to not found stream file names in new versions. To keep compatibility, if we can't find stream file name
/// we are trying to change escaping (via ... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>oid SerializationAggregateFunction::serializeTextJSON(const IColumn & column, size_t row_num, WriteBuffer & ostr, const FormatSettings & settings) const
{
writeJSONString(serializeToString(function, column, row_num, version), ostr, settings);
}
void SerializationAggregateFunction::deserializeTextJSO... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|> settings) const override;
};
}
<|fim_prefix|>#pragma once
#include <AggregateFunctions/IAggregateFunction_fwd.h>
#include <DataTypes/Serializations/ISerialization.h>
namespace DB
{
class SerializationAggregateFunction final : public ISerialization
{
private:
AggregateFunctionPtr function;
St... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|> writeCString("<elem>", ostr);
nested->serializeTextXML(nested_column, i, ostr, settings);
writeCString("</elem>", ostr);
}
writeCString("</array>", ostr);
}
void SerializationArray::serializeTextCSV(const IColumn & column, size_t row_num, WriteBuffer & ostr, const FormatSetting... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <DataTypes/Serializations/SimpleTextSerialization.h>
namespace DB
{
class SerializationArray final : public SimpleTextSerialization
{
private:
SerializationPtr nested;
explicit SerializationArray(const SerializationPtr & nested_) : nested(nested_) {}
public:
static U... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Columns/ColumnsNumber.h>
#include <Common/SipHash.h>
#include <DataTypes/Serializations/SerializationArrayOffsets.h>
namespace DB
{
UInt128 SerializationArrayOffsets::getHash()
{
SipHash hash;
hash.update("ArrayOffsets");
return hash.get128();
}
SerializationPtr SerializationArra... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>alizationArrayOffsets final : public SerializationNumber<UInt64>
{
private:
SerializationArrayOffsets() = default;
public:
static UInt128 getHash();
static SerializationPtr create();
void deserializeBinaryBulkWithMultipleStreams(
ColumnPtr & column,
size_t rows_offset,
size_t... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Common/SipHash.h>
#include <DataTypes/Serializations/SerializationBool.h>
#include <Columns/ColumnsNumber.h>
#include <Common/Exception.h>
#include <IO/WriteBuffer.h>
#include <IO/ReadBuffer.h>
#include <IO/ReadHelpers.h>
#include <IO/WriteHelpers.h>
#include <IO/PeekableReadBuffer.h>
#include... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <DataTypes/Serializations/SerializationWrapper.h>
namespace DB
{
class IColumn;
class SerializationBool final : public SerializationWrapper
{
private:
explicit SerializationBool(const SerializationPtr & nested_);
public:
static UInt128 getHash(const SerializationPtr & ne... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <DataTypes/Serializations/SerializationCustomSimpleText.h>
#include <Formats/ParseError.h>
#include <IO/ReadBufferFromString.h>
#include <IO/ReadHelpers.h>
#include <IO/WriteBufferFromString.h>
#include <IO/WriteHelpers.h>
namespace
{
using namespace DB;
String serializeToString(const Seriali... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>ext serialization with escaping but without quoting.
*/
void serializeTextEscaped(const IColumn & column, size_t row_num, WriteBuffer & ostr, const FormatSettings &) const override;
void deserializeTextEscaped(IColumn & column, ReadBuffer & istr, const FormatSettings &) const override;
b... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Common/SipHash.h>
#include <DataTypes/Serializations/SerializationDate.h>
#include <IO/ReadHelpers.h>
#include <IO/WriteHelpers.h>
#include <Columns/ColumnsNumber.h>
#include <Common/assert_cast.h>
namespace DB
{
UInt128 SerializationDate::getHash(const DateLUTImpl & time_zone_)
{
SipHa... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>serializeText(const IColumn & column, size_t row_num, WriteBuffer & ostr, const FormatSettings &) const override;
void deserializeWholeText(IColumn & column, ReadBuffer & istr, const FormatSettings &) const override;
bool tryDeserializeWholeText(IColumn & column, ReadBuffer & istr, const FormatSet... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>tings &) const
{
LocalDate value;
readCSV(value, istr);
assert_cast<ColumnInt32 &>(column).getData().push_back(value.getExtenedDayNum());
}
bool SerializationDate32::tryDeserializeTextCSV(IColumn & column, ReadBuffer & istr, const FormatSettings &) const
{
LocalDate value;
if (!tryRea... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>ffer & istr, const FormatSettings &) const override;
bool tryDeserializeTextQuoted(IColumn & column, ReadBuffer & istr, const FormatSettings &) const override;
void serializeTextJSON(const IColumn & column, size_t row_num, WriteBuffer & ostr, const FormatSettings &) const override;
void deseri... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>-31 18:36:48' or '1504193808'
{
readText(x, istr, settings, time_zone, utc_time_zone);
assertChar('\'', istr);
}
else /// Just 1504193808 or 01504193808
{
readAsIntText(x, istr);
}
/// It's important to do this at the end - for exception safety.
assert_... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <DataTypes/Serializations/SerializationNumber.h>
#include <DataTypes/DataTypeTime.h>
#include <DataTypes/TimezoneMixin.h>
namespace DB
{
class SerializationDateTime final : public SerializationNumber<UInt32>, public TimezoneMixin
{
private:
explicit SerializationDateTime(const... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|> }
/// Best effort parsing supports datetime in format like "01.01.2000, 00:00:00"
/// and can mistakenly read comma as a part of datetime.
/// For example data "...,01.01.2000,some string,..." cannot be parsed correctly.
/// To fix this problem we first read CSV string ... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>_t row_num, WriteBuffer & ostr, const FormatSettings &) const override;
void deserializeTextCSV(IColumn & column, ReadBuffer & istr, const FormatSettings & settings) const override;
bool tryDeserializeTextCSV(IColumn & column, ReadBuffer & istr, const FormatSettings & settings) const override;
};
... | fim | ClickHouse/ClickHouse | c |
#include <Common/SipHash.h>
#include <DataTypes/Serializations/SerializationDecimal.h>
#include <base/TypeName.h>
#include <Columns/ColumnVector.h>
#include <IO/ReadHelpers.h>
#include <IO/WriteHelpers.h>
#include <IO/readDecimalText.h>
#include <Common/assert_cast.h>
#include <Common/typeid_cast.h>
namespace DB
{
n... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>IColumn & column, ReadBuffer & istr, const FormatSettings &) const override;
void serializeTextJSON(const IColumn & column, size_t row_num, WriteBuffer & ostr, const FormatSettings & settings) const override;
void deserializeTextJSON(IColumn & column, ReadBuffer & istr, const FormatSettings & set... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|> <typename T>
void SerializationDecimalBase<T>::deserializeBinary(Field & field, ReadBuffer & istr, const FormatSettings &) const
{
typename FieldType::NativeType x;
readBinaryLittleEndian(x, istr);
field = DecimalField<T>(T(x), this->scale);
}
template <typename T>
void SerializationDecimalB... | fim | ClickHouse/ClickHouse | cpp |
#pragma once
#include <base/TypeName.h>
#include <DataTypes/Serializations/SimpleTextSerialization.h>
#include <Columns/ColumnDecimal.h>
namespace DB
{
template <typename T>
class SerializationDecimalBase : public SimpleTextSerialization
{
protected:
const UInt32 precision;
const UInt32 scale;
public:
u... | fim | ClickHouse/ClickHouse | c |
#include <Common/SipHash.h>
#include <DataTypes/Serializations/SerializationDetached.h>
#include <Columns/ColumnBLOB.h>
#include <Compression/CompressedWriteBuffer.h>
#include <Compression/CompressionFactory.h>
#include <DataTypes/Serializations/ISerialization.h>
#include <IO/VarInt.h>
#include <Common/Exception.h>
#i... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <DataTypes/Serializations/ISerialization.h>
namespace DB
{
/// Implementation detail for parallel blocks marshalling on pipeline threads.
/// Input column for `serialize` method should be `ColumnBLOB`. To serialize it we simply copy the BLOB into the output buffer.
/// `deserializ... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>r, const FormatSettings & settings) const
{
auto variant_type = decodeDataType(istr);
if (isNothing(variant_type))
{
dynamic_column.insertDefault();
return;
}
auto variant_type_name = variant_type->getName();
const auto & variant_serialization = dynamic_column.getV... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <DataTypes/Serializations/ISerialization.h>
#include <DataTypes/Serializations/SerializationInfoSettings.h>
#include <DataTypes/DataTypeDynamic.h>
#include <Columns/ColumnDynamic.h>
namespace DB
{
class SerializationDynamicElement;
class SerializationDynamic final : public ISeria... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>olumnPtr variant_column = nested_subcolumn.empty() || is_null_map_subcolumn ? result_column->assumeMutable() : result_type->createColumn();
variant_column->reserve(variant_column->size() + limit);
MutableColumnPtr non_nullable_variant_column = variant_column->assumeMutable();
NullM... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <DataTypes/Serializations/SerializationWrapper.h>
namespace DB
{
/// Serialization for Dynamic element when we read it as a subcolumn.
class SerializationDynamicElement final : public SerializationWrapper
{
private:
/// Serialization of SharedVariant. It's used if the requeste... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>:UInt16:
return getLimitsImpl<ColumnUInt16>(indexes_column, num_types);
case TypeIndex::UInt32:
return getLimitsImpl<ColumnUInt32>(indexes_column, num_types);
case TypeIndex::UInt64:
return getLimitsImpl<ColumnUInt64>(indexes_column, num_types);
... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>mn && flattened_column, ColumnDynamic & dynamic_column);
/// Iterate over indexes and calculate the total number of occurrences for each index.
std::vector<size_t> getLimitsForFlattenedDynamicColumn(const IColumn & indexes_column, size_t num_types);
}
<|fim_prefix|>#pragma once
#include <DataTypes/IDat... | fim | ClickHouse/ClickHouse | c |
#include <Common/SipHash.h>
#include <DataTypes/Serializations/SerializationEnum.h>
#include <Columns/ColumnVector.h>
#include <Formats/FormatSettings.h>
#include <IO/ReadHelpers.h>
#include <IO/WriteBufferFromString.h>
#include <IO/WriteHelpers.h>
#include <Common/assert_cast.h>
namespace DB
{
template <typename Ty... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <memory>
#include <DataTypes/Serializations/SerializationNumber.h>
#include <DataTypes/EnumValues.h>
#include <DataTypes/DataTypeEnum.h>
namespace DB
{
template <typename Type>
class SerializationEnum final : public SerializationNumber<Type>
{
private:
using typename Serializa... | fim | ClickHouse/ClickHouse | c |
#include <Common/SipHash.h>
#include <DataTypes/Serializations/SerializationFixedString.h>
#include <Columns/ColumnFixedString.h>
#include <Columns/ColumnConst.h>
#include <Formats/FormatSettings.h>
#include <Formats/ParseError.h>
#include <IO/WriteBuffer.h>
#include <IO/ReadHelpers.h>
#include <IO/WriteHelpers.h>
#... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <DataTypes/Serializations/ISerialization.h>
#include <Common/PODArray.h>
namespace DB
{
class SerializationFixedString final : public ISerialization
{
private:
size_t n;
explicit SerializationFixedString(size_t n_) : n(n_) {}
public:
static UInt128 getHash(size_t n_)... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|> IPv value;
if (!tryReadCSV(value, istr))
return false;
assert_cast<ColumnVector<IPv> &>(column).getData().push_back(value);
return true;
}
template <typename IPv>
void SerializationIP<IPv>::serializeBinary(const Field & field, WriteBuffer & ostr, const FormatSettings &) const
{
... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>n, ReadBuffer & istr, const FormatSettings & settings, bool whole) const override;
void serializeTextQuoted(const IColumn & column, size_t row_num, WriteBuffer & ostr, const FormatSettings & settings) const override;
void deserializeTextQuoted(IColumn & column, ReadBuffer & istr, const FormatSett... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <DataTypes/Serializations/SerializationInfo.h>
#include <Columns/ColumnSparse.h>
#include <DataTypes/DataTypeString.h>
#include <DataTypes/IDataType.h>
#include <IO/ReadHelpers.h>
#include <IO/WriteHelpers.h>
#include <Core/Block.h>
#include <base/EnumReflection.h>
#include <Poco/JSON/JSON.h>
#... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <Core/MergeTreeSerializationEnums.h>
#include <Core/Types_fwd.h>
#include <DataTypes/Serializations/ISerialization.h>
#include <DataTypes/Serializations/SerializationInfoSettings.h>
#include <map>
namespace Poco::JSON
{
class Object;
}
namespace DB
{
class ReadBuffer;
class Read... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>BASIC)
return false;
/// Skip support for sparse serialization of Nullable(Tuple) for now
if (const auto * nullable_type = assert_cast<const DataTypeNullable *>(&type))
{
if (isTuple(nullable_type->getNestedType()))
return false;
}
... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <Core/MergeTreeSerializationEnums.h>
class SipHash;
namespace DB
{
class IDataType;
struct SerializationInfoSettings
{
double ratio_of_defaults_for_sparse = 1.0;
bool choose_kind = false;
MergeTreeSerializationInfoVersion version = MergeTreeSerializationInfoVersion:... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <DataTypes/Serializations/SerializationInfoTuple.h>
#include <DataTypes/DataTypeTuple.h>
#include <Columns/ColumnTuple.h>
#include <Common/Exception.h>
#include <Common/assert_cast.h>
#include <IO/WriteHelpers.h>
#include <Poco/JSON/Object.h>
namespace DB
{
namespace ErrorCodes
{
extern co... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <Core/Names.h>
#include <DataTypes/Serializations/SerializationInfo.h>
namespace DB
{
class SerializationInfoTuple : public SerializationInfo
{
public:
SerializationInfoTuple(MutableSerializationInfos elems_, Names names_);
bool hasCustomSerialization() const override;
... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Common/SipHash.h>
#include <DataTypes/Serializations/SerializationInterval.h>
#include <Columns/ColumnsNumber.h>
#include <Common/Exception.h>
#include <IO/WriteBuffer.h>
#include <Parsers/Kusto/Formatters.h>
#include <base/arithmeticOverflow.h>
namespace DB
{
using ColumnInterval = DataType... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <DataTypes/Serializations/ISerialization.h>
#include <DataTypes/DataTypeInterval.h>
#include <Formats/FormatSettings.h>
#include <Common/IntervalKind.h>
namespace DB
{
class SerializationInterval final : public SerializationNumber<typename DataType<|fim_suffix|>l::FieldType>;
... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Common/SipHash.h>
#include <DataTypes/Serializations/SerializationJSON.h>
#include <IO/WriteHelpers.h>
#include <IO/ReadHelpers.h>
#if USE_SIMDJSON
#include <Common/JSONParsers/SimdJSONParser.h>
#endif
#if USE_RAPIDJSON
#include <Common/JSONParsers/RapidJSONParser.h>
#endif
#include <Common/JSO... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>, const FormatSettings & settings) const override;
void deserializeObject(IColumn & column, std::string_view object, const FormatSettings & settings) const override;
private:
void serializeTextImpl(const IColumn & column, size_t row_num, WriteBuffer & ostr, const FormatSettings & settings, bool ... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>column, &ISerialization::deserializeTextJSON, istr, settings);
}
bool SerializationLowCardinality::tryDeserializeTextJSON(IColumn & column, ReadBuffer & istr, const FormatSettings & settings) const
{
return tryDeserializeImpl(column, &ISerialization::tryDeserializeTextJSON, istr, settings);
}
void S... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|> }
void enumerateStreams(
EnumerateStreamsSettings & settings,
const StreamCallback & callback,
const SubstreamData & data) const override;
void serializeBinaryBulkStatePrefix(
const IColumn & column,
SerializeBinaryBulkSettings & settings,
... | fim | ClickHouse/ClickHouse | c |
#include <DataTypes/Serializations/SerializationMap.h>
#include <DataTypes/DataTypeMap.h>
#include <DataTypes/DataTypesNumber.h>
#include <DataTypes/Serializations/SerializationArray.h>
#include <DataTypes/Serializations/SerializationArrayOffsets.h>
#include <DataTypes/Serializations/SerializationMapKeysOrValues.h>
#i... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <DataTypes/Serializations/SimpleTextSerialization.h>
#include <Columns/ColumnMap.h>
namespace DB
{
class SerializationMapSize;
class SerializationMapKeysOrValues;
class SerializationMapKeyValue;
class SerializationMap final : public SimpleTextSerialization
{
private:
Serializ... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <DataTypes/Serializations/SerializationMapKeyValue.h>
#include <DataTypes/Serializations/SerializationMap.h>
#include <Columns/ColumnArray.h>
#include <DataTypes/DataTypeMap.h>
#include <DataTypes/DataTypeMapHelpers.h>
#include <Common/logger_useful.h>
namespace DB
{
namespace ErrorCodes
{
... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <DataTypes/Serializations/ISerialization.h>
#include <DataTypes/Serializations/SerializationWrapper.h>
namespace DB
{
/// Serialization wrapper for reading a single key's value from a Map column as a subcolumn
/// (e.g. `map['key']`). In the bucketed Map format, this class determi... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>gs.path.push_back(SubstreamType::Bucket);
settings.path.back().bucket = bucket;
keys_or_values_serialization->deserializeBinaryBulkStatePrefix(settings, map_keys_or_values_with_buckets_state->bucket_keys_or_values_states[bucket], cache);
settings.path.pop_back();
}
state =... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|> const IColumn & column,
SerializeBinaryBulkSettings & settings,
SerializeBinaryBulkStatePtr & state) const override;
void serializeBinaryBulkStateSuffix(
SerializeBinaryBulkSettings & settings,
SerializeBinaryBulkStatePtr & state) const override;
void deserial... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <DataTypes/Serializations/SerializationMapSize.h>
#include <DataTypes/Serializations/SerializationMap.h>
#include <Columns/ColumnsNumber.h>
#include <Common/SipHash.h>
namespace DB
{
namespace ErrorCodes
{
extern const int NOT_IMPLEMENTED;
extern const int LOGICAL_ERROR;
}
Serializatio... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|> size_t, WriteBuffer &, const FormatSettings &) const override { throwNoSerialization(); }
void deserializeBinary(IColumn &, ReadBuffer &, const FormatSettings &) const override { throwNoSerialization(); }
void serializeText(const IColumn &, size_t, WriteBuffer &, const FormatSettings &) const ove... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Common/SipHash.h>
#include <DataTypes/Serializations/SerializationNamed.h>
#include <Common/Exception.h>
namespace DB
{
namespace ErrorCodes
{
extern const int LOGICAL_ERROR;
}
SerializationNamed::SerializationNamed(
const SerializationPtr & nested_,
const String & name_,
Subs... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>eam_type);
}
};
void addToPath(SubstreamPath & path) const;
};
SerializationPtr removeNamedSerialization(const SerializationPtr & serialization);
}
<|fim_prefix|>#pragma once
#include <DataTypes/Serializations/SerializationWrapper.h>
namespace DB
{
/// Serialization wrapper that acts ... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>Hash()
{
SipHash hash;
hash.update("Nothing");
return hash.get128();
}
SerializationPtr SerializationNothing::create()
{
return ISerialization::pooled(getHash(), [] { return new SerializationNothing(); });
}
void SerializationNothing::throwNoSerialization()
{
throw Exception(ErrorCod... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>Column & column, ReadBuffer & istr, size_t rows_offset, size_t limit, double avg_value_size_hint) const override;
};
}
<|fim_prefix|>#pragma once
#include <DataTypes/Serializations/SimpleTextSerialization.h>
namespace DB
{
class SerializationNothing final : public SimpleTextSerialization
{
private:
... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>y.
/// It can happen only if there is an unquoted string instead of a number.
/// We also should delete incorrectly deserialized value from nested column.
nested_column.popBack(1);
if constexpr (!throw_exception)
return ReturnType(false);
throw DB::Exc... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>;
static bool tryDeserializeNullEscaped(ReadBuffer & istr, const FormatSettings & settings);
static void serializeNullQuoted(WriteBuffer & ostr);
static bool tryDeserializeNullQuoted(ReadBuffer & istr);
static void serializeNullCSV(WriteBuffer & ostr, const FormatSettings & settings);
... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>lizationNumber<T>::tryDeserializeTextCSV(IColumn & column, ReadBuffer & istr, const FormatSettings & /*settings*/) const
{
FieldType x;
if (!tryReadCSV(x, istr))
return false;
assert_cast<ColumnVector<T> &>(column).getData().push_back(x);
return true;
}
template <typename T>
void ... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>onst FormatSettings &) const override;
void serializeBinary(const IColumn & column, size_t row_num, WriteBuffer & ostr, const FormatSettings &) const override;
void deserializeBinary(IColumn & column, ReadBuffer & istr, const FormatSettings &) const override;
void serializeBinaryBulk(const ICo... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|> std::unordered_map<String, ISerialization::DeserializeBinaryBulkStatePtr> dynamic_path_states;
ISerialization::DeserializeBinaryBulkStatePtr shared_data_state;
SerializationPtr shared_data_serialization;
ISerialization::DeserializeBinaryBulkStatePtr structure_state;
ISerialization::De... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>dered_set<String> paths_to_skip;
std::vector<String> sorted_paths_to_skip;
std::list<re2::RE2> path_regexps_to_skip;
DataTypePtr dynamic_type;
SerializationPtr dynamic_serialization;
private:
std::vector<String> sorted_typed_paths;
};
}
<|fim_prefix|>#pragma once
#include <Columns/C... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|> literal_column, rows_offset, limit, nested_settings, combined_state->literal_state, cache);
/// Deserialize sub-object into a temporary column.
ColumnPtr sub_object_column = sub_object_type->createColumn();
sub_object_serialization->deserializeBinaryBulkWithMultipleStreams(
su... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>izeBinaryBulkSettings & settings,
DeserializeBinaryBulkStatePtr & state,
SubstreamsCache * cache) const override;
void serializeBinary(const Field &, WriteBuffer &, const FormatSettings &) const override { throwNoSerialization(); }
void deserializeBinary(Field &, ReadBuffer &, con... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|> rows_offset,
limit,
settings,
object_distinct_paths_state->bucket_shared_data_paths_state[bucket],
cache);
settings.path.pop_back();
const auto & shared_data_paths_array_column =... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <DataTypes/Serializations/ISerialization.h>
#include <DataTypes/Serializations/SimpleTextSerialization.h>
namespace DB
{
namespace ErrorCodes
{
extern const int NOT_IMPLEMENTED;
}
/// Special serialization that is used for calculation of distinct paths in JSON column.
/// It ... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Columns/ColumnDynamic.h>
#include <Common/SipHash.h>
#include <DataTypes/DataTypeFactory.h>
#include <DataTypes/DataTypeVariant.h>
#include <DataTypes/Serializations/SerializationObject.h>
#include <DataTypes/Serializations/SerializationObjectDynamicPath.h>
#include <DataTypes/Serializations/Ser... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>ultipleStreams(
const IColumn & column,
size_t offset,
size_t limit,
SerializeBinaryBulkSettings & settings,
SerializeBinaryBulkStatePtr & state) const override;
void deserializeBinaryBulkWithMultipleStreams(
ColumnPtr & column,
size_t rows_offs... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>th{shared_data_paths->getDataAt(j)};
auto it = flattened_shared_data_paths.find(path);
/// If we see this path for the first time, add it to the list and create a column for it.
if (it == flattened_shared_data_paths.end())
{
it = flattened_sh... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>ize_t start, size_t end);
/// Deserialize up to limit indexes from the read buffer and collect corresponding paths to the paths_column.
void deserializeIndexesAndCollectPaths(IColumn & paths_column, ReadBuffer & istr, std::vector<String> && paths, size_t rows_offset, size_t limit);
}
<|fim_prefix|>#pragm... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>:get(CurrentMetrics::SerializationCacheBytesInMemory));
}
delete ptr;
}
);
it->second = ret;
return ret;
}
}
}
<|fim_prefix|>#include <DataTypes/Serializations/ISerialization.h>
#include <DataTypes/Serializations/SerializationObjectPool.h>
#include <Common/Cur... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <DataTypes/Serializations/ISerialization.h>
#include <functional>
namespace DB
{
/// Cache for constant serialization objects.
/// Deduplicates identical serializations so that concurrent users of the
/// same type share one object.
namespac<|fim_suffix|>object, which is then inse... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>f);
readBinaryLittleEndian(structure_granule.paths_marks_stream_mark.offset_in_decompressed_block, buf);
readBinaryLittleEndian(structure_granule.paths_substreams_metadata_stream_mark.offset_in_compressed_file, buf);
readBinaryLittleEndian(structure_granule.paths_substreams_metadata_stream_mar... | fim | ClickHouse/ClickHouse | cpp |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.