text stringlengths 14 100k | source stringclasses 1
value | repo stringclasses 810
values | language stringclasses 13
values |
|---|---|---|---|
<|fim_prefix|>#include <Interpreters/DuplicateOrderByVisitor.h>
#include <Functions/FunctionFactory.h>
#include <AggregateFunctions/AggregateFunctionFactory.h>
#include <Parsers/ASTFunction.h>
#include <Parsers/ASTSelectQuery.h>
#include <Parsers/ASTSetQuery.h>
#include <Parsers/ASTTablesInSelectQuery.h>
#include <Pars... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>rderByFromSubqueriesMatcher, true>;
/// Finds SELECT that can be optimized
class DuplicateOrderByData
{
public:
using TypeToVisit = ASTSelectQuery;
ContextPtr context;
void visit(ASTSelectQuery & select_query, ASTPtr &);
};
using DuplicateOrderByMatcher = OneTypeMatcher<DuplicateOrderByDa... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>_dictionaries_loader_,
ContextPtr context_,
const bool throw_on_error)
: WithContext(context_)
, log(getLogger("EmbeddedDictionaries"))
, geo_dictionaries_loader(std::move(geo_dictionaries_loader_))
, reload_period(getContext()->getConfigRef().getInt("builtin_dictionaries_reload_in... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>nst
{
return regions_hierarchies.get();
}
MultiVersion<RegionsNames>::Version getRegionsNames() const
{
return regions_names.get();
}
};
}
<|fim_prefix|>#pragma once
#include <Interpreters/Context_fwd.h>
#include <Common/Logger_fwd.h>
#include <Common/MultiVersion.h>... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <base/getFQDNOrHostName.h>
#include <Common/DateLUTImpl.h>
#include <Common/ErrorCodes.h>
#include <DataTypes/DataTypeArray.h>
#include <DataType<|fim_suffix|>_DEPTH, DBMS_DEFAULT_MAX_PARSER_BACKTRACKS),
"The time when the last error happened."
},
{
... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <Interpreters/PeriodicLog.h>
#include <Common/ErrorCodes.h>
#include <Core/NamesAndAliases.h><|fim_suffix|>>(ErrorCodes::end());
mutable std::mutex previous_values_mutex;
};
}
<|fim_middle|>
#include <Storages/ColumnsDescription.h>
namespace DB
{
/** ErrorLog is a log of err... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Interpreters/ExecuteScalarSubqueriesVisitor.h>
#include <Columns/ColumnConst.h>
#include <Columns/ColumnNullable.h>
#include <Columns/ColumnTuple.h>
#include <Core/Settings.h>
#include <DataTypes/DataTypeNullable.h>
#include <DataTypes/DataTypeTuple.h>
#include <IO/WriteHelpers.h>
#include <Int... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>zer server.
* The request is sent to remote servers with already substituted constants.
*/
class ExecuteScalarSubqueriesMatcher
{
public:
using Visitor = InDepthNodeVisitor<ExecuteScalarSubqueriesMatcher, true>;
struct Data : public WithContext
{
size_t subquery_depth;
... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Interpreters/Set.h>
#include <Common/ProfileEvents.h>
#include <Interpreters/ArrayJoinAction.h>
#include <Interpreters/ExpressionActions.h>
#include <Interpreters/TableJoin.h>
#include <Interpreters/Context.h>
#include <Columns/ColumnArray.h>
#include <Columns/ColumnFunction.h>
#include <Columns... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <Common/Exception.h>
#include <Core/Block.h>
#include <Core/ColumnNumbers.h>
#include <Interpreters/Acti<|fim_suffix|>rom block). Example: filter column for where actions.
/// If not empty, has the same size with required_output; is filled in finalize().
std::unordered_map<s... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|> max_temporary_columns;
extern const SettingsUInt64 max_temporary_non_const_columns;
extern const SettingsUInt64 min_count_to_compile_expression;
extern const SettingsBool enable_lazy_columns_replication;
}
ExpressionActionsSettings::ExpressionActionsSettings(const Settings & from, CompileExp... | fim | ClickHouse/ClickHouse | cpp |
#pragma once
#include <Core/ShortCircuitFunctionEvaluation.h>
#include <Interpreters/Context_fwd.h>
#include <cstddef>
namespace DB
{
struct Settings;
enum class CompileExpressions: uint8_t
{
no = 0,
yes = 1,
};
struct ExpressionActionsSettings
{
ExpressionActionsSettings() = default;
explicit Exp... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>_columns` will not be removed (they can be used for e.g. sampling or FINAL modifier).
ActionsAndProjectInputsFlagPtr appendPrewhere(ExpressionActionsChain & chain, bool only_types);
bool appendWhere(ExpressionActionsChain & chain, bool only_types);
bool appendGroupBy(ExpressionActionsChain & c... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>se;
compile_node.result_type = node->result_type;
if (is_compilable_constant)
{
compile_node.type = CompileDAG::CompileType::CONSTANT;
compile_node.column = node->column;
}
else if (frame.skip_compile)
... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>olved_name))
return resolved_name;
throw Exception(ErrorCodes::BAD_ARGUMENTS, "Dictionary ({}) not found", backQuote(dictionary_name));
}
std::string ExternalDictionariesLoader::resolveDictionaryNameFromDatabaseCatalog(const std::string & name, const std::string & current_database_name) cons... | fim | ClickHouse/ClickHouse | cpp |
#pragma once
#include <Dictionaries/IDictionary.h>
#include <Interpreters/Context_fwd.h>
#include <Interpreters/ExternalLoader.h>
#include <Common/quoteString.h>
#include <memory>
namespace DB
{
class IExternalLoaderConfigRepository;
/// Manages user-defined dictionaries.
class ExternalDictionariesLoader : public ... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Interpreters/ExternalLoader.h>
#include <mutex>
#include <unordered_set>
#include <base/chrono_io.h>
#include <boost/range/adaptor/map.hpp>
#include <boost/range/algorithm/copy.hpp>
#include <Common/Config/AbstractConfigurationComparison.h>
#include <Common/CurrentThread.h>
#include <Common/Exc... | fim | ClickHouse/ClickHouse | cpp |
#pragma once
#include <chrono>
#include <functional>
#include <exception>
#include <unordered_map>
#include <base/types.h>
#include <Interpreters/IExternalLoadable.h>
#include <Interpreters/IExternalLoaderConfigRepository.h>
#include <base/scope_guard.h>
#include <Common/ExternalLoaderStatus.h>
#include <Common/Logger... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>me)
{
return getName() == loadable_definition_name;
}
LoadablesConfigurationPtr ExternalLoaderDictionaryStorageConfigRepository::load(const std::string &)
{
return dictionary_storage.getConfiguration();
}
}
<|fim_prefix|>#include <Interpreters/ExternalLoaderDictionaryStorageConfigRepository.h>
... | fim | ClickHouse/ClickHouse | cpp |
#pragma once
#include <Interpreters/IExternalLoaderConfigRepository.h>
#include <Databases/IDatabase.h>
namespace DB
{
class StorageDictionary;
class ExternalLoaderDictionaryStorageConfigRepository : public IExternalLoaderConfigRepository
{
public:
explicit ExternalLoaderDictionaryStorageConfigRepository(const ... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Interpreters/ExternalLoaderTempConfigRepository.h>
#<|fim_suffix|>ory(const String & repository_name_, const String & path_, const LoadablesConfigurationPtr & config_)
: name(repository_name_), path(path_), config(config_) {}
std::set<String> ExternalLoaderTempConfigRepository::getAllLoada... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <base/types.h>
#include <Interpreters/IExternalLoaderConfigRepository.h>
#include <Poco/Timestamp.h>
namespace DB
{
/// A config repository filled with preset loadables used by ExternalLoader.
class ExternalLoaderTempConfigRepository : public IExternalLoaderConfigRepository
{
publ... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>);
config_processor.savePreprocessedConfig(preprocessed, app_path);
return preprocessed.configuration;
}
}
<|fim_prefix|>#include <Interpreters/ExternalLoaderXMLConfigRepository.h>
#include <filesystem>
#include <Common/StringUtils.h>
#include <Common/Config/ConfigProcessor.h>
#include <Common/... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <base/types.h>
#include <unordered_set>
#include <mutex>
#include <Interpreters/IExternalLoaderConfigRepository.h>
#include <Poco/Timestamp.h>
namespace DB
{
/// XML config repository used by ExternalLoader.
/// Represents xml-files in local filesystem.
class ExternalLoaderXMLCon... | fim | ClickHouse/ClickHouse | c |
#include <Interpreters/ExtractExpressionInfoVisitor.h>
#include <Functions/FunctionFactory.h>
#include <AggregateFunctions/AggregateFunctionFactory.h>
#include <Interpreters/IdentifierSemantic.h>
#include <Parsers/ASTFunction.h>
#include <Parsers/ASTIdentifier.h>
#include <Parsers/ASTSubquery.h>
namespace DB
{
void ... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>true>;
bool hasNonRewritableFunction(const ASTPtr & node, ContextPtr context);
}
<|fim_prefix|>#pragma once
#include <Interpreters/Context_fwd.h>
#include <Interpreters/DatabaseAndTableWithAlias.h>
#include <Interpreters/InDepthNodeVisitor.h>
#include <Parsers/IAST_fwd.h>
namespace DB
{
class ASTFunc... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#pragma once
#include <Interpreters/FileCache/IFileCachePriority.h>
#include <Interpreters/FileCache/FileCacheOriginInfo.h>
#include <Common/CurrentMetrics.h>
#include <base/defines.h>
#include <boost/noncopyable.hpp>
#include <mutex>
#include <unordered_map>
namespace CurrentMetrics
{
extern const M... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|> queue_iterator->remove(lock);
}
}
removed_queue_entries = true;
}
void EvictionCandidates::evict()
{
if (candidates.empty())
return;
auto timer = DB::CurrentThread::getProfileEvents().timer(ProfileEvents::FilesystemCacheEvictMicroseconds);
/// If queue entries a... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>replace target + merge holds if `replace_if_exists`, else throw.
void addImpl(const QueueID & queue_id, QueueEvictionInfoPtr info, bool replace_if_exists);
size_t size_to_evict = 0; /// Total size to evict among all eviction infos.
size_t elements_to_evict = 0; /// Total elements to evict amo... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|> }
if (!key_prefix_it->is_directory() && key_prefix_it->path().filename() != "status")
{
LOG_WARNING(log, "Unexpected file {} (not a directory), will skip it", path.string());
}
key_prefix_it++;
}
};
const UInt64 num_... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <array>
#include <atomic>
#include <memory>
#include <mutex>
#include <shared_mutex>
#include <unordered_map>
#include <boost/functional/hash.hpp>
#include <Common/callOnce.h>
#include <Common/ThreadPool_fwd.h>
#include <Common/StatusFile.h>
#include <Interpreters/FileCache/FileCac... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>me caches_by_name_copy;
{
std::lock_guard lock(mutex);
caches_by_name_copy = caches_by_name;
}
std::unordered_set<std::string> checked_paths;
for (const auto & [_, cache_info] : caches_by_name_copy)
{
if (cache_info->config_path.empty() || checked_paths.contain... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <Interpreters/FileCache/FileCache_fwd.h>
#include <Interpreters/FileCache/FileCacheSettings.h>
#include <boost/noncopyable.hpp>
#include <unordered_map>
#include <unordered_set>
#include <mutex>
namespace DB
{
/**
* Creates a FileCache object for cache_base_path.
*/
class FileC... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Interpreters/FileCache/FileCacheKey.h>
#include <base/hex.h>
#include <Common/Exception.h>
#include <Common/SipHash.h>
#include <Core/UUID.h>
namespace DB
{
namespace ErrorCodes
{
extern const int BAD_ARGUMENTS;
}
FileCacheKey::FileCacheKey(const UInt128 & key_)
: key(key_)
{
}
std:... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <Core/Types.h>
#include <fmt/format.h>
namespace DB
{
struct FileCacheKey
{
using KeyHash = UInt128;
KeyHash key;
std::string toString() const;
FileCacheKey() = default;
static FileCacheKey random();
static FileCacheKey fromPath(const std::string & path);... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#pragma once
#include <Core/UUID.h>
#include <Interpreters/FileCache/FileSegmentKeyType.h>
#include <sys/types.h>
namespace DB
{
struct FileCacheOriginInfo
{
using UserID = std::string;
using Weight = UInt64;
using SegmentKeyType = FileSegmentKeyType;
UserID user<|fim_suffix|>
Segme... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>getColumnsDescription()
{
FileCacheSettingsImpl impl;
ColumnsDescription result;
result.add(
ColumnDescription(
"cache_name", std::make_shared<DataTypeString>(), "Cache name"));
for (const auto & setting : impl.all())
{
ColumnDescription desc;
desc... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>ator==(const FileCacheSettings & settings) const noexcept;
~FileCacheSettings();
static ColumnsDescription getColumnsDescription();
FILE_CACHE_SETTINGS_SUPPORTED_TYPES(FileCacheSettings, DECLARE_SETTING_SUBSCRIPT_OPERATOR)
void loadFromConfig(
const Poco::Util::AbstractConfigura... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>. We only signal overflow when the actual rounded-up value exceeds `SIZE_MAX`.
const size_t remainder = num % multiple;
if (remainder == 0)
return num;
size_t result = 0;
if (common::addOverflow(num, multiple - remainder, result))
throw std::overflow_error("FileCacheUtils:... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>024 * 1024;
static constexpr double FILECACHE_DEFAULT_FREE_SPACE_SIZE_RATIO = 0; /// Disabled.
static constexpr double FILECACHE_DEFAULT_FREE_SPACE_ELEMENTS_RATIO = 0; /// Disabled.
static constexpr int FILECACHE_DEFAULT_FREE_SPACE_REMOVE_BATCH = 100;
static constexpr auto FILECACHE_DEFAULT_CONFIG_PATH = ... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#pragma once
#include <list>
namespace DB
{
class FileCache;
using FileCachePtr = std::shared_ptr<FileCache>;
<|fim_suffix|>ing KeyMetadataPtr = std::shared_ptr<KeyMetadata>;
}
<|fim_middle|>class IFileCachePriority;
using FileCachePriorityPtr = std::shared_ptr<IFileCachePriority>;
class FileSegment;... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Interpreters/FileCache/FileSegment.h>
#include <filesystem>
#include <IO/Operators.h>
#include <IO/WriteBufferFromString.h>
#include <Interpreters/FileCache/FileCache.h>
#include <Interpreters/FileCache/FileCacheUtils.h>
#include <base/EnumReflection.h>
#include <base/getThreadId.h>
#include <b... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|> bool force_shrink_to_downloaded_size);
const Key file_key;
Range segment_range;
const FileSegmentKind segment_kind;
/// Size of the segment is not known until it is downloaded and
/// can be bigger than max_file_segment_size.
/// is_unbound == true for temporary data in cache.
... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>tely after releasing.
* Also, corresponding files are removed during cache loading.
* Ephemeral file segments have no bound, and a single segment can have an arbitrary size.
*/
Ephemeral,
};
std::string toString(FileSegmentKind kind);
struct FileSegmentInfo... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Interpreters/FileCache/FileSegmentKeyType.h>
#include <base/EnumReflection.h>
namespace DB
{
String getKeyTypePrefix(FileSegmentKeyT<|fim_suffix|>eral)
return "";
return String(magic_enum::enum_name(type));
}
String toString(FileSegmentKeyType type)
{
return String(magic_enum:... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <base/types.h>
namespace DB<|fim_suffix|>etadata, index, marks, etc.)
Data, // Segment for table data
};
String getKeyTypePrefix(FileSegmentKeyType type);
String toString(FileSegmentKeyType type);
}
<|fim_middle|>
{
enum class FileSegmentKeyType : uint8_t
{
General = 0,
... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>tex); }
std::mutex mutex;
};
/**
* Guard for a file segment.
*/
struct FileSegmentGuard : private boost::noncopyable
{
struct Lock : public std::unique_lock<std::mutex>
{
explicit Lock(std::mutex & mutex_) : std::unique_lock<std::mutex>(mutex_) {}
};
Lock lock() { return Lo... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>expected state: {}", magic_enum::enum_name(entry_state)));
if (entry_state != Entry::State::Removed)
it->remove(lock);
}
}
IFileCachePriority::IPriorityDump::IPriorityDump() = default;
IFileCachePriority::IPriorityDump::~IPriorityDump() = default;
IFileCachePriority::IPriorityDum... | fim | ClickHouse/ClickHouse | cpp |
#pragma once
#include <Interpreters/FileCache/FileCacheOriginInfo.h>
#include <Interpreters/FileCache/FileCacheKey.h>
#include <Core/Types.h>
#include <Interpreters/FileCache/Guards.h>
#include <Interpreters/FileCache/FileCache_fwd_internal.h>
#include <atomic>
#include <functional>
#include <memory>
#include <fmt/r... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Interpreters/FileCache/EvictionCandidates.h>
#include <Interpreters/FileCache/FileCache.h>
#include <Interpreters/FileCache/LRUFileCachePriority.h>
#include <pcg-random/pcg_random.hpp>
#include <Common/CurrentMetrics.h>
#include <Common/CurrentThread.h>
#include <Common/logger_useful.h>
#include... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>r state;
/// Eviction position is a pointer used in collectCandidatesForEviction
/// to track where the last collectCandidatesForEviction stopped.
/// This is an optimization for concurrently made eviction attempts,
/// which allows us not to iterate the queue from scratch,
/// skippin... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>te();
try
{
file_segment->detach(segment_lock, *this);
}
catch (...)
{
tryLogCurrentException(__PRETTY_FUNCTION__);
chassert(false);
/// Do not rethrow, we must delete the file below.
}
try
{
const auto path = key_metadata->getFileS... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <boost/noncopyable.hpp>
#include <base/isSharedPtrUnique.h>
#include <Interpreters/FileCache/Guards.h>
#include <Interpreters/FileCache/IFileCachePriority.h>
#include <Interpreters/FileCache/FileCacheKey.h>
#include <Interpreters/FileCache/FileSegment.h>
#include <Interpreters/File... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>ext && context.use_count() == 2)
{
auto lock = cache->lockCache();
query_limit->removeQueryContext(query_id, lock);
}
}
}
<|fim_prefix|>#include <Interpreters/FileCache/FileCache.h>
#include <Interpreters/FileCac<|fim_middle|>he/Metadata.h>
#include <Interpreters/FileCache/QueryLi... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <Interpreters/FileCache/Guards.h>
#include <Interpreters/FileCache/LRUFileCachePriority.h>
namespace DB
{
struct ReadSettings;
struct FilesystemCacheSettings;
class FileSegment;
class FileCacheQueryLimit
{
public:
class QueryContext;
using QueryContextPtr = std::shared_ptr<... | fim | ClickHouse/ClickHouse | c |
#include <Interpreters/FileCache/IFileCachePriority.h>
#include <Interpreters/FileCache/SLRUFileCachePriority.h>
#include <Interpreters/FileCache/FileCache.h>
#include <Interpreters/FileCache/EvictionCandidates.h>
#include <base/scope_guard.h>
#include <Common/CurrentMetrics.h>
#include <Common/thread_local_rng.h>
#inc... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <Interpreters/FileCache/LRUFileCachePriority.h>
#include <Common/logger_useful.h>
namespace DB
{
/// Based on the SLRU algorithm implementation.
/// There are two queues: "protected" and "probationary".
/// All cache entries which have been accessed only once, would lie in probat... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>chePriority::getHoldElements()
{
return getPriority(SegmentType::Data).getHoldElements()
+ getPriority(SegmentType::System).getHoldElements();
}
SplitFileCachePriority::SplitIterator::SplitIterator(
IFileCachePriority * inner_cache_priority,
IteratorPtr iterator_,
FileSegmentKeyTy... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <memory>
#include <Interpreters/FileCache/Guards.h>
#include <Interpreters/FileCache/IFileCachePriority.h>
#include <Common/logger_useful.h>
namespace DB
{
/**
* Wrapper for IFilecachePriority that keeps two IFilecachePriority inside:
* Data: for `.bin`, `.mrk` and etc files
*... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>ke_unique<ReadBufferFromEmptyFile>();
}
}
<|fim_prefix|>#include <Interpreters/FileCache/WriteBufferToFileSegment.h>
#include <Interpreters/FileCache/FileSegment.h>
#include <Interpreters/FileCache/FileCache.h>
#include <Interpreters/Context.h>
#include <IO/SwapHelper.h>
#include <IO/ReadBufferFromFile.h... | fim | ClickHouse/ClickHouse | cpp |
#pragma once
#include <IO/WriteBufferFromFileDecorator.h>
#include <Interpreters/FileCache/FileSegment.h>
#include <IO/IReadableWriteBuffer.h>
#include <Disks/IO/CachedOnDiskWriteBufferFromFile.h>
namespace DB
{
namespace ErrorCodes
{
extern const int NOT_IMPLEMENTED;
}
class FileSegment;
class WriteBufferToFi... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>make_shared<DataTypeDate>(), "Event date"},
{"event_time", std::make_shared<DataTypeDateTime>(), "Event time"},
{"query_id", std::make_shared<DataTypeString>(), "Id of the query"},
{"source_file_path", std::make_shared<DataTypeString>(), "File segment path on filesystem"},
... | fim | ClickHouse/ClickHouse | cpp |
#pragma once
#include <Core/NamesAndAliases.h>
#include <DataTypes/DataTypeNumberBase.h>
#include <DataTypes/DataTypeTuple.h>
#include <Interpreters/SystemLog.h>
#include <Storages/ColumnsDescription.h>
namespace DB
{
struct FilesystemCacheLogElement
{
enum class CacheType : uint8_t
{
READ_FROM_CACHE... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <DataTypes/DataTypeDate.h>
#include <DataTypes/DataTypeDateTime.h>
#include <DataTypes/DataTypeDateTime64.h>
#include <DataTypes/DataTypeLowCardinality.h>
#include <DataTypes/DataTypeString.h>
#include <DataTypes/DataTypesNumber.h>
#include <Interpreters/FilesystemReadPrefetchesLog.h>
#include <b... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <Common/Priority.h>
#include <Common/Stopwatch.h>
#include <Core/NamesAndAliases.h>
#include <Interpreters/SystemLog.h>
#include <Storages/ColumnsDescription.h>
namespace DB
{
enum class FilesystemPrefetchState : uint8_t
{
USED,
CANCE<|fim_suffix|>_point prefetch_submit_ti... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <cstddef>
#include <Columns/IColumn.h>
#include <IO/Operators.h>
#include <Interpreters/FillingRow.h>
#include <Common/FieldAccurateComparison.h>
#include <Common/Logger.h>
#include <Common/logger_useful.h>
namespace DB
{
constexpr static bool debug_logging_enabled = false;
template <class..... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <Core/SortDescription.h>
namespace DB
{
/// Compares fields in terms of sorting order, considering direction.
bool less(const Field & lhs, const Field & rhs, int direction);
bool equals(const Field & lhs, const Field & rhs);
/** Helps to implement modifier WITH FILL for ORDER BY ... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#pragma once
#include <Interpreters/IJoin.h>
#include <Interpreters/TableJoin.h>
#include <DataTypes/DataTypeNullable.h>
#include <DataTypes/DataTypeLowCardinality.h>
#include <Common/logger_useful.h>
#include <Poco/Logger.h>
namespace DB
{
namespace ErrorCodes
{
extern const int LOGICAL_ERROR;
... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#pragma once
#include <Interpreters/InDepthNodeVisitor.h>
#include <Parsers/ASTFunction.h>
#include <Parsers/ASTIdentifier.h>
namespace DB
{
/// Checks from bottom to top if a function's alias shadows the name
/// of one of it's arguments, e.g.
/// SELECT toString(dummy) as dummy FROM system.one GROUP... | fim | ClickHouse/ClickHouse | c |
#include <Interpreters/FunctionNameNormalizer.h>
#include <Parsers/ASTColumnDeclaration.h>
#include <Parsers/ASTCreateQuery.h>
#include <Parsers/ASTFunction.h>
#include <Parsers/ASTTTLElement.h>
#include <Functions/FunctionFactory.h>
#include <AggregateFunctions/AggregateFunctionFactory.h>
namespace DB
{
void Funct... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>g function nodes by their canonical names.
/// See the comment of ActionsDAG::foldActionsByProjection for details.
struct FunctionNameNormalizer
{
static void visit(IAST *);
};
}
<|fim_prefix|>#pragma once
#include <Parsers/IAST_fwd.h><|fim_middle|>
namespace DB
{
/// Rewrite function names to the... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>quantile[function.name].addFuncNode(ast);
}
void GatherFunctionQuantileData::FuseQuantileAggregatesData::addFuncNode(ASTPtr & ast)
{
const auto * func = ast->as<ASTFunction>();
if (!func || func->parameters == nullptr)
return;
const auto & arguments = func->arguments->children;
... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <Interpreters/InDepthNodeVisitor.h>
#include <Parsers/IAST_fwd.h>
namespace DB
{
class ASTFunction;
/// Gather all the `quantile*` functions
class GatherFunctionQuantileData
{
public:
struct FuseQuantileAggregatesData
{
std::unordered_map<String, std::vector<ASTPt... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|> expressions_with_window_functions.push_back(ast);
}
return result;
}
return {};
}
ASTs expressions_with_window_functions;
};
using WindowExpressionsCollectorVisitor = InDepthNodeVisitorWithChildInfo<WindowExpressionsCollectorMatcher>;
ASTs ge... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>GROUP BY.
return !node.isWindowFunction() && AggregateUtils::isAggregateFunction(node);
}
};
using GetAggregatesVisitor = GetAggregatesMatcher::Visitor;
inline void assertNoWindows(const ASTPtr & ast, const char * description)
{
GetAggregatesVisitor::Data data{.assert_no_windows = descr... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Interpreters/GlobalSubqueriesVisitor.h>
#include <Core/Block.h>
#include <Core/NamesAndTypes.h>
#include <Core/Settings.h>
#include <Databases/IDatabase.h>
#include <IO/WriteHelpers.h>
#include <Interpreters/Context.h>
#include <Interpreters/DatabaseCatalog.h>
#include <Interpreters/IdentifierS... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <Interpreters/Context_fwd.h>
#include <Interpreters/InDepthNodeVisitor.h>
#include <Parsers/IAST_fwd.h>
namespace DB
{
class ASTSelectQuery;
class ASTFunction;
struct ASTTablesInSelectQueryElement;
class TableJoin;
struct TemporaryTableHolder;
using TemporaryTablesMapping = std::... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Compression/CompressedWriteBuffer.h>
#include <Formats/NativeWriter.h>
#include <Formats/formatBlock.h>
#include <Interpreters/Context.h>
#include <Interpreters/GraceHashJoin.h>
#include <Interpreters/HashJoin/HashJoin.h>
#include <Interpreters/TableJoin.h>
#include <Interpreters/TemporaryDataOn... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>ck_size) const override;
/// Open iterator over joined blocks.
/// Must be called after all @joinBlock calls.
IBlocksStreamPtr getDelayedBlocks() override;
bool hasDelayedBlocks() const override { return true; }
void onBuildPhaseFinish() override;
static bool isSupported(const s... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#pragma once
#include <Functions/FunctionFactory.h>
#include <Interpreters/InDepthNodeVisitor.h>
#include <Parsers/ASTFunction.h>
#include <Parsers/ASTIdentifier.h>
#include <Parsers/IAST.h>
namespace DB
{
/// recursive traversal and check for optimizeGroupByFunctionKeys
struct KeepFunctionMatcher
{
... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>]
|> runParallel)
Target.create "Format" (fun _ -> run dotnet ["fantomas"; "."; "-r"] "src")
open Fake.Core.TargetOperators
let dependencies = [
"Clean" ==> "InstallClient" ==> "Bundle" ==> "Azure"
"Clean" ==> "InstallClient" ==> "Run"
]
[<EntryPoint>]
let main args = runOrDefault args<|f... | fim | CompositionalIT/SAFE-Dojo | fsharp |
<|fim_prefix|>module Helpers
open Fake.Core
let initializeContext () =
let execContext = Context.FakeExecutionContext.Create false "build.fsx" []
Context.setExecutionContext (Context.RuntimeContext.Fake execContext)
module Proc =
module Parallel =
open System
let locker = obj ()
... | fim | CompositionalIT/SAFE-Dojo | fsharp |
<|fim_prefix|>module App
open Elmi<|fim_suffix|>Program Index.init Index.update Index.view
#if DEBUG
|> Program.withConsoleTrace
#endif
|> Program.withReactSynchronous "elmish-app"
#if DEBUG
|> Program.withDebugger
#endif
|> Program.run<|fim_middle|>sh
open Elmish.React
#if DEBUG
open Elmish.Debug
open Elmish.HMR
#en... | fim | CompositionalIT/SAFE-Dojo | fsharp |
<|fim_prefix|>module Index
open Elmish
open Feliz
open Feliz.Bulma
open Feliz.Recharts
open Feliz.PigeonMaps
open Elmish.SweetAlert
open Fable.Remoting.Client
open Shared
/// The different elements of the completed report.
type Report = {
Location: LocationResponse
Crimes: CrimeResponse array
}
type Server... | fim | CompositionalIT/SAFE-Dojo | fsharp |
<|fim_suffix|> |> Array.countBy (fun r -> r.Category)
|> Array.sortByDescending snd
|> Array.map (fun (k, c) -> { Crime = k; Incidents = c })
return crimes
}
let private asWeatherResponse (weather: Weather.OpenMeteoCurrentWeather.CurrentWeather) = {
WeatherType = weather.Weathercode |> Weathe... | fim | CompositionalIT/SAFE-Dojo | fsharp |
module DataAccess
open System
open FSharp.Data
open Shared
[<AutoOpen>]
module GeoLocation =
open FSharp.Data.UnitSystems.SI.UnitNames
[<Literal>]
let Sample =
"""{"status":200,"result":{"postcode":"EC2A 4NE","quality":1,"eastings":533041,"northings":182485,"country":"England","nhs_ha":"London","... | fim | CompositionalIT/SAFE-Dojo | fsharp |
<|fim_suffix|>e_router webApp
use_static "public"
use_gzip
}
run app<|fim_prefix|>open Fable.Remoting.Giraffe
<|fim_middle|>open Fable.Remoting.Server
open Saturn
open Shared
let webApp =
Remoting.createApi ()
|> Remoting.withRouteBuilder Route.builder
|> Remoting.fromValue Api.dojoApi
|> Remo... | fim | CompositionalIT/SAFE-Dojo | fsharp |
<|fim_prefix|>namespace Shared
type LatLong = { Latitude: float; Longitude: float }
type Location = {
Town: string
Region: string
LatLong: LatLong
}
type LocationResponse = {
Postcode: string
Location: Location
DistanceToLondon: float
}
type CrimeResponse = { Crime: string; Incidents: int }
... | fim | CompositionalIT/SAFE-Dojo | fsharp |
<|fim_suffix|>ource keyword
}
// Generate the ARM template here...
deployment |> Writer.quickWrite @"generated-template"
// Or deploy it directly to Azure here... (required Azure CLI installed!)
// deployment
// |> Deploy.execute "my-resource-group" Deploy.NoParameters<|fim_prefix|>open Farmer
open Farmer.Builders
/... | fim | CompositionalIT/farmer | fsharp |
<|fim_suffix|>te to orchestrate all of these.
let template = arm {
location Location.EastUS
add_resources [ scriptIdentity; farmerlogs; myAcr; buildImage; containerEnv ]
}
template.Template |> Writer.toJson |> Console.WriteLine<|fim_prefix|>#r "nuget: Farmer"
#r "nuget: FSharp.Text.Docker"
open System
open Fa... | fim | CompositionalIT/farmer | fsharp |
<|fim_prefix|>#r "nuget:Farmer"
open System
open System.<|fim_suffix|>er
let vnets = [ 1..4 ] |> Seq.map makeVnet |> List.ofSeq
let akses = [ 1..4 ] |> Seq.map makeAks |> List.ofSeq
arm {
add_resource msi
add_resources akses
add_resources vnets
}
|> Writer.quickWrite "aks-on-vnet"
<|fim_middle|>IO
open F... | fim | CompositionalIT/farmer | fsharp |
<|fim_prefix|>#r @"nuget:Farmer"
open Farmer
open Farmer.Builders
let workspace = logAnalytics { name "logana<|fim_suffix|>y.NoParameters<|fim_middle|>lytics-workspace" }
let myAppInsights = appInsights {
name "appInsights"
log_analytics_workspace workspace
}
let myFunctions = functions {
name "function... | fim | CompositionalIT/farmer | fsharp |
<|fim_suffix|>"deleteme" Deploy.NoParameters<|fim_prefix|>#r "nuget:Farmer"
open Farmer
open Farmer.Builders
let myAppInsights = appInsights { name "isaacsAi" }
let myFunctions = functions {
name "mysuperwebapp"
link_to_app_insights myAppInsights.Name
}
let template = arm {
location Locat<|fim_middle|>i... | fim | CompositionalIT/farmer | fsharp |
<|fim_suffix|> image "mcr.microsoft.com/azuredocs/aci-helloworld"
add_internal_ports [ 80us ]
}
]
network_profile "hello-aci-netprofile"
}
]
}
|> Writer.quickWrite "applicationGateway"<|fim_prefix|>#r "nuget: Farmer"
open Farmer
open ... | fim | CompositionalIT/farmer | fsharp |
<|fim_prefix|>#r "nuget:Farmer"
open Farmer
open Farmer.Builders
arm {
location Location.EastUS
add_resources [
vnet {
name "private-network"
add_address_spaces [ "10.1.0.0/16" ]
add_subnets [
subnet {
<|fim_suffix|> ... | fim | CompositionalIT/farmer | fsharp |
<|fim_suffix|>te "generated-template"<|fim_prefix|>#r "nuget:Farmer"
open Farmer
open Farmer.Builders
let isaacWebApp = webApp {
name "isaacsuperweb"
app_insights_off
}
let isaacStorage = storageAccount { name "isaacsuperstore" }
let isaacCdn = cdn {
name "isaacsupercdn"
add_endpoints [
end... | fim | CompositionalIT/farmer | fsharp |
<|fim_suffix|> ephemeral_storage 1.<Gb>
add_volume_mounts [ "empty-v", "/tmp"; "certs-v", "/certs" ]
}
]
replicas 1 10
add_env_variable "QueueName" queueName
add_secret_expression "queueconnectionstring" myStorageAcco... | fim | CompositionalIT/farmer | fsharp |
#r @"C:\Users\isaac\code\farmer\src\Farmer\bin\Debug\net5.0\Farmer.dll"
open Farmer
open Farmer.Builders
open Farmer.ContainerGroup
let nginx = containerInstance {
name "nginx"
image "nginx:1.17.6-alpine"
add_ports PublicPort [ 80us; 443us ]
add_ports InternalPort [ 9090us ]
memory 0.5<Gb>
cpu... | fim | CompositionalIT/farmer | fsharp |
<|fim_prefix|>#r "nuget:Farmer"
open Farmer
open Farmer.Builders
open Farmer.ContainerGroup
let template = arm {
location Location.WestEurope
add_resources [
contai<|fim_suffix|> name "container-group-with-gpu"
operating_system Linux
restart_policy ContainerGroup.Rest... | fim | CompositionalIT/farmer | fsharp |
<|fim_prefix|>#r "nuget:Farmer"
open Farmer
open Farmer.Builders
let containerGroupUser = userAssignedIdentity { name "aciUser" }
let template = arm {
location Location.WestEurope
add_resources [
containerGroupUser
containerGroup {
name "container-group-with-init"
ope... | fim | CompositionalIT/farmer | fsharp |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.