1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
|
#pragma once
#include <Common/NamePrompter.h>
#include <Parsers/IAST_fwd.h>
#include <Parsers/ASTCreateQuery.h>
#include <Storages/ColumnsDescription.h>
#include <Storages/ConstraintsDescription.h>
#include <Storages/IStorage_fwd.h>
#include <Storages/registerStorages.h>
#include <Access/Common/AccessType.h>
#include <unordered_map>
namespace DB
{
class Context;
struct StorageID;
/** Allows to create a table by the name and parameters of the engine.
* In 'columns' Nested data structures must be flattened.
* You should subsequently call IStorage::startup method to work with table.
*/
class StorageFactory : private boost::noncopyable, public IHints<1, StorageFactory>
{
public:
static StorageFactory & instance();
struct Arguments
{
const String & engine_name;
ASTs & engine_args;
ASTStorage * storage_def;
const ASTCreateQuery & query;
/// Path to table data.
/// Relative to <path> from server config (possibly <path> of some <disk> of some <volume> for *MergeTree)
const String & relative_data_path;
const StorageID & table_id;
ContextWeakMutablePtr local_context;
ContextWeakMutablePtr context;
const ColumnsDescription & columns;
const ConstraintsDescription & constraints;
bool attach;
bool has_force_restore_data_flag;
const String & comment;
ContextMutablePtr getContext() const;
ContextMutablePtr getLocalContext() const;
};
/// Analog of the IStorage::supports*() helpers
/// (But the former cannot be replaced with StorageFeatures due to nesting)
struct StorageFeatures
{
bool supports_settings = false;
bool supports_skipping_indices = false;
bool supports_projections = false;
bool supports_sort_order = false;
/// See also IStorage::supportsTTL()
bool supports_ttl = false;
/// See also IStorage::supportsReplication()
bool supports_replication = false;
/// See also IStorage::supportsDeduplication()
bool supports_deduplication = false;
/// See also IStorage::supportsParallelInsert()
bool supports_parallel_insert = false;
bool supports_schema_inference = false;
AccessType source_access_type = AccessType::NONE;
};
using CreatorFn = std::function<StoragePtr(const Arguments & arguments)>;
struct Creator
{
CreatorFn creator_fn;
StorageFeatures features;
};
using Storages = std::unordered_map<std::string, Creator>;
StoragePtr get(
const ASTCreateQuery & query,
const String & relative_data_path,
ContextMutablePtr local_context,
ContextMutablePtr context,
const ColumnsDescription & columns,
const ConstraintsDescription & constraints,
bool has_force_restore_data_flag) const;
/// Register a table engine by its name.
/// No locking, you must register all engines before usage of get.
void registerStorage(const std::string & name, CreatorFn creator_fn, StorageFeatures features = StorageFeatures{
.supports_settings = false,
.supports_skipping_indices = false,
.supports_projections = false,
.supports_sort_order = false,
.supports_ttl = false,
.supports_replication = false,
.supports_deduplication = false,
.supports_parallel_insert = false,
.supports_schema_inference = false,
.source_access_type = AccessType::NONE,
});
const Storages & getAllStorages() const
{
return storages;
}
std::vector<String> getAllRegisteredNames() const override
{
std::vector<String> result;
auto getter = [](const auto & pair) { return pair.first; };
std::transform(storages.begin(), storages.end(), std::back_inserter(result), getter);
return result;
}
using FeatureMatcherFn = std::function<bool(StorageFeatures)>;
std::vector<String> getAllRegisteredNamesByFeatureMatcherFn(FeatureMatcherFn feature_matcher_fn) const
{
std::vector<String> result;
for (const auto& pair : storages)
if (feature_matcher_fn(pair.second.features))
result.push_back(pair.first);
return result;
}
AccessType getSourceAccessType(const String & table_engine) const;
bool checkIfStorageSupportsSchemaInterface(const String & storage_name)
{
if (storages.contains(storage_name))
return storages[storage_name].features.supports_schema_inference;
return false;
}
private:
Storages storages;
};
}
|
