30 namespace foreign_storage {
43 const std::list<Catalog_Namespace::UserMetadata>& all_users,
44 std::map<std::string, import_export::TypedImportBuffer*>& import_buffers) {
45 for (
const auto& user : all_users) {
46 if (import_buffers.find(
"user_id") != import_buffers.end()) {
47 import_buffers[
"user_id"]->addInt(user.userId);
49 if (import_buffers.find(
"user_name") != import_buffers.end()) {
50 import_buffers[
"user_name"]->addString(user.userName);
52 if (import_buffers.find(
"is_super_user") != import_buffers.end()) {
53 import_buffers[
"is_super_user"]->addBoolean(user.isSuper);
55 if (import_buffers.find(
"default_db_id") != import_buffers.end()) {
56 import_buffers[
"default_db_id"]->addInt(user.defaultDbId);
58 if (import_buffers.find(
"default_db_name") != import_buffers.end()) {
59 if (user.defaultDbId > 0) {
60 import_buffers[
"default_db_name"]->addString(
get_db_name(user.defaultDbId));
62 set_null(import_buffers[
"default_db_name"]);
65 if (import_buffers.find(
"can_login") != import_buffers.end()) {
66 import_buffers[
"can_login"]->addBoolean(user.can_login);
74 if (sys_catalog.getMetadataForUserById(user_id, user_metadata)) {
83 std::string table_type{
"DEFAULT"};
87 table_type =
"TEMPORARY";
89 table_type =
"FOREIGN";
97 auto ddl = catalog->dumpCreateTable(td.
tableId);
98 if (!ddl.has_value()) {
107 const std::map<int32_t, std::vector<TableDescriptor>>& tables_by_database,
108 std::map<std::string, import_export::TypedImportBuffer*>& import_buffers) {
109 for (
const auto& [db_id,
tables] : tables_by_database) {
110 for (
const auto& table :
tables) {
111 if (import_buffers.find(
"database_id") != import_buffers.end()) {
112 import_buffers[
"database_id"]->addInt(db_id);
114 if (import_buffers.find(
"database_name") != import_buffers.end()) {
115 import_buffers[
"database_name"]->addString(
get_db_name(db_id));
117 if (import_buffers.find(
"table_id") != import_buffers.end()) {
118 import_buffers[
"table_id"]->addInt(table.tableId);
120 if (import_buffers.find(
"table_name") != import_buffers.end()) {
121 import_buffers[
"table_name"]->addString(table.tableName);
123 if (import_buffers.find(
"owner_id") != import_buffers.end()) {
124 import_buffers[
"owner_id"]->addInt(table.userId);
126 if (import_buffers.find(
"owner_user_name") != import_buffers.end()) {
127 import_buffers[
"owner_user_name"]->addString(
get_user_name(table.userId));
129 if (import_buffers.find(
"column_count") != import_buffers.end()) {
130 import_buffers[
"column_count"]->addInt(table.nColumns);
132 if (import_buffers.find(
"table_type") != import_buffers.end()) {
135 if (import_buffers.find(
"view_sql") != import_buffers.end()) {
136 import_buffers[
"view_sql"]->addString(table.viewSQL);
138 if (import_buffers.find(
"max_fragment_size") != import_buffers.end()) {
139 import_buffers[
"max_fragment_size"]->addInt(table.maxFragRows);
141 if (import_buffers.find(
"max_chunk_size") != import_buffers.end()) {
142 import_buffers[
"max_chunk_size"]->addBigint(table.maxChunkSize);
144 if (import_buffers.find(
"fragment_page_size") != import_buffers.end()) {
145 import_buffers[
"fragment_page_size"]->addInt(table.fragPageSize);
147 if (import_buffers.find(
"max_rows") != import_buffers.end()) {
148 import_buffers[
"max_rows"]->addBigint(table.maxRows);
150 if (import_buffers.find(
"max_rollback_epochs") != import_buffers.end()) {
151 import_buffers[
"max_rollback_epochs"]->addInt(table.maxRollbackEpochs);
153 if (import_buffers.find(
"shard_count") != import_buffers.end()) {
154 import_buffers[
"shard_count"]->addInt(table.nShards);
156 if (import_buffers.find(
"ddl_statement") != import_buffers.end()) {
157 import_buffers[
"ddl_statement"]->addString(
get_table_ddl(db_id, table));
164 rapidjson::Document document;
165 document.Parse(dashboard_metadata);
166 if (!document.IsObject()) {
169 auto data_sources_str =
171 std::vector<std::string> data_sources;
172 if (data_sources_str.has_value()) {
173 data_sources =
split(data_sources_str.value(),
",");
174 for (
auto it = data_sources.begin(); it != data_sources.end();) {
176 static std::regex parameter_regex{
"\\$\\{.+\\}"};
177 if (std::regex_match(*it, parameter_regex)) {
179 it = data_sources.erase(it);
189 const std::map<int32_t, std::vector<DashboardDescriptor>>& dashboards_by_database,
190 std::map<std::string, import_export::TypedImportBuffer*>& import_buffers) {
191 for (
const auto& [db_id, dashboards] : dashboards_by_database) {
192 for (
const auto& dashboard : dashboards) {
193 if (import_buffers.find(
"database_id") != import_buffers.end()) {
194 import_buffers[
"database_id"]->addInt(db_id);
196 if (import_buffers.find(
"database_name") != import_buffers.end()) {
197 import_buffers[
"database_name"]->addString(
get_db_name(db_id));
199 if (import_buffers.find(
"dashboard_id") != import_buffers.end()) {
200 import_buffers[
"dashboard_id"]->addInt(dashboard.dashboardId);
202 if (import_buffers.find(
"dashboard_name") != import_buffers.end()) {
203 import_buffers[
"dashboard_name"]->addString(dashboard.dashboardName);
205 if (import_buffers.find(
"owner_id") != import_buffers.end()) {
206 import_buffers[
"owner_id"]->addInt(dashboard.userId);
208 if (import_buffers.find(
"owner_user_name") != import_buffers.end()) {
209 import_buffers[
"owner_user_name"]->addString(
get_user_name(dashboard.userId));
211 if (import_buffers.find(
"last_updated_at") != import_buffers.end()) {
212 auto& buffer = import_buffers[
"last_updated_at"];
213 import_buffers[
"last_updated_at"]->add_value(
214 buffer->getColumnDesc(), dashboard.updateTime,
false, {});
216 if (import_buffers.find(
"data_sources") != import_buffers.end()) {
217 import_buffers[
"data_sources"]->addStringArray(
227 std::vector<std::string> permissions;
231 permissions.emplace_back(
"all");
234 permissions.emplace_back(
"view_sql_editor");
237 permissions.emplace_back(
"access");
242 permissions.emplace_back(
"all");
245 if (object_id == -1) {
249 permissions.emplace_back(
"select" + suffix);
252 permissions.emplace_back(
"insert" + suffix);
255 permissions.emplace_back(
"update" + suffix);
258 permissions.emplace_back(
"delete" + suffix);
261 permissions.emplace_back(
"truncate" + suffix);
264 permissions.emplace_back(
"alter" + suffix);
267 permissions.emplace_back(
"drop" + suffix);
270 permissions.emplace_back(
"create table");
275 permissions.emplace_back(
"all");
278 if (object_id == -1) {
279 suffix =
" dashboard";
282 permissions.emplace_back(
"view" + suffix);
285 permissions.emplace_back(
"edit" + suffix);
288 permissions.emplace_back(
"delete" + suffix);
291 permissions.emplace_back(
"create dashboard");
296 permissions.emplace_back(
"all");
299 if (object_id == -1) {
303 permissions.emplace_back(
"select" + suffix);
306 permissions.emplace_back(
"drop" + suffix);
309 permissions.emplace_back(
"create view");
314 permissions.emplace_back(
"all");
317 if (object_id == -1) {
321 permissions.emplace_back(
"alter" + suffix);
324 permissions.emplace_back(
"usage" + suffix);
327 permissions.emplace_back(
"drop" + suffix);
330 permissions.emplace_back(
"create server");
334 UNREACHABLE() <<
"Unexpected object type: " << object_type;
340 std::string object_type_str;
343 object_type_str =
"database";
345 object_type_str =
"table";
347 object_type_str =
"dashboard";
349 object_type_str =
"view";
351 object_type_str =
"server";
353 UNREACHABLE() <<
"Unexpected object type: " << object_type;
355 return object_type_str;
359 const std::vector<ObjectRoleDescriptor>& object_permissions,
360 std::map<std::string, import_export::TypedImportBuffer*>& import_buffers) {
361 for (
const auto& permission : object_permissions) {
362 if (import_buffers.find(
"role_name") != import_buffers.end()) {
363 import_buffers[
"role_name"]->addString(permission.roleName);
365 if (import_buffers.find(
"is_user_role") != import_buffers.end()) {
366 import_buffers[
"is_user_role"]->addBoolean(permission.roleType);
368 if (import_buffers.find(
"database_id") != import_buffers.end()) {
369 import_buffers[
"database_id"]->addInt(permission.dbId);
371 if (import_buffers.find(
"database_name") != import_buffers.end()) {
372 import_buffers[
"database_name"]->addString(
get_db_name(permission.dbId));
374 if (import_buffers.find(
"object_name") != import_buffers.end()) {
375 import_buffers[
"object_name"]->addString(permission.objectName);
377 if (import_buffers.find(
"object_id") != import_buffers.end()) {
378 import_buffers[
"object_id"]->addInt(permission.objectId);
380 if (import_buffers.find(
"object_owner_id") != import_buffers.end()) {
381 import_buffers[
"object_owner_id"]->addInt(permission.objectOwnerId);
383 if (import_buffers.find(
"object_owner_user_name") != import_buffers.end()) {
384 import_buffers[
"object_owner_user_name"]->addString(
387 if (import_buffers.find(
"object_permission_type") != import_buffers.end()) {
388 import_buffers[
"object_permission_type"]->addString(
391 if (import_buffers.find(
"object_permissions") != import_buffers.end()) {
393 get_permissions(permission.privs, permission.objectType, permission.objectId);
394 import_buffers[
"object_permissions"]->addStringArray(permissions);
400 const std::list<Catalog_Namespace::DBMetadata>& databases,
401 std::map<std::string, import_export::TypedImportBuffer*>& import_buffers) {
402 for (
const auto& db : databases) {
403 if (import_buffers.find(
"database_id") != import_buffers.end()) {
404 import_buffers[
"database_id"]->addInt(db.dbId);
406 if (import_buffers.find(
"database_name") != import_buffers.end()) {
407 import_buffers[
"database_name"]->addString(db.dbName);
409 if (import_buffers.find(
"owner_id") != import_buffers.end()) {
410 import_buffers[
"owner_id"]->addInt(db.dbOwner);
412 if (import_buffers.find(
"owner_user_name") != import_buffers.end()) {
413 import_buffers[
"owner_user_name"]->addString(
get_user_name(db.dbOwner));
419 const std::set<std::string>& roles,
420 std::map<std::string, import_export::TypedImportBuffer*>& import_buffers) {
421 for (
const auto& role : roles) {
422 CHECK(import_buffers.find(
"role_name") != import_buffers.end());
423 import_buffers[
"role_name"]->addString(role);
428 const std::map<std::string, std::vector<std::string>>& user_names_by_role_,
429 std::map<std::string, import_export::TypedImportBuffer*>& import_buffers) {
430 for (
const auto& [role, user_names] : user_names_by_role_) {
431 for (
const auto& user_name : user_names) {
432 if (import_buffers.find(
"role_name") != import_buffers.end()) {
433 import_buffers[
"role_name"]->addString(role);
435 if (import_buffers.find(
"user_name") != import_buffers.end()) {
436 import_buffers[
"user_name"]->addString(user_name);
443 std::map<int32_t, std::vector<TableDescriptor>> tables_by_database;
445 for (
const auto& catalog : sys_catalog.getCatalogsForAllDbs()) {
447 for (
const auto& td : catalog->getAllTableMetadataCopy()) {
448 tables_by_database[catalog->getDatabaseId()].emplace_back(td);
452 return tables_by_database;
456 std::map<int32_t, std::vector<DashboardDescriptor>> dashboards_by_database;
458 for (
const auto& catalog : sys_catalog.getCatalogsForAllDbs()) {
460 for (
const auto& dashboard : catalog->getAllDashboardsMetadataCopy()) {
461 dashboards_by_database[catalog->getDatabaseId()].emplace_back(dashboard);
465 return dashboards_by_database;
470 const auto& users = sys_catalog.getAllUserMetadata();
471 std::map<std::string, std::vector<std::string>> user_names_by_role;
472 for (
const auto& user : users) {
473 for (
const auto& role :
474 sys_catalog.getRoles(
false, user.isSuper, user.userName,
true)) {
475 user_names_by_role[role].emplace_back(user.userName);
478 return user_names_by_role;
483 const std::string& table_name) {
509 users_ = sys_catalog.getAllUserMetadata();
527 roles_ = sys_catalog.getCreatedRoles();
542 const std::string& table_name,
543 std::map<std::string, import_export::TypedImportBuffer*>& import_buffers) {
static const AccessPrivileges VIEW_SQL_EDITOR
static const AccessPrivileges VIEW_DASHBOARD
static const AccessPrivileges DROP_SERVER
std::vector< std::string > get_data_sources(const std::string &dashboard_metadata)
static const AccessPrivileges ALL_DATABASE
static const AccessPrivileges ALTER_TABLE
std::set< std::string > roles_
std::string get_table_ddl(int32_t db_id, const TableDescriptor &td)
InternalCatalogDataWrapper()
std::vector< std::string > get_permissions(const AccessPrivileges privileges, int32_t object_type, int32_t object_id)
static const AccessPrivileges TRUNCATE_TABLE
static constexpr const char * DASHBOARDS_SYS_TABLE_NAME
constexpr const char * kDeletedValueIndicator
std::map< int32_t, std::vector< DashboardDescriptor > > get_all_dashboards()
void populate_import_buffers_for_catalog_dashboards(const std::map< int32_t, std::vector< DashboardDescriptor >> &dashboards_by_database, std::map< std::string, import_export::TypedImportBuffer * > &import_buffers)
static const AccessPrivileges INSERT_INTO_TABLE
static const AccessPrivileges CREATE_DASHBOARD
static const AccessPrivileges SERVER_USAGE
void populateChunkBuffersForTable(const std::string &table_name, std::map< std::string, import_export::TypedImportBuffer * > &import_buffers) override
const std::string kInfoSchemaDbName
bool isForeignTable() const
static const AccessPrivileges SELECT_FROM_TABLE
std::string suffix(SQLTypes type)
static const AccessPrivileges ALL_VIEW
std::vector< ObjectRoleDescriptor > object_permissions_
static const AccessPrivileges ALTER_SERVER
This file contains the class specification and related data structures for Catalog.
static constexpr const char * ROLES_SYS_TABLE_NAME
static SysCatalog & instance()
This file contains the class specification and related data structures for SysCatalog.
static const AccessPrivileges DROP_TABLE
void populate_import_buffers_for_catalog_permissions(const std::vector< ObjectRoleDescriptor > &object_permissions, std::map< std::string, import_export::TypedImportBuffer * > &import_buffers)
void populate_import_buffers_for_catalog_tables(const std::map< int32_t, std::vector< TableDescriptor >> &tables_by_database, std::map< std::string, import_export::TypedImportBuffer * > &import_buffers)
CONSTEXPR DEVICE void set_null(T &value)
std::list< Catalog_Namespace::UserMetadata > users_
void populate_import_buffers_for_catalog_role_assignments(const std::map< std::string, std::vector< std::string >> &user_names_by_role_, std::map< std::string, import_export::TypedImportBuffer * > &import_buffers)
static const AccessPrivileges ALL_SERVER
static const AccessPrivileges CREATE_SERVER
std::map< int32_t, std::vector< TableDescriptor > > get_all_tables()
static const AccessPrivileges DELETE_FROM_TABLE
static constexpr const char * ROLE_ASSIGNMENTS_SYS_TABLE_NAME
static const AccessPrivileges CREATE_TABLE
static constexpr const char * USERS_SYS_TABLE_NAME
std::optional< std::string > get_optional_string_value_from_object(const rapidjson::Value &object, const std::string &key)
static constexpr const char * DATABASES_SYS_TABLE_NAME
std::list< Catalog_Namespace::DBMetadata > databases_
std::shared_ptr< Catalog > getCatalog(const std::string &dbName)
static constexpr const char * TABLES_SYS_TABLE_NAME
const ForeignTable * foreign_table_
void populate_import_buffers_for_catalog_databases(const std::list< Catalog_Namespace::DBMetadata > &databases, std::map< std::string, import_export::TypedImportBuffer * > &import_buffers)
bool isTemporaryTable() const
static const AccessPrivileges SELECT_FROM_VIEW
static constexpr const char * PERMISSIONS_SYS_TABLE_NAME
std::map< std::string, std::vector< std::string > > get_all_role_assignments()
static const AccessPrivileges ALL_DASHBOARD
static const AccessPrivileges ACCESS
static const AccessPrivileges ALL_TABLE
void populate_import_buffers_for_catalog_users(const std::list< Catalog_Namespace::UserMetadata > &all_users, std::map< std::string, import_export::TypedImportBuffer * > &import_buffers)
std::string get_table_type(const TableDescriptor &td)
static const AccessPrivileges DROP_VIEW
static const AccessPrivileges CREATE_VIEW
std::string get_db_name(int32_t db_id)
std::string get_user_name(int32_t user_id)
const ColumnDescriptor * getColumnDesc() const
std::map< std::string, std::vector< std::string > > user_names_by_role_
static const AccessPrivileges DELETE_DASHBOARD
std::map< int32_t, std::vector< TableDescriptor > > tables_by_database_
void populate_import_buffers_for_catalog_roles(const std::set< std::string > &roles, std::map< std::string, import_export::TypedImportBuffer * > &import_buffers)
static const AccessPrivileges EDIT_DASHBOARD
static const AccessPrivileges UPDATE_IN_TABLE
bool hasPermission(int permission) const
std::map< int32_t, std::vector< DashboardDescriptor > > dashboards_by_database_
void add_value(const ColumnDescriptor *cd, const std::string_view val, const bool is_null, const CopyParams ©_params, const bool check_not_null=true)
void initializeObjectsForTable(const std::string &table_name) override
std::string get_object_type_str(int32_t object_type)