text stringlengths 14 100k | source stringclasses 1
value | repo stringclasses 810
values | language stringclasses 13
values |
|---|---|---|---|
<|fim_suffix|> auto block_key = block_keys_extractor.extractCurrentKey();
const auto * it = requested_key_to_index.find(block_key);
chassert(it);
auto & result_data_found_indexes = it->getMapped();
for (size_t result_data_found_index : result_data_fou... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <atomic>
#include <Dictionaries/DictionaryHelpers.h>
#include <Dictionaries/DictionaryStructure.h>
#include <Dictionaries/IDiction<|fim_suffix|>ectDictionary<DictionaryKeyType::Simple>;
extern template class DirectDictionary<DictionaryKeyType::Complex>;
}
<|fim_middle|>ary.h>
#inc... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Dictionaries/Embedded/GeoDictionariesLoader.h>
#include <Poco/Util/AbstractConfiguration.h>
#include <Dictionaries/Embedded/GeodataProviders/HierarchiesProvider.h>
#include <Dictionaries/Embedded/GeodataProviders/NamesProvider.h>
namespace DB
{
std::unique_ptr<RegionsHierarchies> GeoDictionar... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>tionaries/Embedded/RegionsHierarchies.h>
#include <Dictionaries/Embedded/RegionsNames.h>
#include <Poco/Util/AbstractConfiguration.h>
namespace DB
{
// Default implementation of geo dictionaries loader used by native server application
class GeoDictionariesLoader
{
public:
static std::unique_ptr<Re... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#pragma o<|fim_suffix|>ion;
};
struct RegionNameEntry
{
RegionID id{};
std::string name;
};
}
<|fim_middle|>nce
#include <string>
#include <Dictionaries/Embedded/GeodataProviders/Types.h>
namespace DB
{
struct RegionEntry
{
RegionID id;
RegionID parent_id;
RegionType type;
Reg... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>e_shared<RegionsHierarchyDataSource>(path);
}
IRegionsHierarchyDataSourcePtr RegionsHierarchiesDataProvider::getHierarchySource(const std::string & name) const
{
auto found = hierarchy_files.find(name);
if (found != hierarchy_files.end())
{
const auto & hierarchy_file_path = found->s... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <Dictionaries/Embedded/GeodataProviders/IHierarchiesProvider.h>
#include <Common/UnorderedMapWithMemoryTracking.h>
#include <Common/FileUpdatesTracker.<|fim_suffix|>files are loaded, and the hierarchy of regions is put on the `suffix` key.
*
* For example, if /opt/geo/r... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Dictionaries/Embedded/GeodataProviders/HierarchyFormatReader.h>
#include <IO/ReadHelpers.h>
#include <IO/WriteHelpers.h>
namespace DB
{
bool RegionsHierarchyFormatReader::readNext(RegionEntry & entry)
{
while (!input->eof())
{
/** Our internal geobase has negative numbers,
... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <IO/ReadBuffer.h>
#include <Dictionaries/Embedded/GeodataProviders/IHierarchiesProvider.h>
namespace DB
{
// Reads regions hierarchy in geoexport format
class RegionsHierarchyFormatR<|fim_suffix|>try) override;
};
}
<|fim_middle|>eader : public IRegionsHierarchyReader
{
private:
... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>rcePtr getDefaultHierarchySource() const = 0;
virtual IRegionsHierarchyDataSourcePtr getHierarchySource(const std::string & name) const = 0;
virtual ~IRegionsHierarchiesDataProvider() = default;
};
using IRegionsHierarchiesDataProviderPtr = std::shared_ptr<IRegionsHierarchiesDataProvider>;
}
<|... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#pragma once
#include <memory>
#include <Dictionaries/Embedded/GeodataProviders/Entries.h>
namespace DB
{
// Iterates over all name entries in data source
class I<|fim_suffix|>r() = default;
};
using IRegionsNamesDataProviderPtr = std::unique_ptr<IRegionsNamesDataProvider>;
}
<|fim_middle|>LanguageRe... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>;
}
}
<|fim_prefix|>#include <Dictionaries/Embedded/GeodataProviders/NamesFormatReader.h>
#include <IO/ReadHelpers.h>
namespace DB
{
bool LanguageRegionsNamesFormatReader::readNext(RegionNameEntry & entry)
{
while (!input->eof<|fim_middle|>())
{
Int32 read_region_id = 0;
std::s... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>Ptr input;
public:
explicit LanguageRegionsNamesFormatReader(ReadBufferPtr input_) : input(std::move(input_)) {}
bool readNext(RegionNameEntry & entry) override;
};
}
<|fim_prefix|>#pragma once
#include <IO/ReadBuffer.h>
#include <Dictionaries/Embe<|fim_middle|>dded/GeodataProviders/INamesProv... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Dictionaries/Embedded/GeodataProviders/NamesProvider.h>
#include <IO/ReadBufferFromFile.h>
#include <Dictionaries/Embedded/GeodataProviders/NamesFormatReader.h>
#include <filesystem>
namespace fs = std::filesystem;
namespace DB
{
bool LanguageRegionsNamesDataSource::isModified() const
{
... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <Common/FileUpdatesTracker.h>
#include <Dictionaries/Embedded/GeodataProviders/INamesProvider.h>
namespace DB
{
// Represents local file with list of regions ids / names
class LanguageRegionsNamesDataSource : public ILanguageRegionsNamesDataSource
{
private:
std::string path;
... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#pragma once
#include <base/types.h>
namespac<|fim_suffix|>y = 6,
};
}
<|fim_middle|>e DB
{
using RegionID = UInt32;
using RegionDepth = UInt8;
using RegionPopulation = UInt32;
enum class RegionType : int8_t
{
Hidden = -1,
Continent = 1,
Country = 3,
District = 4,
Area = 5,
Ci... | fim | ClickHouse/ClickHouse | c |
#include <Dictionaries/Embedded/RegionsHierarchies.h>
#include <Poco/DirectoryIterator.h>
#include <Common/logger_useful.h>
namespace DB
{
RegionsHierarchies::RegionsHierarchies(IRegionsHierarchiesDataProviderPtr data_provider)
{
LoggerPtr log = getLogger("RegionsHierarchies");
LOG_DEBUG(log, "Adding defaul... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <Common/UnorderedMapWithMemoryTracking.h>
#include <Poco/Exception.h>
#include <Dictionaries/Embedded/GeodataProviders/IHierarc<|fim_suffix|> & elem : data)
elem.second.reload();
}
const RegionsHierarchy & get(const std::string & key) const
{
auto it... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Dictionaries/Embedded/RegionsHierarchy.h>
#include <IO/WriteHelpers.h>
#include <Poco/Exception.h>
#include <Poco/Util/Application.h>
#include <Common/logger_useful.h>
#include <Dictionaries/Embedded/GeodataProviders/IHierarchiesProvider.h>
namespace DB
{
namespace ErrorCodes
{
extern con... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|> RegionParents district;
/// region -> the continent (the first when climbing in the hierarchy of regions), including it or 0, if there is none
RegionParents continent;
/// region -> the continent (the latter when you climb the hierarchy of regions), including it or 0, if there is none
Re... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|> continue;
LOG_DEBUG(log, "Reloading regions names for language: {}", language);
auto names_reader = names_source->createReader();
const size_t initial_size = 10000;
const size_t max_size = 15000000;
Chars new_chars;
StringViews new_names_refs... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|> language_id != root_language)
{
language_id = static_cast<size_t>(fallbacks[language_id]);
ref = names_refs[language_id][region_id];
}
return ref;
}
static Language getLanguageEnum(const std::string & language)
{
#define M(NAME, FALLBA... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>struct, configuration, sample_block, std::move(coordinator), context);
};
factory.registerSource("executable", create_table_source, Documentation{
.description = "Obtains dictionary data by running an executable script that writes the data to its standard output in one of the supported fo... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <Core/Block.h>
#include <Interpreters/Context_fwd.h>
#include <Dictionaries/IDictionarySource.h>
#include <Dictionaries/DictionaryStructure.h>
#include <Processors/Sources/ShellCommandSource.h>
namespace DB
{
/// Allows loading dictionaries from executable
class<|fim_suffix|> C... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Dictionaries/ExecutablePoolDictionarySource.h>
#include <filesystem>
#include <boost/algorithm/string/split.hpp>
#include <Common/logger_useful.h>
#include <Common/LocalDateTime.h>
#include <Common/filesystemHelpers.h>
#include <Core/Settings.h>
#include <Processors/Formats/IOutputFormat.h>... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <Core/Block.h>
#include <Interpreters/Context_fwd.h>
#includ<|fim_suffix|>*/
class ExecutablePoolDictionarySource final : public IDictionarySource
{
public:
struct Configuration
{
String command;
VectorWithMemoryTracking<String> command_arguments;
b... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Dictionaries/ExternalQueryBuilder.h>
#include <boost/range/join.hpp>
#include <IO/WriteBuffer.h>
#include <IO/WriteBufferFromString.h>
#include <IO/WriteHelpers.h>
#include <Dictionaries/DictionaryStructure.h>
#include <Databases/removeWhereConditionPlaceholder.h>
namespace DB
{
static inlin... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>*/
enum LoadKeysMethod
{
AND_OR_CHAIN,
IN_WITH_TUPLES,
CASSANDRA_SEPARATE_PARTITION_KEY,
};
std::string composeLoadKeysQuery(const Columns & key_columns, const VectorWithMemoryTracking<size_t> & requested_rows, LoadKeysMethod method, size_t partition_key_prefix = 0... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Dictionaries/FileDictionarySource.h>
#include <Common/logger_useful.h>
#include <Common/StringUtils.h>
#include <Common/filesystemHelpers.h>
#include <QueryPipeline/BlockIO.h>
#include <IO/ReadBufferFromFile.h>
#include <Interpreters/Context.h>
#include <Processors/Formats/IInputFormat.h>
#inclu... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <Common/Exception.h>
#include <Poco/Timestamp.h>
#include <QueryPipeline/BlockIO.h>
#include <Dictionaries/IDictionarySource.h>
#include <Core/Block.h>
#include <Interpreters/Context_fwd.h>
namespace DB
{
namespace ErrorCodes
{
extern const int NOT_IMPLEMENTED;
}
/// Allows lo... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <memory>
#include <Dictionaries/FlatDictionary.h>
#include <Core/Defines.h>
#include <Common/HashTable/HashMap.h>
#include <Common/HashTable/HashSet.h>
#include <Common/ArenaUtils.h>
#include <Dictionaries/DictionarySourceHelpers.h>
#include <DataTypes/DataTypesDecimal.h>
#include <IO/WriteHelp... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <atomic>
#include <variant>
#include <Common/VectorWithMemoryTracking.h>
#include <optional>
#include <Common/HashTable/HashSet.h>
#include <Common/Arena.h>
#include <QueryPipeline/Pipe.h>
#include <DataTypes/IDataType.h>
#include <Core/Block_fwd.h>
#include <Dictionaries/Dictiona... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Dictionaries/HTTPDictio<|fim_suffix|>ve(buf));
return io;
}
bool HTTPDictionarySource::isModified() const
{
return true;
}
bool HTTPDictionarySource::supportsSelectiveLoad() const
{
return true;
}
bool HTTPDictionarySource::hasUpdateField() const
{
return !configuration.update... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <Core/Block.h>
#include <IO/ConnectionTimeouts.h>
#include <IO/ReadWriteBufferFromHTTP.h>
#include <Poco/Net/HTTPBasicCredentials.h>
#include <Poco/URI.h>
#include <Common/LocalDateTime.h>
#include <Dictionaries/DictionaryStructure.h>
#include <Dictionaries/IDictionarySource.h>
#inc... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <memory>
#include <Dictionaries/HashedArrayDictionary.h>
#include <Common/ArenaUtils.h>
#include <QueryPipeline/QueryPipeline.h>
#include <Core/Defines.h>
#include <Core/Settings.h>
#include <DataTypes/DataTypesDecimal.h>
#include <Columns/ColumnsNumber.h>
#include <Columns/ColumnNullable.h>
#in... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <atomic>
#include <memory>
#include <variant>
#include <optional>
#include <Core/Block_fwd.h>
#include <Common/HashTable/HashMap.h>
#include <Common/HashTable/HashSet.h>
#include <Dictionaries/DictionaryStructure.h>
#include <Dictionaries/IDictionary.h>
#include <Dictionaries/IDic... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>ue >;
}
<|fim_prefix|>#include <Dictionaries/HashedDictionary.h>
namespace DB
{
template class HashedDictionary<DictionaryKeyType::Simple, /* sparse= */ false, /* sharded= */ fa<|fim_middle|>lse >;
template class HashedDictionary<DictionaryKeyType::Simple, /* sparse= */ false, /* sharded= */ true >;
... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <Dictionaries/DictionaryStructure.h>
#include <Dictionaries/IDictionary.h>
#include <Dictionaries/IDictionarySource.h>
#include <Common/ThreadGroupSwitcher.h>
#include <Dictionaries/DictionaryHelpers.h>
#include <Dictionaries/ClickHouseDictionarySource.h>
#include <Dictionaries/Dict... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#pragma once
#include <type_traits>
#include <sparsehash/sparse_hash_map>
#include <Common/HashTable/Hash.h>
#include <Common/HashTable/HashMap.h>
#include <Common/HashTable/HashSet.h>
#include <Common/HashTable/PackedHashMap.h>
namespace DB::Hashe<|fim_suffix|>t; }
template <typename T> auto getValueFr... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#pragma once
#include <Core/Types_fwd.h>
#include <Dictionaries/IDictionary.h>
#include <Common/CacheLine.h>
#include <Common/HashTable/HashMap.h>
#include <Common/HashTable/HashSet.h>
#include <Common/HashTable/PackedHashMap.h>
#include <sparsehash/sparse_hash_map>
#include <sparsehash/sparse_hash_set>... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#pragma once
#include <Dictionaries/IDictionary.h>
#include <Dictionaries/DictionaryHelpers.h>
#include <Common/ThreadGro<|fim_suffix|> if (stop_all_workers)
break;
/// Note: we use isFinishedAndEmpty() instead of isFinished() to avoid
/// ... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>e_t hierarchical_attribute_index = *dictionary_structure.hierarchical_attribute_index;
const auto & hierarchical_attribute = dictionary_structure.attributes[hierarchical_attribute_index];
const PaddedPODArray<UInt64> & requested_keys = key_column_typed->getData();
ChildToParentHierarchicalCon... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>addedPODArray<UInt64> & requested_keys,
const DictionaryHierarchicalParentToChildIndex & parent_to_child_index,
size_t level,
size_t & valid_keys);
/** Default getHierarchy implementation for dictionaries that does not have structure with child to parent representation.
* Implementation wil... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#pragma once
#include <Columns/IColumn_fwd.h>
#include <Dictionaries/DictionaryHelpers.h>
#include <Common/HashTable/HashMap.h>
#include <Common/PODArray.h>
namespace DB
{
struct KeyState
{
enum State: uint8_t
{
not_found = 0,
expired = 1,
found = 2,
};
KeyState... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>vel [[maybe_unused]],
DictionaryHierarchicalParentToChildIndexPtr parent_to_child_index [[maybe_unused]]) const
{
throw Exception(ErrorCodes::NOT_IMPLEMENTED,
"Method getDescendants is not supported for {} dictionary.",
getDictionaryID().... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#pragma once
#include <Columns/IColumn_fwd.h>
#include <QueryPipeline/QueryPipeline.h>
#include <QueryPipeline/BlockIO.h>
#include <Common/VectorWithMemoryTracking.h>
namespace DB
{
class IDictionarySource;
using DictionarySourcePtr = std::shared_ptr<IDictionarySource>;
/** Data-provider interface f... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>= std::get<ContainerType<AttributeType>>(attribute.maps);
if (const auto * ipv4_col = std::get_if<IPv4Container>(&ip_column))
{
const auto * key_ip_column_ptr = typeid_cast<const ColumnVector<UInt32> *>(&*key_columns.front());
if (key_ip_column_ptr == nullptr)
throw Ex... | fim | ClickHouse/ClickHouse | cpp |
#pragma once
#include <atomic>
#include <memory>
#include <variant>
#include <Columns/ColumnVector.h>
#include <Dictionaries/DictionaryHelpers.h>
#include <Dictionaries/DictionaryStructure.h>
#include <Dictionaries/IDictionary.h>
#include <Dictionaries/IDictionarySource.h>
#include <Poco/Net/IPAddress.h>
#include <Com... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Dictionaries/InvalidateQueryResponse.h>
namespace DB
{
InvalidateQueryResponse::InvalidateQueryResponse(const InvalidateQueryResponse & other)
{
std::lock_guard lock(other.mutex);
response = other.response;
}
b<|fim_suffix|>updateAndCheckModified(const std::string & new_response)
{
... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <mutex>
#include <string>
namespace DB
{
/// Thread-safe holder for the last value returned by a<|fim_suffix|>fied(const std::string & new_response);
private:
mutable std::mutex mutex;
std::string response;
};
}
<|fim_middle|> dictionary source's invalidate query.
class ... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>ath))
throw Exception(ErrorCodes::PATH_ACCESS_DENIED, "File path {} is not inside {}", path, dictionaries_lib_path);
namespace fs = std::filesystem;
if (!fs::exists(path))
throw Exception(ErrorCodes::FILE_DOESNT_EXIST, "LibraryDictionarySource: Can't load library {}: file doesn't... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>ernalDictionaryLibraryBridgeHelperPtr bridge_helper;
ExternalResultDescription description;
};
}
<|fim_prefix|>#pragma once
#include <BridgeHelper/ExternalDictionaryLibraryBridgeHelper.h>
#include <Common/LocalDateTime.h>
#include <QueryPipeline/BlockIO.h>
#include <Core/UUID.h>
#include <Dictionari... | fim | ClickHouse/ClickHouse | c |
#include "config.h"
#include <Dictionaries/DictionarySourceFactory.h>
#include <Common/Exception.h>
#if USE_MONGODB
#include <Dictionaries/MongoDBDictionarySource.h>
#include <Dictionaries/DictionaryStructure.h>
#include <Columns/IColumn.h>
#include <Common/logger_useful.h>
#include <Processors/Sources/MongoDBSource... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>_struct;
const std::shared_ptr<MongoDBConfiguration> configuration;
SharedHeader sample_block;
};
}
#endif
<|fim_prefix|>#pragma once
#include "config.h"
#if USE_MONGODB
#include <Dictionaries/DictionaryStructure.h>
#include <Dictionaries/IDictionarySource.h>
#include <QueryPipeline/BlockIO.h>
... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Dictionaries/MySQLDictionarySource.h>
#if USE_MYSQL
# include <mysqlxx/PoolFactory.h>
#endif
#include <Poco/Util/AbstractConfiguration.h>
#include <Dictionaries/DictionarySourceFactory.h>
#include <Dictionaries/DictionaryStructure.h>
#include <Dictionaries/registerDictionaries.h>
#include ... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <Core/Block.h>
#include "config.h"
#if USE_MYSQL
# include <Common/LocalDateTime.h>
# include <mysqlxx/PoolWithFailover.h>
# include <Dictionaries/DictionaryStructure.h>
# include <Dictionaries/ExternalQueryBuilder.h>
# include <Dictionaries/IDictionarySource.h>
# ... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>onarySourcePtr { return std::make_unique<NullDictionarySource>(std::make_shared<const Block>(sample_block)); };
factory.registerSource("null", create_table_source, Documentation{
.description = "A source that returns no data. Used internally as a placeholder and for testing.",
.syntax... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <Core/Block_fwd.h>
#include <Dictionaries/IDictionarySource.h>
#include <Common/Exception.h>
namespace DB
{
namespace ErrorCodes
{
extern const int NOT_IMPLEMENTED;
}
/// Allows creating empty dictionary
class NullDictionarySource final : public IDictionarySource
{
public:
... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>*this;
}
bool atLastPolygonOfMultiPolygon() { return current_polygon + 1 == multi_polygon_offsets[current_multi_polygon]; }
bool atLastRingOfPolygon() { return current_ring + 1 == polygon_offsets[current_polygon]; }
bool atLastPointOfRing() { return points_added == ring_offsets[current_ri... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|> const DictionaryStructure dict_struct;
const DictionarySourcePtr source_ptr;
const DictionaryLifetime dict_lifetime;
const Configuration configuration;
/** Computes `bytes_allocated`, including index bytes via the virtual
* `getIndexBytesAllocated`. Must be invoked from a *concre... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Core/NamesAndTypes.h>
#include <Dictionaries/DictionaryFactory.h>
#include <Dictionaries/PolygonDictionaryImplementations.h>
#include <DataTypes/DataTypeArray.h>
#include <DataTypes/DataTypeTuple.h>
#include <DataTypes/DataTypesNumber.h>
#include <Dictionaries/ClickHouseDictionarySource.h>
#inc... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <Dictionaries/PolygonDictionary.h>
#include <Dictionaries/PolygonDictionaryUtils.h>
#include <Common/VectorWithMemoryTracking.h>
namespace DB
{
/** Simple implementation of the polygon dictionary. Doesn't generate anything during its construction.
* Iterates over all stored pol... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Dictionaries/PolygonDictionaryUtils.h>
#include <Common/SetWithMemoryTracking.h>
#include <Common/ThreadPool.h>
#include <Common/logger_useful.h>
#include <algorithm>
#include <numeric>
namespace DB
{
namespace ErrorCodes
{
extern const int LOGICAL_ERROR;
}
FinalCell::FinalCell(const V... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>tr;
if (y < min_y || y >= max_y)
return nullptr;
return root->find((x - min_x) / (max_x - min_x), (y - min_y) / (max_y - min_y));
}
[[nodiscard]] size_t getBytesAllocated() const override
{
return root ? root->getBytesAllocated() : 0;
}
/** Until t... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Dictionaries/PostgreSQLDictionarySource.h>
#include <Poco/Util/AbstractConfiguration.h>
#include <Core/QualifiedTableName.h>
#include <Core/Settings.h>
#include <Dictionaries/DictionarySourceFactory.h>
#include <Storages/NamedCollectionsHelpers.h>
#include <Dictionaries/registerDictionaries.h>
... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include "config.h"
#<|fim_suffix|>table;
const String query;
const String where;
const String invalidate_query;
const String update_field;
const UInt64 update_lag;
};
PostgreSQLDictionarySource(
const DictionaryStructure & dict_struct... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Dictionaries/RangeHashedDictionary.h>
namespace DB
{
template <DictionaryKeyType dictionary_key_type>
ColumnPtr RangeHashedDictionary<dictionary_key_type>::getColumn(
const std::string & attribute_name,
const DataTypePtr & attribute_type,
const Columns & key_columns,
const Data... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|> result.emplace_back(range_dictionary_ptr->getColumnInternal(attribute_name, result_type, data));
}
return result;
};
auto coordinator = std::make_shared<DictionarySourceCoordinator>(
dictionary,
column_names,
std::move(key_columns),
std::move... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|> to excessive resource consumption.
namespace DB
{
template class RangeHashedDictionary<DictionaryKeyType::Complex>;
}
<|fim_prefix|>#include <Dictionaries/RangeHashedDictionary.h>
/// RangeHashedDi<|fim_middle|>ctionary is instantiated from two files
/// RangeHashedDictionarySimple.cpp and RangeHashe... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>E_TYPE(Decimal32);
INSTANTIATE_GET_ITEMS_IMPL_FOR_ATTRIBUTE_TYPE(Decimal64);
INSTANTIATE_GET_ITEMS_IMPL_FOR_ATTRIBUTE_TYPE(Decimal128);
INSTANTIATE_GET_ITEMS_IMPL_FOR_ATTRIBUTE_TYPE(Decimal256);
INSTANTIATE_GET_ITEMS_IMPL_FOR_ATTRIBUTE_TYPE(DateTime64);
}
<|fim_prefix|>#include <Dictionaries/RangeHashedDi... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>;
}
<|fim_prefix|>#include <Dictionaries/RangeHashedDictionaryGetItemsImpl.txx>
namespace DB
{
INSTANTIATE<|fim_middle|>_GET_ITEMS_IMPL_FOR_ATTRIBUTE_TYPE(Float32);
INSTANTIATE_GET_ITEMS_IMPL_FOR_ATTRIBUTE_TYPE(Float64)<|endoftext|> | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>YPE(Int16);
INSTANTIATE_GET_ITEMS_IMPL_FOR_ATTRIBUTE_TYPE(Int32);
INSTANTIATE_GET_ITEMS_IMPL_FOR_ATTRIBUTE_TYPE(Int64);
INSTANTIATE_GET_ITEMS_IMPL_FOR_ATTRIBUTE_TYPE(Int128);
INSTANTIATE_GET_ITEMS_IMPL_FOR_ATTRIBUTE_TYPE(Int256);
}
<|fim_prefix|>#include <Dictionaries/RangeHashedDictionaryGetItemsImpl.txx... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <Dictionaries/RangeHashedDictio<|fim_suffix|>UTE_TYPE(Object);
}
<|fim_middle|>naryGetItemsImpl.txx>
namespace DB
{
INSTANTIATE_GET_ITEMS_IMPL_FOR_ATTRIBUTE_TYPE(UUID);
INSTANTIATE_GET_ITEMS_IMPL_FOR_ATTRIBUTE_TYPE(IPv4);
INSTANTIATE_GET_ITEMS_IMPL_FOR_ATTRIBUTE_TYPE(IPv6);
INSTANTIATE_GET_ITEMS... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>;
INSTANTIATE_GET_ITEMS_IMPL_FOR_ATTRIBUTE_TYPE(UInt256);
}
<|fim_prefix|>#include <Dictionaries/RangeHashedDictionaryGetItemsImpl.txx>
namespace DB
{
INSTANTIATE_GET_ITEMS_IMPL_FOR_ATTRIBUTE_TYPE(UInt8);
INSTANTIATE_GET_ITEMS_IMPL_FOR_ATTRIBUTE_TYPE(UInt16);
INSTANTIATE_GET_ITEMS_IMPL_FOR_ATTRIBUTE_TYPE... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <Dictionaries/RangeHashedDictionaryGetItem<|fim_suffix|>IT_IMPL_FOR_ATTRIBUTE_TYPE(Decimal64);
INSTANTIATE_GET_ITEMS_SHORT_CIRCUIT_IMPL_FOR_ATTRIBUTE_TYPE(Decimal128);
INSTANTIATE_GET_ITEMS_SHORT_CIRCUIT_IMPL_FOR_ATTRIBUTE_TYPE(Decimal256);
INSTANTIATE_GET_ITEMS_SHORT_CIRCUIT_IMPL_FOR_ATTRIBUTE_T... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <Dictionaries/RangeHashedDictionaryGetItemsShortCircuitImpl.txx>
namespace DB
{
INSTANTIATE_GET_ITEMS<|fim_suffix|>R_ATTRIBUTE_TYPE(Float32);
INSTANTIATE_GET_ITEMS_SHORT_CIRCUIT_IMPL_FOR_ATTRIBUTE_TYPE(Float64);
}
<|fim_middle|>_SHORT_CIRCUIT_IMPL_FO<|endoftext|> | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <Dictionaries/RangeHashedDictionaryGetItemsShortCircuitImpl.txx>
namespace DB
{
INSTANTIATE_GET_ITEMS_SHORT_CIRCUIT_IMPL_FOR_ATTRIBUTE_TYPE(Int8);
INSTANTIATE_GET_ITEMS_SHORT_CIRCUIT_IMPL_FOR_ATTRIBUTE_TYPE(Int16);
INS<|fim_suffix|>T_CIRCUIT_IMPL_FOR_ATTRIBUTE_TYPE(Int128);
INSTANTIATE_GET_ITEMS... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <Dictionaries/RangeHashedDictionaryGetItems<|fim_suffix|>(IPv6);
INSTANTIATE_GET_ITEMS_SHORT_CIRCUIT_IMPL_FOR_ATTRIBUTE_TYPE(String);
INSTANTIATE_GET_ITEMS_SHORT_CIRCUIT_IMPL_FOR_ATTRIBUTE_TYPE(Array);
INSTANTIATE_GET_ITEMS_SHORT_CIRCUIT_IMPL_FOR_ATTRIBUTE_TYPE(Map);
INSTANTIATE_GET_ITEMS_SHORT_C... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <Dictionaries/RangeHashedDictionaryGetItemsShortCircuitImpl.txx>
namespace DB
{
INSTANTIATE_GET_ITEMS_SHORT_CIRCUIT_I<|fim_suffix|>L_FOR_ATTRIBUTE_TYPE(UInt8);
INSTANTIATE_GET_ITEMS_SHORT_CIRCUIT_IMPL_FOR_ATTRIBUTE_TYPE(UInt16);
INSTANTIATE_GET_ITEMS_SHORT_CIRCUIT_IMPL_FOR_ATTRIBUTE_TYPE(UInt32)... | fim | ClickHouse/ClickHouse | cpp |
#include <Dictionaries/RangeHashedDictionary.h>
/// RangeHashedDictionary is instantiated from two files
/// RangeHashedDictionarySimple.cpp and RangeHashedDictionaryComplex.cpp
/// to better parallelize the build procedure and avoid MSan build failure
/// due to excessive resource consumption.
namespace DB
{
templa... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <Dictionaries/RedisDictionarySource.h>
#include <Dictionaries/DictionarySourceFactory.h>
#include <Dictionaries/DictionaryStructure.h>
#include <Columns/IColumn.h>
#include <Interpreters/Context.h>
#include <QueryPipeline/QueryPipeline.h>
#include <Poco/Util/AbstractConfiguration.h>
#include <Co... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>
bool isModified() const override { return true; }
bool hasUpdateField() const override { return false; }
DictionarySourcePtr clone() const override { return std::make_shared<RedisDictionarySource>(*this); }
std::string toString() const override;
private:
c... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Dictionaries/RedisSource.h>
#include <Columns/ColumnNullable.h>
#include <Columns/ColumnString.h>
#include <Columns/ColumnsNumber.h>
#include <IO/ReadHelpers.h>
#include <IO/WriteHelpers.h>
#include <IO/ReadBufferFromString.h>
namespace DB
{
namespace ErrorCodes
{
extern const... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <Core/ExternalResultDescription.h>
#include <Processors/ISource.h>
#include <Poco/Redis/Array.h>
#include <Poco/Redis/Type.h>
#include <Storages/RedisCommon.h>
namespace DB
{
class RedisSource final : public ISource
{
public:
RedisSource(
RedisConn... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <optional>
#include <string_view>
#include <base/defines.h>
#include <Poco/Logger.h>
#include <Poco/RegularExpression.h>
#include <Core/ColumnsWithTypeAndName.h>
#include <Core/Settings.h>
#include <DataTypes/DataTypeString.h>
#include <DataTypes/DataTypesNumber.h>
#include <Interpreters/Conte... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>ont();
}
const ColumnPtr & default_values_column = std::get<RefDefault>(default_or_filter).get();
const Columns & columns = Columns({default_values_column});
return getColumns({attribute_name}, {attribute_type}, key_columns, key_types, columns).front();
}
Columns ... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#pragma once
#if defined(OS_LINUX) || defined(OS_FREEBSD)
#include <chrono>
#include <pcg_random.hpp>
#include <filesystem>
#include <city.h>
#include <fcntl.h>
#include <absl/container/flat_hash_map.h>
#include <absl/container/flat_hash_set.h>
#include <Common/ErrnoException.h>
# include <base/Mem... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Dictionaries/HashedDictionary.h>
namespace DB
{
template class HashedDictionary<DictionaryKeyType::Simple,<|fim_suffix|>e >;
template class HashedDictionary<DictionaryKeyType::Complex, /* sparse= */ true, /* sharded= */ false >;
template class HashedDictionary<DictionaryKeyType::Complex, /* ... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <Dictionaries/XDBCDictionarySource.h>
#include <Columns/ColumnString.h>
#include <Common/DateLUTImpl.h>
#include <DataTypes/DataTypeString.h>
#include <IO/ReadWriteBufferFromHTTP.h>
#include <IO/WriteHelpers.h>
#include <IO/ConnectionTimeouts.h>
#include <Interpreters/Context.h>
#include <Poco/N... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <Core/Block.h>
#include <IO/ConnectionTimeouts.h>
#include <Poco/URI.h>
#include <BridgeHelper/XDBCBridgeHelper.h>
#include <Dictionaries/DictionaryStructure.h>
#include <Dictionaries/ExternalQueryBuilder.h>
#include <Dictionaries/IDictionarySource.h>
#include <Dictionaries/Invalida... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Dictionaries/YAMLRegExpTreeDictionarySource.h>
#include <cstdlib>
#include <iterator>
#include <memory>
#include <optional>
#include <string>
#include <Common/UnorderedMapWithMemoryTracking.h>
#include <Poco/Logger.h>
#include <Core/ColumnWithTypeAndName.h>
#include <DataTypes/DataTypeArray.h>
... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <Common/Exception.h>
#include "config.h"
#include <Core/Block.h>
#include <Interpreters/Context_fwd.h>
#include <QueryPipeline/QueryPipeline.h>
#include <Poco/Logger.h>
#include <Poco/Timestamp.h>
#include <Dictionaries/IDictionarySource.h>
#include <Dictionaries/DictionaryStruc... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include "config.h"
#if USE_YTSAURUS
#include <memory>
#include <Dictionaries/DictionarySourceFactory.h>
#include <Dictionaries/YTsaurusDictionarySource.h>
#include <Interpreters/Context.h>
#include <Processors/Sources/YTsaurusSource.h>
#include <Storages/YTsaurus/StorageYTsaurus.h>
#include <Storages/Na... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include "config.h"
#if USE_YTSAURUS
#include <Dictionaries/DictionaryStructure.h>
#include <Dictionaries/IDictionarySource.h>
#include <Storages/YTsaurus/StorageYTsaurus.h>
#include <Core/YTsaurus/YTsaurusClient.h>
#include <Core/Block.h>
namespace DB
{
namespace ErrorCodes
{
extern ... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>database = config->getString("dictionary.source.clickhouse.db", "");
String table = config->getString("dictionary.source.clickhouse.table", "");
info.query = config->getString("dictionary.source.clickhouse.query", "");
if (!table.empty())
info.table_name = {database, table};
else... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>me;
String query;
bool is_local = false;
};
std::optional<ClickHouseDictionarySourceInfo>
getInfoIfClickHouseDictionarySource(DictionaryConfigurationPtr & config, ContextPtr global_context);
}
<|fim_prefix|>#pragma once
#include <Core/QualifiedTableName.h>
#include <Interpreters/Context_fwd.h>
... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>h>
namespace DB
{
namespace ErrorCodes
{
extern const int TOO_MANY_COLUMNS;
extern const int TOO_MANY_ROWS;
extern const int RECEIVED_EMPTY_DATA;
}
std::string readInvalidateQuery(QueryPipeline & pipeline)
{
PullingPipelineExecutor executor(pipeline);
Block block;
while (execu... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>(QueryPipeline & pipeline);
}
<|fim_prefix|>#pragma once
#include <string>
namespace DB
{
class QueryPipeline;
/// Using in MySQLDictionarySource and <|fim_middle|>XDBCDictionarySource after processing invalidate_query.
std::string readInvalidateQuery<|endoftext|> | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|> bool created_from_ddl) -> DictionaryPtr
{
return createCacheDictionaryLayout<DictionaryKeyType::Complex, false /* ssd */>(full_name, dict_struct, config, config_prefix, std::move(source_ptr), global_context, created_from_ddl);
};
factory.registerLayout("complex_key_cache"... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|> registerDictionarySourceClickHouse(source_factory);
registerDictionarySourceMongoDB(source_factory);
registerDictionarySourceRedis(source_factory);
registerDictionarySourceCassandra(source_factory);
registerDictionarySourceXDBC(source_factory);
registerDictio... | fim | ClickHouse/ClickHouse | cpp |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.