text stringlengths 14 100k | source stringclasses 1
value | repo stringclasses 810
values | language stringclasses 13
values |
|---|---|---|---|
#pragma once
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wdocumentation-html"
#include <Common/Exception.h>
#include <DataTypes/Serializations/SimpleTextSerialization.h>
#include <boost/algorithm/string/join.hpp>
#include <map>
namespace DB
{
namespace ErrorCodes
{
extern const int NOT_IMPL... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>= paths_data_granule.paths_data.end())
{
/// If no subcolumn is requested, just insert path data into destination column.
if (path_subcolumn.empty())
{
column->assumeMutable()->insertRangeFrom(*path_data_it->second, structure_... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <DataTypes/Serializations/SerializationWrapper.h>
#include <DataTypes/Serializations/SerializationObjectSharedData.h>
namespace DB
{
/// Serialization of dynamic Object paths from shared data.
class SerializationObjectSharedDataPath final : public SerializationWrapper
{
private:
... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Columns/ColumnDynamic.h>
#include <DataTypes/DataTypeFactory.h>
#include <DataTypes/DataTypeVariant.h>
#include <Common/SipHash.h>
#include <DataTypes/Serializations/SerializationObject.h>
#include <DataTypes/Serializations/SerializationObjectTypedPath.h>
#include <IO/ReadHelpers.h>
namespace D... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|> {
}
public:
static UInt128 getHash(const SerializationPtr & nested_, const String & path_);
static SerializationPtr create(const SerializationPtr & nested_, const String & path_);
size_t allocatedBytes() const override;
void enumerateStreams(
EnumerateStreamsSettings & sett... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>conditional_t<sizeof(FloatType) == 4, UInt32, UInt64>>;
constexpr size_t bits = sizeof(Word) * 8;
const size_t slice_size = DataTypeQBit::bitsToBytes(dimension);
const size_t slice_size_bits = slice_size * 8;
std::vector<FloatType> dst(slice_size_bits, FloatType{});
for (size_t bit =... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>ts, char * const * __restrict dst);
/** For a given FixedString column, reads the packed bytes of that column’s bit plane and “scatters” each bit into the
* correct positions of the dst buffer, reconstructing the original row-wise bit layout across all elements.
* The bit_mask T(1) << (si... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|> settings);
}
void SerializationReplicated::serializeTextRaw(const IColumn & column, size_t row_num, WriteBuffer & ostr, const FormatSettings & settings) const
{
const auto & column_replicated = assert_cast<const ColumnReplicated &>(column);
nested->serializeTextRaw(*column_replicated.getNestedCo... | fim | ClickHouse/ClickHouse | cpp |
#pragma once
#include <DataTypes/Serializations/ISerialization.h>
namespace DB
{
/// Serialization for replicated column representation (ColumnReplicated).
/// Right now it can be used only for serializing in output formats (including Native)
/// and not for serializing into MergeTree parts (it requires more complic... | fim | ClickHouse/ClickHouse | c |
#include <Common/SipHash.h>
#include <DataTypes/Serializations/SerializationSparse.h>
#include <Columns/ColumnConst.h>
#include <Columns/ColumnNullable.h>
#include <Columns/ColumnSparse.h>
#include <Columns/ColumnVector.h>
#include <Columns/IColumn.h>
#include <DataTypes/DataTypeNullable.h>
#include <DataTypes/DataTyp... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <DataTypes/Serializations/SerializationNumber.h>
#include <DataTypes/Serializations/ISerialization.h>
namespace DB
{
/// Serialization for sparse representation.
/// Only '{serialize,deserialize}BinaryBulk' makes sense.
/// Format:
/// Values and offsets are written to separate ... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>tings,
DeserializeBinaryBulkStatePtr & state,
SubstreamsCache * cache) const
{
/// Check if the whole String column is already deserialized and we have it in the cache.
settings.path.push_back(Substream::Regular);
if (insertDataFromSubstreamsCacheIfAny(cache, settings, column))
{
... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>& 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 FormatSettings &) const override;
... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Common/SipHash.h>
#include <DataTypes/Serializations/SerializationStringSize.h>
#include <Columns/ColumnString.h>
#include <Columns/ColumnsNumber.h>
namespace DB
{
SerializationStringSize::SerializationStringSize(MergeTreeStringSerializationVersion version_)
: version(version_)
, seri... | fim | ClickHouse/ClickHouse | cpp |
#pragma once
#include <Core/MergeTreeSerializationEnums.h>
#include <DataTypes/Serializations/SerializationNumber.h>
#include <DataTypes/Serializations/SerializationString.h>
namespace DB
{
/// Enables the `.size` subcolumn for string columns.
class SerializationStringSize final : public SerializationNumber<UInt64>
... | fim | ClickHouse/ClickHouse | c |
#include <DataTypes/DataTypeFactory.h>
#include <DataTypes/DataTypeObject.h>
#include <DataTypes/DataTypeVariant.h>
#include <Common/SipHash.h>
#include <DataTypes/Serializations/SerializationObject.h>
#include <DataTypes/Serializations/SerializationSubObject.h>
#include <DataTypes/Serializations/SerializationSubObject... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <DataTypes/Serializations/ISerialization.h>
#include <DataTypes/Serializations/SimpleTextSerialization.h>
namespace<|fim_suffix|>of a sub-object Object subcolumns.
/// For example, if we have type JSON and data {"a" : {"b" : {"c" : 42, "d" : "Hello"}}, "c" : [1, 2, 3], "d" : 42}
//... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Common/SipHash.h>
#include <DataTypes/Serializations/SerializationSubObjectSharedData.h>
#include <DataTypes/Serializations/SerializationObjectHelpers.h>
#include <DataTypes/DataTypeObject.h>
#include <Columns/ColumnArray.h>
#include <Columns/ColumnObject.h>
#include <Common/assert_cast.h>
name... | fim | ClickHouse/ClickHouse | cpp |
#pragma once
#include <DataTypes/Serializations/ISerialization.h>
#include <DataTypes/Serializations/SimpleTextSerialization.h>
#include <DataTypes/Serializations/SerializationObjectSharedData.h>
namespace DB
{
namespace ErrorCodes
{
extern const int NOT_IMPLEMENTED;
}
/// Serialization of shared data for a sub... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <DataTypes/Serializations/SerializationDateTime.h>
#include <Columns/ColumnVector.h>
#include <DataTypes/DataTypeTime.h>
#include <Formats/FormatSettings.h>
#include <IO/Operators.h>
#include <IO/ReadBufferFromString.h>
#include <IO/ReadHelpers.h>
#include <IO/WriteHelpers.h>
#include <IO/parseD... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <Common/SipHash.h>
#include <DataTypes/Serializations/SerializationTime64.h>
#include <Columns/ColumnVector.h>
#include <Formats/FormatSettings.h>
#include <IO/ReadBufferFromString.h>
#include <IO/ReadHelpers.h>
#include <IO/WriteBufferFromString.h>
#include <IO/WriteHelpers.h>
#include <IO/pars... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <DataTypes/Serializations/SerializationDecimalBase.h>
#include <Common/DateLUT.h>
class DateLUTImpl;
namespace DB
{
class DataTypeTime64;
class SerializationTime64 final : public SerializationDecimalBase<Time64>
{
private:
explicit SerializationTime64(UInt32 scale_);
exp... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>Ptr & state,
SubstreamsCache * cache) const
{
if (elems.empty())
{
if (insertDataFromSubstreamsCacheIfAny(cache, settings, column))
{
/// Data was inserted from substreams cache.
}
else if (ReadBuffer * stream = settings.getter(settings.path))
... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>eStreams(
const IColumn & column,
size_t offset,
size_t limit,
SerializeBinaryBulkSettings & settings,
SerializeBinaryBulkStatePtr & state) const override;
void deserializeBinaryBulkWithMultipleStreams(
ColumnPtr & column,
... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>onst
{
UUID x = field.safeGet<UUID>();
writeBinaryLittleEndian(x, ostr);
}
void SerializationUUID::deserializeBinary(Field & field, ReadBuffer & istr, const FormatSettings &) const
{
UUID x;
readBinaryLittleEndian(x, istr);
field = NearestFieldType<UUID>(x);
}
void SerializationUUID:... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <DataTypes/Serializations/SerializationNumber.h>
namespace DB
{
class SerializationUUID final : public SimpleTextSerialization
{
private:
SerializationUUID() = default;
public:
static UInt128 getHash();
static SerializationPtr create();
void serializeText(const I... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>Column & variant_column, const SerializationPtr & variant_serialization, ReadBuffer & buf, const FormatSettings & settings_)
{
return variant_serialization->tryDeserializeTextEscaped(variant_column, buf, settings_);
};
return tryDeserializeTextEscapedOrRawImpl(column, istr, settings, ... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>be deserialized
/// into String type), so we uses some heuristics to determine the more optimal order.
static std::vector<size_t> getVariantsDeserializeTextOrder(const DataTypes & variant_types);
private:
friend SerializationVariantElement;
friend SerializationVariantElementNullMap;
... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>te null-map for our variant if we don't already have it.
std::optional<NullMap> null_map_from_discriminators;
if (!null_map)
{
null_map_from_discriminators = NullMap();
null_map_from_discriminators->reserve(local_discriminators->size());
const auto & local_discriminator... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>streamPath & path) const;
void removeVariantFromPath(SubstreamPath & path) const;
};
}
<|fim_prefix|>#pragma once
#include <DataTypes/Serializations/SerializationWrapper.h>
#include <DataTypes/DataTypeNullable.h>
#include <Columns/ColumnVariant.h>
namespace DB
{
class SerializationVariant;
class S... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>minators->size());
const auto & local_discriminators_data = assert_cast<const ColumnVariant::ColumnDiscriminators &>(*local_discriminators).getData();
for (auto local_discr : local_discriminators_data)
null_map_data.push_back(local_discr != local_variant_discriminator);
return null_ma... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>element_name_, ColumnVariant::Discriminator variant_discriminator_);
size_t allocatedBytes() const override;
void enumerateStreams(
EnumerateStreamsSettings & settings,
const StreamCallback & callback,
const SubstreamData & data) const override;
void serializeBinaryB... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>_num, ostr, settings);
}
void SerializationWrapper::deserializeTextQuoted(IColumn & column, ReadBuffer & istr, const FormatSettings & settings) const
{
nested_serialization->deserializeTextQuoted(column, istr, settings);
}
bool SerializationWrapper::tryDeserializeTextQuoted(IColumn & column, ReadBuf... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <DataTypes/Serializations/ISerialization.h>
namespace DB
{
/// Wrapper for serialization, which calls methods, which are not overridden, from nested serialization.
/// You can inherit this class, when you need to override bunch of methods, to avoid boilerplate code.
class Serializ... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|> bool tryDeserializeTextQuoted(IColumn & column, ReadBuffer & istr, const FormatSettings & settings) const override
{
return tryDeserializeText(column, istr, settings, false);
}
void deserializeTextJSON(IColumn & column, ReadBuffer & istr, const FormatSettings & settings) const over... | fim | ClickHouse/ClickHouse | c |
#include <DataTypes/Serializations/getSubcolumnsDeserializationOrder.h>
#include <Common/Exception.h>
namespace DB
{
namespace ErrorCodes
{
extern const int LOGICAL_ERROR;
}
std::vector<size_t> getSubcolumnsDeserializationOrder(
const String & column_name,
const std::vector<ISerialization::SubstreamData>... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <DataTypes/Serializations/ISerializatio<|fim_suffix|>st ISerialization::StreamFileNameSettings & stream_file_name_settings);
}
<|fim_middle|>n.h>
namespace DB
{
/// When we deserialize several subcolumns of the same column it's always better to deserialize
/// subcolumns in order ... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Columns/ColumnObject.h>
#include <DataTypes/DataTypeFactory.h>
#include <DataTypes/Serializations/SerializationObject.h>
#include <IO/ReadBufferFromString.h>
#include <gtest/gtest.h>
using namespace DB;
TEST(ObjectSerialization, FieldBinarySerialization)
{
auto type = DataTypeFactory::ins... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>omString write_buffer(serialized_data);
FormatSettings format_settings;
serialization_float32->serializeBinary(test_field, write_buffer, format_settings);
ReadBufferFromString read_buffer(serialized_data);
Field deserialized_field;
serialization_float32->deserializeBinary(deserialized... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>;
}
TEST(SerializationInfoJSON, FromJSONUnknownKind)
{
expectMalformedKindFails("FooBar");
}
TEST(SerializationInfoJSON, FromJSONKindWrongCase)
{
expectMalformedKindFails("sparse");
}
TEST(SerializationInfoJSON, FromJSONKindAllCaps)
{
expectMalformedKindFails("SPARSE");
}
TEST(SerializationInf... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <DataTypes/Serializations/SimpleTextSerialization.h>
#include <DataTypes/Serializations/SerializationArray.h>
#include <Columns/ColumnArray.h>
#include <Columns/ColumnsNumber.h>
#include <Formats/FormatSettings.h>
#include <IO/ReadBufferFromMemory.h>
#include <Common/Exception.h>
#include <gtest... | fim | ClickHouse/ClickHouse | cpp |
#include <Columns/ColumnString.h>
#include <DataTypes/DataTypeFactory.h>
#include <DataTypes/DataTypeString.h>
#include <IO/ReadBufferFromString.h>
#include <Common/MemoryTracker.h>
#include <Common/ThreadStatus.h>
#include <gtest/gtest.h>
namespace DB
{
namespace ErrorCodes
{
extern const int MEMORY_... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <Core/Types.h>
#include <Common/DateLUT.h>
/** Mixin-class that manages timezone info for timezone-aware DateTime implementations
* Could be used as a (second) base for a class implementing IDateType/ISer<|fim_suffix|>ult;
explicit TimezoneMixin(std::string_view time_zone_n... | fim | ClickHouse/ClickHouse | c |
#include <DataTypes/Utils.h>
#include <DataTypes/DataTypesDecimal.h>
#include <DataTypes/DataTypeNullable.h>
#include <DataTypes/DataTypeLowCardinality.h>
#include <DataTypes/DataTypeArray.h>
#include <DataTypes/DataTypeMap.h>
#include <DataTypes/DataTypeTuple.h>
namespace DB
{
bool canBeSafelyCast(const DataTypePtr ... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <DataTypes/IDataType.h>
namespace DB<|fim_suffix|>lyCast(const DataTypePtr & from_type, const DataTypePtr & to_type);
}
<|fim_middle|>
{
/** Returns true if from_type can be safely cast to to_type.
*
* Examples:
* From type UInt8 to type UInt16 returns true.
* From type U... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <DataTypes/convertMySQLDataType.h>
#include <Core/Field.h>
#include <base/types.h>
#include <Core/MultiEnum.h>
#include <Core/SettingsEnums.h>
#include <Parsers/ASTFunction.h>
#include <Parsers/IAST.h>
#include <DataTypes/DataTypeDate.h>
#include <DataTypes/DataTypeDate32.h>
#include <DataTypes/... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>signed, size_t length, size_t precision, size_t scale);
}
<|fim_prefix|>#pragma once
#include <string>
#include <Core/MultiEnum.h>
#include <DataTypes/IDataType.h>
namespace DB
{
enum class MySQLDataTypesSupport : uint8_t;
/// Convert MySQL type to ClickHouse data type.
DataTypePtr convertMySQLDataTyp... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>(nested_type->getTypeId())
{
case TypeIndex::Dynamic:
return nested_type;
default:
throw Exception(ErrorCodes::INCORRECT_DATA, "Couldn't parse 'optional' type from YT(incorrect nested type)");
}
}
return std::make_shared<Data... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>json);
bool isYTSaurusTypesCompatible(std::shared_ptr<const IDataType> ch_type, std::shared_ptr<const IDataType> yt_type, bool allow_nullable);
}
<|fim_prefix|>#pragma once
#include <memory>
#include <base/types.h>
#include <Core/MultiEnum.h>
#include <DataTypes/IDataType.h>
#inc<|fim_middle|>lude <Poc... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>
return ast_data_type;
}
}
<|fim_prefix|>#include <DataTypes/dataTypeToAST.h>
#include <DataTypes/IDataType.h>
#include <Core/Defines.h>
#include <Parsers/ASTDataType.h>
#include <Parsers/ParserDataType.h>
#include <Parsers/parseQuery.h>
namespace DB
{
namespace ErrorCodes
{
extern const int ... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <boost/smart_ptr/intrusive_ptr.hpp>
#include <memory>
namespace DB
{
class ASTDataType;
class IDataType;
using DataTypePtr = std::shared_ptr<const IDataTyp<|fim_suffix|>.
boost::intrusive_ptr<ASTDataType> dataTypeToAST(const DataTypePtr & data_type);
}
<|fim_middle|>e>;
/// Conv... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <DataTypes/flattenTuple.h>
#include <DataTypes/DataTypeTuple.h>
#include <DataTypes/DataTypeArray.h>
#include <DataTypes/DataTypeNullable.h>
#include <Columns/ColumnTuple.h>
#include <Columns/ColumnArray.h>
#include <Columns/ColumnNullable.h>
namespace DB
{
namespace
{
void flattenTupleTypeImp... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>r & column);
}
<|fim_prefix|>#pragma once
#include <DataTypes/IDataType.h>
namespace DB
{
/// Flattens nested Tuple to plain Tuple. I.e extracts all paths and types from tuple:
/// Tuple(t Tuple(c1 UInt32, c2 String), c3 UInt64) -><|fim_middle|> Tuple(t.c1 UInt32, t.c2 String, c3 UInt32)
/// It also g... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <base/types.h>
#include <IO/ReadBufferFromMemory.h>
#include <IO/ReadHelpers.h>
#include <DataTypes/IDataType.h>
#include <DataTypes/DataTypeFactory.h>
#include <Common/MemoryTracker.h>
#include <Common/CurrentThread.h>
#include <Common/ThreadStatus.h>
#include <Parsers/ParserDataType.h>
#inc... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>ypes.size() == 2 && types.contains(TypeIndex::Nothing);
if (!only_string)
return throwOrReturn<on_error>(types, "because some of them are String and some of them are not", ErrorCodes::NO_COMMON_TYPE);
return std::make_shared<DataTypeString>();
}
auto numeric_type = ge... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>emplate <LeastSupertypeOnError on_error = LeastSupertypeOnError::Throw>
DataTypePtr getLeastSupertype(const TypeIndexSet & types);
DataTypePtr getLeastSupertypeOrString(const TypeIndexSet & types);
DataTypePtr tryGetLeastSupertype(const TypeIndexSet & types);
/// A vector that shows the conversion rate... | fim | ClickHouse/ClickHouse | c |
#include <IO/WriteBufferFromString.h>
#include <IO/Operators.h>
#include <Common/typeid_cast.h>
#include <DataTypes/getMostSubtype.h>
#include <DataTypes/DataTypeArray.h>
#include <DataTypes/DataTypeTuple.h>
#include <DataTypes/DataTypeNullable.h>
#include <DataTypes/DataTypeNothing.h>
#include <DataTypes/DataTypeStr... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <DataTypes/IDataType.h>
namespace DB
{
/** Get data type that covers intersection of all possible values of passed data<|fim_suffix|> common subtype for all types.
* Examples: most common subtype for UInt16, UInt8 and Int8 - UInt16.
* Examples: most common subtype for Array(U... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <DataTypes/DataTypeArray.h>
#include <DataTypes/DataTypeMap.h>
#include <DataTypes/DataTypeTuple.h>
#include <DataTypes/hasNullable.h>
namespace DB
{
bool hasNullable(const DataTypePtr & type)
{
if (isNullableOrLowCardinalityNullable(type))
return true;
if (const DataTypeArray ... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>r & type);
}
<|fim_prefix|>#pragma once
#include <DataTypes/IDataType.h>
namespace DB
{
bool hasNullable(const DataTyp<|fim_middle|>ePt<|endoftext|> | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|> values.
For `Time64`, negative inputs are preserved for both text (e.g., `'-01:02:03.123'`) and numeric inputs (e.g., `-3723.123`).
**Saturation**.
The time-of-day component is capped to the range [-999:59:59.xxx, 999:59:59.xxx] when converting to components or serialising to text.
The stored numeric va... | fim | ClickHouse/ClickHouse | cpp |
#include <DataTypes/DataTypeFactory.h>
#include <DataTypes/IDataType.h>
#include <Parsers/ASTFunction.h>
#include <Parsers/ASTIdentifier.h>
#include <Parsers/ASTLiteral.h>
#include <Parsers/ASTExpressionList.h>
#include <Parsers/ASTObjectTypeArgument.h>
#include <gtest/gtest.h>
using namespace DB;
/// Regression tes... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>function has `arguments` with zero children — `children[0]`
/// reads past the end of the vector.
TEST(DataTypeObject, CreateJSONWithEqualsZeroChildrenDoesNotCrash)
{
auto & factory = DataTypeFactory::instance();
auto equals_args = make_intrusive<ASTExpressionList>();
auto equals_func = make... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <Columns/IColumn.h>
#include <Core/Field.h>
#include <DataTypes/DataTypeFactory.h>
#include <DataTypes/IDataType.h>
#include <Formats/FormatSettings.h>
#include <IO/ReadBuffer.h>
#include <gtest/gtest.h>
#include <string>
#include <vector>
template <typename T>
inline std::ostream& operator<<... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>ource_columns).toString(), columns_with_nested.toString());
}
<|fim_prefix|>#include <DataTypes/NestedUtils.h>
#include <DataTypes/DataTypesNumber.h>
#include <DataTypes/DataTypeArray.h>
#include <DataTypes/DataTypeNested.h>
#include <gtest/gtest.h>
using namespace DB;
GTEST_TEST(NestedUtils, collect)
{... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <gtest/gtest.h>
#include <DataTypes/DataTypeFactory.h>
#include <DataTypes/IDataType.h>
#include <DataTypes/dataTypeToAST.h>
#include <Parsers/ASTDataType.h>
using namespace DB;
static void check(const std::string & type_name)
{
auto type = DataTypeFactory::instance().get(type_name);
a... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>ype));
return data_types;
}
struct TypesTestCase
{
const char * from_types = nullptr;
const char * expected_type = nullptr;
};
static std::ostream & operator<<(std::ostream & ostr, const TypesTestCase & test_case)
{
ostr << "TypesTestCase{\"" << test_case.from_types << "\", ";
if (t... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <gtest/gtest.h>
#include <Core/Field.h>
#include <DataTypes/DataTypesBinaryEncoding.h>
#include <DataTypes/DataTypeDateTime64.h>
#include <DataTypes/DataTypeFixedString.h>
#include <DataTypes/DataTypeEnum.h>
#include <DataTypes/DataTypesDecimal.h>
#include <DataTypes/DataTypeFunction.h>
#include ... | fim | ClickHouse/ClickHouse | cpp |
#include <DataTypes/DataTypeFactory.h>
#include <DataTypes/DataTypeTuple.h>
#include <DataTypes/DataTypesNumber.h>
#include <DataTypes/Serializations/SerializationDetached.h>
#include <gtest/gtest.h>
using namespace DB;
/// Regression test: DataTypeTuple::createColumn must handle SerializationDetached
/// without th... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>true), (std::pair<std::string, std::string>{"1a", "b"}));
ASSERT_EQ(Nested::splitName(String("a.b1.b2"), true), (std::pair<std::string, std::string>{"a.b1", "b2"}));
ASSERT_EQ(Nested::splitName(String("a.b1.2a.3a"), true), (std::pair<std::string, std::string>{"a.b1.2a", "3a"}));
ASSERT_EQ(Nest... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <memory>
#include <DataTypes/convertYTsaurusDataType.h>
#include <Storages/ColumnsDescription.h>
#include <gtest/gtest.h>
#include <Poco/JSON/Object.h>
#include <Poco/JSON/Parser.h>
#include <Poco/Dynamic/Var.h>
#include <DataTypes/DataTypeNullable.h>
#include <DataTypes/DataTypesNumber.h>
#inclu... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>(type_map->getKeyType());
value_types.emplace_back(type_map->getValueType());
}
transformTypesRecursively(key_types, transform_simple_types, transform_complex_types, format_settings);
transformTypesRecursively(value_types, transform_simple_types, transf... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <DataTypes/IDataType.h>
#include <functional>
namespace DB
{
struct FormatSettings;
/// Function that applies custom transformation functions to provided types recursively.
/// Implementation is similar to function getLeastSuperType:
/// If all types are Array/Map/Tuple/Nullable,... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <DataTypes/validateGroupByKeyType.h>
#include <DataTypes/IDataType.h>
#include <Co<|fim_suffix|>ng this column to a specific data type. "
"Set setting allow_suspicious_types_in_group_by = 1 in order to allow it");
};
check(*key_type);
key_type->forEachChild(check);
}
... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <DataTypes/IDataType.h>
namespace DB
{
/// Validates that the data t<|fim_suffix|> window PARTITION BY). Throws ILLEGAL_COLUMN if Dynamic or Variant types
/// are found and allow_suspicious_types is false.
void validateGroupByKeyType(const DataTypePtr & key_type, bool allow_suspic... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Databases/DDLDependencyVisitor.h>
#include <Dictionaries/getDictionaryConfigurationFromAST.h>
#include <Databases/removeWhereConditionPlaceholder.h>
#include <Interpreters/ApplyWithSubqueryVisitor.h>
#include <Interpreters/Cluster.h>
#include <Interpreters/Context.h>
#include <Interpreters/misc.... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <Core/QualifiedTableName.h>
#include <Interpreters/Context_fwd.h>
#incl<|fim_suffix|>Name>;
struct CreateQueryDependencies
{
TableNamesSet dependencies;
std::optional<StorageID> mv_to_dependency;
std::optional<StorageID> mv_from_dependency;
};
/// Returns a list of al... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Databases/DDLLoadingDependencyVisitor.h>
#include <Databases/DDLDependencyVisitor.h>
#include <Dictionaries/getDictionaryConfigurationFromAST.h>
#include "config.h"
#if USE_LIBPQXX
#include <Storages/PostgreSQL/StorageMaterializedPostgreSQL.h>
#endif
#include <Interpreters/Context.h>
#include <I... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <Core/QualifiedTableName.h>
#include <Parsers/IAST_fwd.h>
#include <Interpreters/InDepthNodeVisitor.h>
namespace DB
{
class ASTFunction;
class ASTFunctionWithKeyValueArguments;
class ASTStorage;
using TableNamesSet = std::unordered_set<QualifiedTableName>;
/// Returns a list of ... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Databases/DDLRenamingVisitor.h>
#include <Dictionaries/getDictionaryConfigurationFromAST.h>
#include <Interpreters/DatabaseCatalog.h>
#include <Interpreters/InDepthNodeVisitor.h>
#include <Interpreters/evaluateConstantExpression.h>
#include <Interpreters/Context.h>
#include <Common/isLocalAddres... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <Core/Types.h>
#include <Parsers/IAST_fwd.h>
#include <Core/QualifiedTableName.h>
#include <Interpreters/InDepthNodeVisitor.h>
#include <memory>
#include <unordered_map>
namespace DB
{
class Context;
using ContextPtr = std::shared_ptr<const Context>;
class DDLRenamingMap;
/// Cha... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Databases/DataLake/Common.h>
#include <DataTypes/DataTypeArray.h>
#include <DataTypes/DataTypeDate.h>
#include <DataTypes/DataTypeDateTime64.h>
#include <DataTypes/DataTypeFactory.h>
#include <DataTypes/DataTypeFixedString.h>
#include <DataTypes/DataTypeMap.h>
#include <DataTypes/DataTypeNullab... | fim | ClickHouse/ClickHouse | cpp |
#pragma once
#include <Core/NamesAndTypes.h>
#include <Core/Types.h>
namespace DataLake
{
String trim(const String & str);
std::vector<String> splitTypeArguments(const String & type_str);
DB::DataTypePtr getType(const String & type_name, bool nullable, const String & prefix = "");
/// Parse a string, containing a... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#pragma once
#include <unordered_set>
#include <Core/Types.h>
#include <Core/Field.h>
namespace DataLake
{
static constexpr auto DATABASE_ENGINE_NAME = "DataLakeCatalog";
static constexpr std::string_view FILE_PATH_PREFIX = "file:/";
/// Some catalogs (Unity or Glue) may store not only Iceberg/DeltaLa... | fim | ClickHouse/ClickHouse | c |
#include <algorithm>
#include <array>
#include <memory>
#include <Databases/DataLake/DatabaseDataLake.h>
#include <Core/SettingsEnums.h>
#include <Core/UUID.h>
#include <Databases/DataLake/HiveCatalog.h>
#include <Storages/ObjectStorage/DataLakes/DataLakeStorageSettings.h>
#include <Databases/DataLake/DatabaseDataLakeS... | fim | ClickHouse/ClickHouse | cpp |
#pragma once
#include "config.h"
#if USE_AVRO && USE_PARQUET
#include <Databases/DataLake/DataLakeConstants.h>
#include <Databases/DatabasesCommon.h>
#include <Databases/DataLake/DatabaseDataLakeSettings.h>
#include <Databases/DataLake/ICatalog.h>
#include <Storages/ObjectStorage/StorageObjectStorage.h>
#include <Poc... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>", "Access id of DLF token for Paimon REST Catalog", 0) \
DECLARE(String, dlf_access_key_secret, "", "Access secret of DLF token for Paimon REST Catalog", 0) \
DECLARE(Bool, force_add_bucket, false, "Add bucket name to the metadata path", 0) \
#define LIST_OF_DATABASE_ICEBERG_SETTINGS(M, ALIAS) \... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>unique_ptr<DatabaseDataLakeSettingsImpl> impl;
};
}
<|fim_prefix|>#pragma once
#include <Core/BaseSettingsFwdMacros.h>
#include <Storages/ObjectStorage/StorageObjectStorageSettings.h>
#include <Core/SettingsEn<|fim_middle|>ums.h>
#include <Core/SettingsFields.h>
namespace DB
{
class ASTStorage;
struct ... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#pragma once
#include <Core/Types.h>
namespace DB
{
enum class DatabaseDataLakeStorageType : uint8_t
{
S3,
Azure,
Local,
HDFS,
/// Fake storage in case when catalog store not only
/// primary-type tables (DeltaLake or Iceberg), but, for
/// example, something else like INFORM... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>ampType(column.GetName(), result, column_type);
}
schema.push_back({column.GetName(), getType(column_type, can_be_nullable)});
}
result.setSchema(schema);
}
}
else
{
if (outcome.GetError().GetErrorType() == Aws::Glue::Glu... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>ring & glue_column_type) const;
String resolveMetadataPathFromTableLocation(const String & table_location, const TableMetadata & table_metadata) const;
struct ObjectStorageWithPath
{
DB::ObjectStoragePtr object_storage;
String bucket_name;
String table_path; /// Path... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>nd(false)
.withMethod(method)
.withOutCallback(out_stream_callaback)
.create(credentials);
}
std::pair<Poco::Dynamic::Var, std::string> makeHTTPRequestAndReadJSON(
const std::string & endpoint,
DB::ContextPtr context,
const Poco::Net::HTTPBasicCredentials & credentials... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <IO/ReadWriteBufferFromHTTP.h>
#include <functional>
#include <Poco/JSON/Parser.h>
namespace DataLake
{
DB::ReadWriteBufferFromHTTPPtr createReadBuffer(
const std::string & endpoint,
DB::ContextPtr context,
const Poco::Net::HTTPBasicCredentials & credentials,
const... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>che::Hadoop::Hive::Table table;
executeWithRetry([&]() TSA_NO_THREAD_SAFETY_ANALYSIS { client->get_table(table, namespace_name, table_name); });
if (table.tableName.empty())
return false;
if (result.requiresLocation())
{
if (table.sd.location.empty())
result.... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>::shared_ptr<apache::thrift::transport::TTransport> socket;
mutable std::shared_ptr<apache::thrift::transport::TTransport> transport;
mutable std::shared_ptr<apache::thrift::protocol::TBinaryProtocol> protocol;
/// Somehow API of apache::thrift::transport::TBufferBase is not thread-safe.
... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Databases/DataLake/ICatalog.h>
#include <Common/Exception.h>
#include <Common/logger_useful.h>
#include <Poco/String.h>
#include <filesystem>
#include <Common/FailPoint.h>
#include <Poco/URI.h>
namespace DB::ErrorCodes
{
extern const int NOT_IMPLEMENTED;
extern const int LOGICAL_ERROR... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <optional>
#include <Core/Types.h>
#include <Core/NamesAndTypes.h>
#include <Core/SettingsEnums.h>
#include <Common/SettingsChanges.h>
#include <Interpreters/StorageID.h>
#include <Databases/DataLake/StorageCredentials.h>
#include <Storages/ObjectStorage/StorageObjectStorageSettings.... | fim | ClickHouse/ClickHouse | c |
#include "config.h"
#if USE_AVRO
#include <algorithm>
#include <chrono>
#include <cstddef>
#include <cstdint>
#include <map>
#include <memory>
#include <optional>
#include <sstream>
#include <unordered_map>
#include <vector>
#include <Core/Names.h>
#include <Databases/DataLake/Common.h>
#include <Databases/DataLake/... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>, const String & table_name, TableMetadata & result) const override;
std::optional<StorageType> getStorageType() const override { return storage_type; }
DB::DatabaseDataLakeCatalogType getCatalogType() const override { return DB::DatabaseDataLakeCatalogType::PAIMON_REST; }
private:
using St... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>nly for debugging.
LOG_DEBUG(log, "Received metadata for table {}: {}", table_name, json_str);
#endif
Poco::JSON::Parser parser;
Poco::Dynamic::Var json = parser.parse(json_str);
const Poco::JSON::Object::Ptr & object = json.extract<Poco::JSON::Object::Ptr>();
auto metadata_object = ... | fim | ClickHouse/ClickHouse | cpp |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.