text stringlengths 14 100k | source stringclasses 1
value | repo stringclasses 810
values | language stringclasses 13
values |
|---|---|---|---|
#pragma once
#include "config.h"
#if USE_AVRO
#include <Databases/DataLake/ICatalog.h>
#include <Poco/Net/HTTPBasicCredentials.h>
#include <IO/ReadWriteBufferFromHTTP.h>
#include <IO/HTTPHeaderEntries.h>
#include <Interpreters/Context_fwd.h>
#include <filesystem>
#include <Poco/JSON/Object.h>
namespace DB
{
class Rea... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#pragma once
#include <Core/Types.h>
#include <Parsers/IAST_fwd.h>
#include <Parsers/ASTFunction.h>
#include <Parsers/ASTLiteral.h>
namespace DB::ErrorCodes
{
extern const int BAD_ARGUMENTS;
}
namespace DataLake
{
class IStorageCredentials
{
public:
virtual ~IStorageCredentials() = default;
... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Databases/DataLake/UnityCatalog.h>
#include <Interpreters/StorageID.h>
#if USE_PARQUET
#include <DataTypes/DataTypeNullable.h>
#include <Poco/URI.h>
#include <Poco/JSON/Array.h>
#include <Poco/JSON/Parser.h>
#include <Common/checkStackSize.h>
#include <IO/ReadHelpers.h>
#include <IO/Operators.... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>::Ptr & response) const;
std::shared_ptr<IStorageCredentials> parseAzureCredentials(const Poco::JSON::Object::Ptr & response) const;
bool getTableMetadataImpl(
const std::string & namespace_name,
const std::string & table_name,
TableMetadata & result) const;
ICatalog:... | fim | ClickHouse/ClickHouse | c |
#include <Databases/DataLake/ICatalog.h>
#include <gtest/gtest.h>
#include <Common/Exception.h>
#include <Core/SettingsEnums.h>
#include <base/types.h>
namespace DB::ErrorCodes
{
extern const int NOT_IMPLEMENTED;
}
namespace DataLake::Test
{
class AzureAbfssParsingTest : public ::testing::Test
{
protected:
void ... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <Databases/DataLake/StorageCredentials.h>
#include <IO/HTTPHeaderEntries.h>
#include <Common/HTTPHeaderFilter.h>
#include <gtest/gtest.h>
namespace DataLake::Test
{
class GCSCredentialsTest : public ::testing::Test
{
protected:
void SetUp() override {}
void TearDown() override {}
};
TE... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>mpTypeFromMetadata(metadata, "ts_col", "timestamp_nano");
EXPECT_EQ(result, "timestamp_ns");
}
TEST(GlueCatalog, ResolveTimestampTypeNotFoundFallbackTimestamp)
{
auto metadata = buildMetadata("other_col", "timestamptz");
// Column not found — glue_column_type "timestamp" falls back to "timest... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>sult = testParseHostPort("thrift://hive-metastore:9083/metastore");
EXPECT_EQ(result.first, "hive-metastore");
EXPECT_EQ(result.second, 9083);
result = testParseHostPort("thrift://hive-metastore:9083/metastore/db/table");
EXPECT_EQ(result.first, "hive-metastore");
EXPECT_EQ(result.sec... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <filesystem>
#include <thread>
#include <Core/Settings.h>
#include <Core/UUID.h>
#include <Databases/DatabaseAtomic.h>
#include <Databases/DatabaseFactory.h>
#include <Databases/DatabaseMetadataDiskSettings.h>
#include <Databases/DatabaseOnDisk.h>
#include <Databases/DatabaseReplicated.h>
#includ... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <Databases/DatabaseMetadataDiskSettings.h>
#include <Databases/DatabaseOrdinary.h>
#include <Databases/DatabasesCommon.h>
#include <Storages/IStorage_fwd.h>
namespace DB
{
/// All tables in DatabaseAtomic have persistent UUID and store data in
/// /clickhouse_path/store/xxx/xxxyy... | fim | ClickHouse/ClickHouse | c |
#include <Databases/DatabaseBackup.h>
#include <filesystem>
#include <boost/algorithm/string.hpp>
#include <Poco/Util/LayeredConfiguration.h>
#include <Common/ThreadPool.h>
#include <Common/threadPoolCallbackRunner.h>
#include <Common/setThreadName.h>
#include <IO/ReadBufferFromFileBase.h>
#include <Core/Settings... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <base/types.h>
#include <Parsers/IAST_fwd.h>
#include <Storages/IStorage_fwd.h>
#include <Databases/IDatabase.h>
#include <Databases/DatabaseOrdinary.h>
#include <Backups/BackupInfo.h>
namespace DB
{
class Context;
class IBackup;
/// DatabaseBackup provides access to backup ta... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>ared<DatabaseDictionary>(
args.database_name,
args.context);
};
factory.registerDatabase("Dictionary", create_fn, {}, Documentation{
.description = "A read-only database that automatically exposes every configured dictionary as a table.",
.syntax = "ENGINE =... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>ES(mutex);
ASTPtr getCreateTableQueryImpl(const String & table_name, ContextPtr context, bool throw_on_error) const override;
private:
LoggerPtr log;
Tables listTables(const FilterByNameFunction & filter_by_name) const;
};
}
<|fim_prefix|>#pragma once
#include <Databases/DatabasesCommon.h>... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>ation documentation)
{
if (!database_engines.emplace(name, Creator{std::move(creator_fn), features, std::move(documentation)}).second)
throw Exception(ErrorCodes::LOGICAL_ERROR, "DatabaseFactory: the database engine name '{}' is not unique", name);
}
DatabaseFactory & DatabaseFactory::instanc... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>.
/// Defaults to `std::nullopt` for non-source engines.
std::optional<AccessTypeObjects::Source> source_access_type = std::nullopt;
};
using CreatorFn = std::function<DatabasePtr(const Arguments & arguments)>;
struct Creator
{
CreatorFn creator_fn;
Engine... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|> auto * engine_define = args.create_query.storage;
const ASTFunction * engine = engine_define->engine;
const String & engine_name = engine_define->engine->name;
/// If init_path is empty, then the current path will be used
std::string init_path;
if (engine->... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>TPtr getCreateDatabaseQueryImpl() const override TSA_REQUIRES(mutex);
StoragePtr getTableImpl(const String & name, ContextPtr context, bool throw_on_error) const;
StoragePtr tryGetTableFromCache(const std::string & name) const;
std::string getTablePath(const std::string & table_name) const;
... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include "config.h"
#<|fim_suffix|>leImpl(name, context_);
}
catch (const Exception & e)
{
// Ignore exceptions thrown by TableFunctionHDFS, which indicate that there is no table
if (e.code() == ErrorCodes::BAD_ARGUMENTS
|| e.code() == ErrorCodes::ACCESS_DENIED
... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>ontextPtr &) const override;
DatabaseTablesIteratorPtr getTablesIterator(ContextPtr, const FilterByNameFunction &, bool) const override;
protected:
ASTPtr getCreateDatabaseQueryImpl() const override TSA_REQUIRES(mutex);
StoragePtr getTableImpl(const String & name, ContextPtr context) const;
... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>r-inversion if underlying storage need to resolve tables
table->drop();
if (table->storesDataOnDisk())
{
auto metdata_disk = getDisk();
metdata_disk->removeRecursive(getTableDataPath(table_name));
}
}
catch (...)
{
std::lock_guar... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>throw_on_error) const override;
/// DatabaseMemory allows to create tables, which store data on disk.
/// It's needed to create such tables in default database of clickhouse-local.
/// TODO May be it's better to use DiskMemory for such tables.
/// To save data on disk it's possible t... | fim | ClickHouse/ClickHouse | c |
#include <Databases/DatabaseMetadataDiskSettings.h>
#include <Parsers/ASTCreateQuery.h>
#include <Disks/DiskFromAST.h>
#include <Parsers/isDiskFunction.h>
#include <Parsers/FieldFromAST.h>
#include <Disks/IDisk.h>
#include <Interpreters/Context.h>
#include <Core/BaseSettings.h>
#include <Core/BaseSettingsFwdMacrosImpl... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>data);
private:
std::unique_ptr<DatabaseMetadataDiskSettingsImpl> impl;
};
}
<|fim_prefix|>#pragma once
#include <Core/BaseSettingsFwdMacros.h>
#include <Core/SettingsFields.h>
#include <Parsers/ASTCreateQuery.h>
namespace DB
{
class ASTStorage;
class Context;
struct MergeTreeSettings;
struct Data... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Databases/DatabaseOnDisk.h>
#include <filesystem>
#include <iterator>
#include <memory>
#include <span>
#include <Core/Settings.h>
#include <Core/UUID.h>
#include <Databases/DatabaseAtomic.h>
#include <Databases/DatabaseOrdinary.h>
#include <Disks/DiskLocal.h>
#include <Disks/IDisk.h>
#include ... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>ring & table_metadata_tmp_path, const String & table_metadata_path, ContextPtr query_context);
virtual void removeDetachedPermanentlyFlag(ContextPtr context, const String & table_name, const String & table_metadata_path, bool attach);
virtual void setDetachedTableNotInUseForce(const UUID & /*uuid... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <filesystem>
#include <memory>
#include <Core/Defines.h>
#include <Core/ServerSettings.h>
#include <Core/Settings.h>
#include <Core/UUID.h>
#include <Databases/DDLDependencyVisitor.h>
#include <Databases/DDLLoadingDependencyVisitor.h>
#include <Databases/DatabaseFactory.h>
#include <Databases/Da... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>ol skip_not_loaded) const override;
DatabaseDetachedTablesSnapshotIteratorPtr getDetachedTablesIterator(
ContextPtr local_context, const DatabaseOnDisk::FilterByNameFunction & filter_by_table_name, bool skip_not_loaded) const override;
Strings getAllTableNames(ContextPtr context) const ov... | fim | ClickHouse/ClickHouse | c |
#include <Databases/DatabaseOverlay.h>
#include <Common/quoteString.h>
#include <Common/typeid_cast.h>
#include <Common/AsyncLoader.h>
#include <Interpreters/Context.h>
#include <Interpreters/InterpreterCreateQuery.h>
#include <Parsers/ASTCreateQuery.h>
#include <Storages/IStorage_fwd.h>
#include <Core/UUID.h>
names... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <Storages/IStorage_fwd.h>
#include <Databases/IDatabase.h>
namespace DB
{
/**
* Implements the IDatabase interface an<|fim_suffix|>ip_not_loaded) const override;
bool empty() const override;
void shutdown() override;
/// Return false if at least one underlying data... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#pragma once
#include <atomic>
#include <optional>
#include <Databases/DatabaseAtomic.h>
#include <Databases/DatabaseReplicatedSettings.h>
#include <Interpreters/Context_fwd.h>
#include <Interpreters/QueryFlags.h>
#include <Parsers/SyncReplicaMode.h>
#include <QueryPipeline/BlockIO.h>
#include <base/def... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Common/assert_cast.h>
#include <Databases/DatabaseReplicatedHelpers.h>
#include <Databases/DatabaseReplicated.h>
namespace DB
{
String getReplicatedDatabaseShardName(const DatabasePtr & database)
{
return assert_cast<const DatabaseReplicated *>(databa<|fim_suffix|>getShardName();
}
String... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>{
class IDatabase;
using DatabasePtr = std::shared_ptr<IDatabase>;
String getReplicatedDatabaseShardName(const DatabasePtr & database);
String getReplicatedDatabaseReplicaName(const DatabasePtr & database);
}
<|fim_prefix|>#pragma once
#includ<|fim_middle|>e <Core/Types.h>
#include <memory>
namespace ... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>INGS_SUPPORTED_TYPES)
IMPLEMENT_SETTINGS_TRAITS(DatabaseReplicatedSettingsTraits, LIST_OF_DATABASE_REPLICATED_SETTINGS, DatabaseReplicatedSettings, DatabaseReplicatedSetting)
DatabaseReplicatedSettings::DatabaseReplicatedSettings() : impl(std::make_unique<DatabaseReplicatedSettingsImpl>())
{
}
DatabaseR... | fim | ClickHouse/ClickHouse | cpp |
#pragma once
#include <Core/BaseSettingsFwdMacros.h>
#include <Core/SettingsFields.h>
namespace Poco
{
namespace Util
{
class AbstractConfiguration;
}
}
namespace DB
{
class ASTStorage;
struct DatabaseReplicatedSettingsImpl;
/// List of available types supported in ReplicatedSettings object
#define DATABASE_REPLICA... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>timeout", entry_name);
return {};
}
}
}
}
if (!zookeeper->exists(fs::path(entry_path) / "committed"))
{
out_reason = fmt::format("Entry {} hasn't been committed", entry_name);
return {};
}
if (task->is_initial_qu... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>r, it may become dangling
ZooKeeperPtr active_node_holder_zookeeper;
/// It will remove "active" node when database is detached
zkutil::EphemeralNodeHolderPtr active_node_holder;
std::optional<Stopwatch> initialization_duration_timer;
mutable std::mutex initialization_duration_timer_m... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>_args[1], "access_key_id");
auto secret_key = checkAndGetLiteralArgument<String>(engine_args[2], "secret_access_key");
if (key_id.empty() || secret_key.empty() || boost::iequals(key_id, "NOSIGN"))
throw Exception::createRuntime(ErrorCodes::BAD_ARGUMENTS, error_mess... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include "config.h"
#if USE_AWS_S3
#include <mutex>
#include <Databases/IDatabase.h>
#include <Parsers/IAST_fwd.h>
#include <Storages/IStorage_fwd.h>
#include <base/types.h>
namespace DB
{
class Context;
/**
* DatabaseS3 provides access to data stored in S3.
* Uses TableFunctionS3 t... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>tabaseWithOwnTablesBase::attachTable(ContextPtr /* context_ */, const String & table_name, const StoragePtr & table, const String &)
{
std::lock_guard lock(mutex);
attachTableUnlocked(table_name, table);
}
void DatabaseWithOwnTablesBase::attachTableUnlocked(const String & table_name, const Storag... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>ASTPtr & ast_storage, bool only_ordinary,
uint32_t max_parser_depth, uint32_t max_parser_backtracks, bool throw_on_error, ContextPtr context);
/// Cleans a CREATE QUERY from temporary flags like "IF NOT EXISTS", "OR REPLACE", "AS SELECT" (for non-views), etc.
void cleanupObjectDefinitionFromTemporary... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <memory>
#include <Databases/IDatabase.h>
#include <Interpreters/Context.h>
#include <Interpreters/DatabaseCatalog.h>
#include <Interpreters/TableNameHints.h>
#include <Parsers/ASTCreateQuery.h>
#include <Storages/IStorage.h>
#include <Common/CurrentMetrics.h>
#include <Common/NamePrompter.h>
#in... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>t FilterByNameFunction & filter_by_table_name = {}, bool skip_not_loaded = false) const /// NOLINT
{
std::vector<LightWeightTableDetails> result;
for (auto iterator = getTablesIterator(context, filter_by_table_name, skip_not_loaded); iterator->isValid(); iterator->next())
{
... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Databases/LoadingStrictnessLevel.h>
#include <base/defines.h>
namespace DB
{
LoadingStrictnessLevel getLoadingStrictnessLevel(bool attach, bool force_attach, bool force_restore, bool secondary)
{
if (force_restore)
{
chassert(attach);
chassert(<|fim_suffix|>ingStrictne... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>bool secondary);
/// Returns true when a table or database is being loaded from previously-validated metadata
/// (server startup, force-restore, or UNDROP TABLE) rather than from a fresh user-supplied
/// query. Only in this case should security checks (e.g. `dynamic_disk_allow_*`) be skipped,
/// becau... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Common/ZooKeeper/ZooKeeperCommon.h>
#include "config.h"
#if USE_MYSQL
# include <filesystem>
# include <string>
# include <Columns/IColumn.h>
# include <Core/Settings.h>
# include <DataTypes/DataTypeDateTime.h>
# include <DataTypes/DataTypeNullable.h>
# include <DataTypes/D... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include "config.h"
#if USE_MYSQL
#include <mysqlxx/Pool.h>
#include <Common/ThreadPool.h>
#include <Storages/ColumnsDescription.h>
#include <Databases/DatabasesCommon.h>
#include <Parsers/ASTCreateQuery.h>
#include <mysqlxx/PoolWithFailover.h>
#include <atomic>
#include <condition_variab... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include "config.h"
#if USE_MYSQL
#include <Columns/IColumn.h>
#include <Core/Block.h>
#include <Core/Settings.h>
#include <Databases/MySQL/FetchTablesColumnsList.h>
#include <DataTypes/convertMySQLDataType.h>
#include <DataTypes/DataTypeString.h>
#include <DataTypes/DataTypesNumber.h>
#include <Processo... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>ettings & settings,
MultiEnum<MySQLDataTypesSupport> type_support);
}
#endif
<|fim_prefix|>#pragma once
#include "config.h"
#if USE_MYSQL
#include <mysqlxx/PoolWithFailover.h>
#include <base/types.h>
#include <Core/MultiEnum.h>
#include <Core/SettingsEnums.h>
#include <Storages/ColumnsDescrip... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Databases/NormalizeAndEvaluateConstantsVisitor.h>
#include <Interpreters/Context.h>
#include <Interpreters/evaluateConstantExpression.h>
#include <Parsers/ASTFunction.h>
#include <Parsers/ASTFunctionWithKeyValueArguments.h>
namespace DB
{
void NormalizeAndEvaluateConstants::visit(const ASTPtr... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <Core/QualifiedTableName.h>
#include <Pa<|fim_suffix|>onst ASTFunctionWithKeyValueArguments & dict_source, Data & data);
};
using NormalizeAndEvaluateConstantsVisitor = NormalizeAndEvaluateConstants::Visitor;
}
<|fim_middle|>rsers/IAST_fwd.h>
#include <Interpreters/InDepthNodeVisi... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Databases/PostgreSQL/DatabaseMaterializedPostgreSQL.h>
#include <Storages/PostgreSQL/MaterializedPostgreSQLSettings.h>
#if USE_LIBPQXX
#include <Storages/PostgreSQL/StorageMaterializedPostgreSQL.h>
#include <Databases/PostgreSQL/fetchPostgreSQLTableStructure.h>
#include <Common/CurrentThread.... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|><PostgreSQLReplicationHandler> replication_handler;
std::map<std::string, StoragePtr> materialized_tables;
mutable std::mutex tables_mutex;
mutable std::mutex handler_mutex;
BackgroundSchedulePoolTaskHolder startup_task;
std::atomic<bool> shutdown_called = false;
LoadTaskPtr star... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>iguration.schema = safeGetLiteralValue<String>(engine_args[4], engine_name);
}
else
{
use_table_cache = safeGetLiteralValue<UInt8>(engine_args[4], engine_name);
LOG_WARNING(getLogger("DatabaseFactory"), "A deprecated s... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>ride;
StoragePtr detachTable(ContextPtr context, const String & table_name) override;
void drop(ContextPtr /*context*/) override;
void shutdown() override;
std::vector<std::pair<ASTPtr, StoragePtr>> getTablesForBackup(const FilterByNameFunction &, const ContextPtr &) const override { ret... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Databases/PostgreSQL/fetchPostgreSQLTableStructure.h>
#if USE_LIBPQXX
#include <DataTypes/DataTypeFactory.h>
#include <DataTypes/DataTypeString.h>
#include <DataTypes/DataTypesNumber.h>
#include <DataTypes/DataTypeNullable.h>
#include <DataTypes/DataTypeArray.h>
#include <DataTypes/DataTypesDe... | fim | ClickHouse/ClickHouse | cpp |
#pragma once
#include "config.h"
#if USE_LIBPQXX
#include <Core/PostgreSQL/ConnectionHolder.h>
#include <Core/NamesAndTypes.h>
namespace DB
{
struct PostgreSQLTableStructure
{
struct PGAttribute
{
Int32 atttypid;
Int32 atttypmod;
Int32 attnum;
bool atthasdef;
char at... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>children;
String database_path = safeGetLiteralValue<String>(arguments[0], "SQLite");
return std::make_shared<DatabaseSQLite>(args.context, engine_define, args.create_query.attach, database_path);
};
factory.registerDatabase("SQLite", create_fn, {
.supports_arguments = tr... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>yNameFunction & filter_by_table_name, bool skip_not_loaded) const override;
bool empty() const override;
void shutdown() override {}
protected:
ASTPtr getCreateDatabaseQueryImpl() const override TSA_REQUIRES(mutex);
ASTPtr getCreateTableQueryImpl(const String & table_name, ContextPtr co... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>getLogger("SQLite"), "SQLite database path {} does not exist, will create an empty SQLite database", database_path);
sqlite3 * tmp_sqlite_db = nullptr;
int status = 0;
{
std::lock_guard lock(init_sqlite_db_mutex);
status = sqlite3_open(database_path.c_str(), &tmp_sqlite_db);
... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma<|fim_suffix|>ypes.h>
#include <Interpreters/Context_fwd.h>
#include <sqlite3.h>
namespace DB
{
using SQLitePtr = std::shared_ptr<sqlite3>;
SQLitePtr openSQLiteDB(const String & database_path, ContextPtr context, bool throw_on_error = true);
}
#endif
<|fim_middle|> once
#include "config.h"
... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Databases/SQLite/fetchSQLiteTableStructure.h>
#if USE_SQLITE
#include <Common/quoteString.h>
#include <DataTypes/DataTypeArray.h>
#include <DataTypes/DataTypeDate.h>
#include <DataTypes/DataTypeDateTime.h>
#include <DataTypes/DataTypeFactory.h>
#include <DataTypes/DataTypeNullable.h>
#include ... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>chSQLiteTableStructure(sqlite3 * connection,
const String & sqlite_table_name);
}
#endif
<|fim_prefix|>#pragma once
#include "config.h"
#if USE_SQLITE
#include <Storages/S<|fim_middle|>torageSQLite.h>
#include <sqlite3.h>
namespace DB
{
st... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>, const TableNamesSet & dependencies)
{
addDependencies(StorageID{table_name}, dependencies);
}
bool TablesDependencyGraph::removeDependency(const StorageID & table_id, const StorageID & dependency, bool remove_isolated_tables)
{
auto * table_node = findNode(table_id);
if (!table_node)
... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>t = 0;
explicit Node(const StorageID & storage_id_) : storage_id(storage_id_) {}
};
using NodeSharedPtr = std::shared_ptr<Node>;
struct Hash
{
using is_transparent = void;
size_t operator()(const Node * node) const { return std::hash<const Node *>{}(node); }
... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>onary.
LOG_WARNING(
log,
"Tables {} depend on XML dictionary {}, but XML dictionaries are loaded independently."
"Consider converting it to DDL dictionary.",
fmt::join(all_loading_dependencies.getDependents(table_id), ", "),
... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>ng default_database;
std::mutex mutex;
ParsedMetadata parsed_tables;
/// For logging
size_t total_dictionaries = 0;
size_t total_materialized_views = 0;
};
/// Loads tables (and dictionaries) from specified databases
/// taking into account dependencies between them.
class TablesLoa... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Databases/enableAllExperimentalSettings.h>
#include <Interpreters/Context.h>
#include <Core/Field.h>
namespace DB
{
/*
* Enables all settings that allow the use of experimental, deprecated, or potentially unsafe features
* in a CREATE query. This function is used in DatabaseReplicated::recov... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>ted::recoverLostReplica() to create tables
* when the original settings used to create the table are not available.
*/
void enableAllExperimentalSettings(ContextMutablePtr context);
}
<|fim_prefix|>#pragma once
#include <Interpreters/Context_fwd.h>
namespace DB
{
/*
* Ena<|fim_middle|>bles all sett... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>tabaseBackup(factory);
}
}
<|fim_prefix|>#include "config.h"
#include <Databases/DatabaseFactory.h>
#include <Databases/registerDatabases.h>
namespace DB
{
void registerDatabaseAtomic(DatabaseFactory & factory);
void registerDatabaseOrdinary(DatabaseFactory & factory);
void registerDatabaseDictionary(... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma onc<|fim_suffix|>tabases();
}
<|fim_middle|>e
namespace DB
{
void registerDa<|endoftext|> | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Databases/removeWhereConditionPlaceholder.h>
namespace DB
{
std::string remo<|fim_suffix|>ndition_position, CONDITION_PLACEHOLDER_TO_REPLACE_VALUE.size(), true_condition);
return query_copy;
}
return query;
}
}
<|fim_middle|>veWhereConditionPlaceholder(const std::string & que... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>dition} for dictionary that must load all data.
* Replace {condition} with true_condition for initial dictionary load.
* For next dictionary loads {condition} will be updated with UPDATE_FIELD.
*/
std::string removeWhereConditionPlaceholder(const std::string & query);
}
<|fim_prefix|>#pragma once
#... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>torWithMemoryTracking<UInt64> requested_keys_vector;
VectorWithMemoryTracking<size_t> requested_complex_key_rows;
if constexpr (dictionary_key_type == DictionaryKeyType::Simple)
requested_keys_vector.reserve(requested_keys.size());
else
requested_complex_key_rows.reserve(reque... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>xception() const override;
bool hasHierarchy() const override { return dictionary_key_type == DictionaryKeyType::Simple && dict_struct.hierarchical_attribute_index.has_value(); }
ColumnPtr getHierarchy(ColumnPtr key_column, const DataTypePtr & key_type) const override;
ColumnUInt8::Ptr isIn... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|> arena.free(const_cast<char *>(previous_value.data()), previous_value.size());
}
}
});
}
if (cell.key != key)
{
if constexpr (std::is_sam... | fim | ClickHouse/ClickHouse | c |
#include <Dictionaries/CacheDictionaryUpdateQueue.h>
#include <Common/CurrentMetrics.h>
#include <Common/setThreadName.h>
namespace CurrentMetrics
{
extern const Metric CacheDictionaryThreads;
extern const Metric CacheDictionaryThreadsActive;
extern const Metric CacheDictionaryThreadsScheduled;
}
namespa... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <mutex>
#include <functional>
#include <Common/ThreadPool.h>
#include <Common/ConcurrentBoundedQueue.h>
#include <Common/CurrentMetrics.h>
#include <Common/PODArray.h>
#include <Common/HashTable/HashMap.h>
#include <Columns/IColumn_fwd.h>
#include <Dictionaries/ICacheDictionaryStor... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Dictionaries/CassandraDictionarySource.h>
#include <Columns/IColumn.h>
#include <Interpreters/Context.h>
#include <QueryPipeline/Pipe.h>
#include <QueryPipeline/QueryPipeline.h>
#include <Common/RemoteHostFilter.h>
#include <Dictionaries/DictionarySourceFactory.h>
#include <Dictionaries/Dictiona... | fim | ClickHouse/ClickHouse | cpp |
#pragma once
#include <Dictionaries/CassandraHelpers.h>
#include <QueryPipeline/BlockIO.h>
#if USE_CASSANDRA
#include <Dictionaries/DictionaryStructure.h>
#include <Dictionaries/IDictionarySource.h>
#include <Dictionaries/ExternalQueryBuilder.h>
#include <Interpreters/Context_fwd.h>
#include <mutex>
namespace DB
{
... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Dictionaries/CassandraHelpers.h>
#if USE_CASSANDRA
#include <Common/Exception.h>
#include <Common/logger_useful.h>
#include <mutex>
namespace DB
{
namespace ErrorCodes
{
extern const int CASSANDRA_INTERNAL_ERROR;
}
void cassandraCheck(CassError code)
{
if (code != CASS_OK)
throw ... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include "config.h"
#if USE_CASSANDRA
#include <cassandra.h>
#include <utility>
#includ<|fim_suffix|>nullptr; }
/// RAII wrapper for raw pointers to objects from cassandra driver library
template<typename CassT, auto Dtor, auto Ctor = defaultCtor<CassT>>
class ObjectHolder
{
CassT * pt... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|> case ExternalResultDescription::ValueType::vtString:
expected = CASS_VALUE_TYPE_TEXT;
expected_text = "text, ascii or varchar";
break;
case ExternalResultDescription::ValueType::vtDate:
expected = CASS_VALUE_TYPE_DATE;
... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>size;
ExternalResultDescription description;
cass_bool_t has_more_pages;
bool assert_types = true;
bool is_initialized = false;
};
}
#endif
<|fim_prefix|>#pragma once
#include <Dictionaries/CassandraHelpers.h>
#if USE_CASSANDRA
#include <Processors/ISource.h>
#include <Core/ExternalRes... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>ool(configuration)}
, load_all_query{query_builder->composeLoadAllQuery()}
{
}
ClickHouseDictionarySource::ClickHouseDictionarySource(const ClickHouseDictionarySource & other)
: update_time{other.update_time}
, dict_struct{other.dict_struct}
, configuration{other.configuration}
, inva... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>= getLogger("ClickHouseDictionarySource");
/// RegExpTreeDictionary is the only dictionary whose structure of attributions differ from the input block.
/// For now we need to modify sample_block in the ctor of RegExpTreeDictionary.
friend class RegExpTreeDictionary;
};
}
<|fim_prefix|>#pragm... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>to it = registered_layouts.find(layout_type);
if (it == registered_layouts.end())
{
throw Exception(ErrorCodes::UNKNOWN_ELEMENT_IN_CONFIG,
"Unknown dictionary layout type: {}",
layout_type);
}
if (!it->second.is_layout_complex && it... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>ex;
bool has_layout_complex;
Documentation documentation;
};
using LayoutRegistry = UnorderedMapWithMemoryTracking<std::string, RegisteredLayout>;
LayoutRegistry registered_layouts;
};
}
<|fim_prefix|>#pragma once
#include <Interpreters/Context_fwd.h>
#include <Common/Docum... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>}
<|fim_prefix|>#include <Dictionaries/DictionaryHelpers.h>
namespace DB
{
MutableColumns deserializeColumnsFromKeys(
const DictionaryStructure & dictionary_structure,
const PaddedPODArray<std::string_view> & keys,
size_t start,
size_t end)
{
MutableColumns result_columns;
result... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>reserve(key_columns_size);
/// Split into keys columns and attribute columns
for (size_t i = 0; i < key_columns_size; ++i)
saved_block_key_columns.emplace_back(block_to_update.safeGetByPosition(i).column);
DictionaryKeysArenaHolder<dictionary_key_type> arena_holder;
DictionaryKey... | fim | ClickHouse/ClickHouse | c |
#include <Dictionaries/DictionaryPipelineExecutor.h>
#include <Core/Block.h>
#include <Processors/Executors/PullingAsyncPipelineExecutor.h>
#include <Processors/Executors/PullingPipelineExecutor.h>
#include <QueryPipeline/QueryPipeline.h>
#include <Common/Exception.h>
namespace DB
{
namespace ErrorCodes
{
extern con... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <memory>
namespace DB
{
<|fim_suffix|>PullingPipelineExecutor> executor;
};
}
<|fim_middle|>class Block;
class QueryPipeline;
class PullingAsyncPipelineExecutor;
class PullingPipelineExecutor;
/// Wrapper for `Pulling(Async)PipelineExecutor` to dynamically dispatch calls to the ... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Core/NamesAndTypes.h>
#include <Dictionaries/DictionaryHelpers.h>
#include <Dictionaries/DictionarySource.h>
#include <Processors/ISource.h>
namespace DB
{
namespace ErrorCodes
{
extern const int LOGICAL_ERROR;
extern const int NO_SUCH_COLUMN_IN_TABLE;
}
class DictionarySource : publ... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <memory>
#include <Columns/IColumn_fwd.h>
#include <Core/Names.h>
#include <Core/Types.h>
#include <Dictionaries/IDictionary.h>
#include <boost/noncopyable.hpp>
namespace DB
{
class DictionarySource;
class DictionarySourceCoordinator final : public std::enable_shared_from_this<D... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Dictionaries/DictionarySourceFactory.h>
#include <Columns/ColumnsNumber.h>
#include <Core/Block.h>
#include <Core/ColumnWithTypeAndName.h>
#include <DataTypes/DataTypeNullable.h>
#include <DataTypes/DataTypesNumber.h>
#include <Poco/Logger.h>
#include <Common/logger_useful.h>
#include <Dictiona... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <Dictionaries/IDictionarySource.h>
#include <Interpreters/Context_fwd.h>
#include <Common/Docume<|fim_suffix|>isterSource(const std::string & source_type, Creator create_source, Documentation documentation = {});
std::vector<String> getAllRegisteredNames() const; // STYLE_CHECK... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Dictionaries/DictionarySourceHelpers.h>
#include <Columns/ColumnsNumber.h>
#include <Core/ColumnWithTypeAndName.h>
#include <DataTypes/DataTypesNumber.h>
#include <IO/WriteHelpers.h>
#include <Dictionaries/DictionaryStructure.h>
#include <Interpreters/Context.h>
#include <Core/Settings.h>
#inclu... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>nst Poco::Util::AbstractConfiguration & config, const std::string & config_prefix);
/** A stream, adds additional columns to each block that it will read from inner stream.
*
* block_to_add rows size must be equal to final sum rows size of all inner stream blocks.
*/
class TransformWithAd... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>injective = config.getBool(prefix + "injective", false);
const auto is_object_id = config.getBool(prefix + "is_object_id", false);
if (name.empty())
throw Exception(ErrorCodes::BAD_ARGUMENTS, "Properties 'name' and 'type' of an attribute cannot be empty");
if (has_hie... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>alizationPtr type_serialization;
const std::string expression;
const Field null_value;
const AttributeUnderlyingType underlying_type;
const bool hierarchical;
const bool bidirectional;
const bool injective;
const bool is_object_id;
const bool is_nullable;
};
template <Attr... | fim | ClickHouse/ClickHouse | c |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.