21 #include <boost/algorithm/string/predicate.hpp>
23 #include "rapidjson/document.h"
42 template <
class LockType>
44 std::unique_ptr<lockmgr::TableSchemaLockContainer<LockType>>>
46 const std::string& table_name,
47 const bool populate_fragmenter) {
48 const TableDescriptor* td{
nullptr};
49 std::unique_ptr<lockmgr::TableSchemaLockContainer<LockType>> td_with_lock =
50 std::make_unique<lockmgr::TableSchemaLockContainer<LockType>>(
52 cat, table_name, populate_fragmenter));
54 td = (*td_with_lock)();
56 return std::make_tuple(td, std::move(td_with_lock));
66 : File_Namespace::StorageStats(storage_stats)
67 , min_epoch(storage_stats.epoch)
68 , max_epoch(storage_stats.epoch)
69 , min_epoch_floor(storage_stats.epoch_floor)
70 , max_epoch_floor(storage_stats.epoch_floor) {}
77 if (total_free_metadata_page_count) {
78 total_free_metadata_page_count.value() +=
88 if (total_free_data_page_count) {
89 total_free_data_page_count.value() +=
95 min_epoch = std::min(min_epoch, storage_stats.
epoch);
96 max_epoch = std::max(max_epoch, storage_stats.
epoch);
97 min_epoch_floor = std::min(min_epoch_floor, storage_stats.
epoch_floor);
98 max_epoch_floor = std::max(max_epoch_floor, storage_stats.
epoch_floor);
105 std::optional<AggregratedStorageStats> agg_storage_stats;
110 for (
const auto physical_table : physical_tables) {
111 auto storage_stats = global_file_mgr->getStorageStats(catalog->
getDatabaseId(),
112 physical_table->tableId);
113 if (agg_storage_stats) {
114 agg_storage_stats.value().aggregate(storage_stats);
116 agg_storage_stats = storage_stats;
123 CHECK(agg_storage_stats.has_value());
124 return agg_storage_stats.value();
128 return std::unique_ptr<RexLiteral>(
133 return std::unique_ptr<RexLiteral>(
new RexLiteral(
138 return std::unique_ptr<RexLiteral>(
143 return std::unique_ptr<RexLiteral>(
150 std::vector<TargetMetaInfo>& label_infos,
151 const std::vector<std::tuple<std::string, SQLTypes, bool>>& headers) {
152 for (
const auto& header : headers) {
153 auto [_val, _type, _notnull] = header;
155 label_infos.emplace_back(_val,
SQLTypeInfo(_type, _notnull));
157 UNREACHABLE() <<
"Unsupported type provided for header. SQL type: "
164 const TableDescriptor* logical_table,
166 bool is_sharded_table = (logical_table->
nShards > 0);
180 logical_values.back().emplace_back(
182 logical_values.back().emplace_back(
184 logical_values.back().emplace_back(
188 logical_values.back().emplace_back(
195 logical_values.back().emplace_back(
197 logical_values.back().emplace_back(
201 logical_values.back().emplace_back(
217 : ddl_utils::SqlType(getSqlType(data_type),
218 getParam1(data_type),
219 getParam2(data_type),
221 getArraySize(data_type)) {}
224 static SQLTypes getSqlType(
const rapidjson::Value& data_type);
226 static int getParam1(
const rapidjson::Value& data_type);
227 static int getParam2(
const rapidjson::Value& data_type);
228 static bool isArray(
const rapidjson::Value& data_type);
229 static int getArraySize(
const rapidjson::Value& data_type);
235 : ddl_utils::Encoding(getEncodingName(data_type), getEncodingParam(data_type)) {}
238 static std::string* getEncodingName(
const rapidjson::Value& data_type);
239 static int getEncodingParam(
const rapidjson::Value& data_type);
255 const rapidjson::Value& query()
const;
258 const rapidjson::Value& payload()
const;
261 std::string commandStr()
override;
266 DdlCommandDataImpl::DdlCommandDataImpl(
const std::string& ddl_statement)
287 if (
payload.HasMember(
"command") &&
payload[
"command"].IsString()) {
288 return payload[
"command"].GetString();
301 const rapidjson::Value* filters =
nullptr;
302 if (payload.HasMember(
"filters") && payload[
"filters"].IsArray()) {
303 filters = &payload[
"filters"];
311 const std::string& ddl_statement,
312 std::shared_ptr<Catalog_Namespace::SessionInfo const> session_ptr)
313 : session_ptr_(session_ptr) {
314 CHECK(!ddl_statement.empty());
320 DdlCommandDataImpl* ddl_query_data =
new DdlCommandDataImpl(ddl_statement);
321 ddl_data_ = std::unique_ptr<DdlCommandData>(ddl_query_data);
323 VLOG(2) <<
"Parsing JSON DDL from Calcite: " << ddl_statement;
324 auto& ddl_query = ddl_query_data->query();
325 CHECK(ddl_query.IsObject()) << ddl_statement;
326 CHECK(ddl_query.HasMember(
"payload"));
327 CHECK(ddl_query[
"payload"].IsObject());
328 const auto& payload = ddl_query[
"payload"].GetObject();
329 CHECK(payload.HasMember(
"command"));
330 CHECK(payload[
"command"].IsString());
340 create_table_stmt.execute(*
session_ptr_, read_only_mode);
344 create_view_stmt.execute(*
session_ptr_, read_only_mode);
356 rename_table_stmt.execute(*
session_ptr_, read_only_mode);
360 if (stmt !=
nullptr) {
366 truncate_table_stmt.execute(*
session_ptr_, read_only_mode);
374 restore_table_stmt.execute(*
session_ptr_, read_only_mode);
378 optimize_table_stmt.execute(*
session_ptr_, read_only_mode);
386 export_query_stmt.execute(*
session_ptr_, read_only_mode);
402 create_user_stmt.execute(*
session_ptr_, read_only_mode);
414 rename_user_stmt.execute(*
session_ptr_, read_only_mode);
418 create_role_stmt.execute(*
session_ptr_, read_only_mode);
430 revoke_role_stmt.execute(*
session_ptr_, read_only_mode);
434 grant_privilege_stmt.execute(*
session_ptr_, read_only_mode);
437 auto revoke_privileges_stmt =
439 revoke_privileges_stmt.execute(*
session_ptr_, read_only_mode);
443 create_dataframe_stmt.execute(*
session_ptr_, read_only_mode);
452 auto execute_write_lock =
485 }
else if (
ddl_command_ ==
"SHOW_RUNTIME_TABLE_FUNCTIONS") {
504 throw std::runtime_error(
"Unsupported DDL command");
531 enum SetParameterType { String_t, Numeric_t };
532 static const std::unordered_map<std::string, SetParameterType>
533 session_set_parameters_map = {{
"EXECUTOR_DEVICE", SetParameterType::String_t},
534 {
"CURRENT_DATABASE", SetParameterType::String_t}};
537 CHECK(ddl_payload.HasMember(
"sessionParameter"));
538 CHECK(ddl_payload[
"sessionParameter"].IsString());
539 CHECK(ddl_payload.HasMember(
"parameterValue"));
540 CHECK(ddl_payload[
"parameterValue"].IsString());
541 std::string parameter_name =
to_upper(ddl_payload[
"sessionParameter"].GetString());
542 std::string parameter_value = ddl_payload[
"parameterValue"].GetString();
544 const auto param_it = session_set_parameters_map.find(parameter_name);
545 if (param_it == session_set_parameters_map.end()) {
546 throw std::runtime_error(parameter_name +
" is not a settable session parameter.");
548 if (param_it->second == SetParameterType::Numeric_t) {
549 if (!std::regex_match(parameter_value, std::regex(
"[(-|+)|][0-9]+"))) {
550 throw std::runtime_error(
"The value of session parameter " + param_it->first +
551 " should be a numeric.");
554 return {parameter_name, parameter_value};
560 CHECK(ddl_payload.HasMember(
"cacheType"));
561 CHECK(ddl_payload[
"cacheType"].IsString());
562 return ddl_payload[
"cacheType"].GetString();
590 CHECK(ddl_payload.HasMember(
"type"));
591 const std::string& targetType = ddl_payload[
"type"].GetString();
592 if (targetType ==
"DASHBOARD") {
610 return execution_details;
618 CHECK(ddl_payload.HasMember(
"querySession"));
619 const std::string& query_session = ddl_payload[
"querySession"].GetString();
621 boost::regex session_id_regex{R
"([0-9]{3}-[a-zA-Z0-9]{4})",
622 boost::regex::extended | boost::regex::icase};
623 if (!boost::regex_match(query_session, session_id_regex)) {
624 throw std::runtime_error(
625 "Please provide the correct session ID of the query that you want to interrupt.");
627 return query_session;
640 [&server_name](
const std::string& reserved_prefix) {
641 return boost::istarts_with(server_name, reserved_prefix);
646 std::string error_message{
"Foreign server names cannot start with "};
649 error_message +=
", ";
652 error_message +=
"or ";
656 error_message +=
".";
657 throw std::runtime_error{error_message};
663 std::shared_ptr<Catalog_Namespace::SessionInfo const> session_ptr)
666 throw std::runtime_error(
"Unsupported command: CREATE FOREIGN SERVER");
669 CHECK(ddl_payload.HasMember(
"serverName"));
670 CHECK(ddl_payload[
"serverName"].IsString());
671 CHECK(ddl_payload.HasMember(
"dataWrapper"));
672 CHECK(ddl_payload[
"dataWrapper"].IsString());
673 if (ddl_payload.HasMember(
"options")) {
674 CHECK(ddl_payload[
"options"].IsObject());
676 CHECK(ddl_payload.HasMember(
"ifNotExists"));
677 CHECK(ddl_payload[
"ifNotExists"].IsBool());
683 if (read_only_mode) {
684 throw std::runtime_error(
"CREATE FOREIGN SERVER invalid in read only mode.");
687 std::string server_name = ddl_payload[
"serverName"].GetString();
691 bool if_not_exists = ddl_payload[
"ifNotExists"].GetBool();
692 if (
session_ptr_->getCatalog().getForeignServer(server_name)) {
696 throw std::runtime_error{
"A foreign server with name \"" + server_name +
697 "\" already exists."};
703 throw std::runtime_error(
"Server " + std::string(server_name) +
704 " will not be created. User has no create privileges.");
708 auto foreign_server = std::make_unique<foreign_storage::ForeignServer>();
709 foreign_server->data_wrapper_type =
to_upper(ddl_payload[
"dataWrapper"].GetString());
710 foreign_server->name = server_name;
711 foreign_server->user_id = current_user.userId;
712 if (ddl_payload.HasMember(
"options")) {
713 foreign_server->populateOptionsMap(ddl_payload[
"options"]);
715 foreign_server->validate();
718 catalog.createForeignServer(std::move(foreign_server),
719 ddl_payload[
"ifNotExists"].GetBool());
728 std::shared_ptr<const Catalog_Namespace::SessionInfo> session_ptr)
731 throw std::runtime_error(
"Unsupported command: ALTER FOREIGN SERVER");
734 CHECK(ddl_payload.HasMember(
"serverName"));
735 CHECK(ddl_payload[
"serverName"].IsString());
736 CHECK(ddl_payload.HasMember(
"alterType"));
737 CHECK(ddl_payload[
"alterType"].IsString());
738 if (ddl_payload[
"alterType"] ==
"SET_OPTIONS") {
739 CHECK(ddl_payload.HasMember(
"options"));
740 CHECK(ddl_payload[
"options"].IsObject());
741 }
else if (ddl_payload[
"alterType"] ==
"SET_DATA_WRAPPER") {
742 CHECK(ddl_payload.HasMember(
"dataWrapper"));
743 CHECK(ddl_payload[
"dataWrapper"].IsString());
744 }
else if (ddl_payload[
"alterType"] ==
"RENAME_SERVER") {
745 CHECK(ddl_payload.HasMember(
"newServerName"));
746 CHECK(ddl_payload[
"newServerName"].IsString());
747 }
else if (ddl_payload[
"alterType"] ==
"CHANGE_OWNER") {
748 CHECK(ddl_payload.HasMember(
"newOwner"));
749 CHECK(ddl_payload[
"newOwner"].IsString());
756 if (read_only_mode) {
757 throw std::runtime_error(
"ALTER FOREIGN SERVER invalid in read only mode.");
760 std::string server_name = ddl_payload[
"serverName"].GetString();
762 throw std::runtime_error{
"Default servers cannot be altered."};
764 if (!
session_ptr_->getCatalog().getForeignServer(server_name)) {
765 throw std::runtime_error{
"Foreign server with name \"" + server_name +
766 "\" does not exist and can not be altered."};
769 throw std::runtime_error(
"Server " + server_name +
770 " can not be altered. User has no ALTER SERVER privileges.");
772 std::string alter_type = ddl_payload[
"alterType"].GetString();
773 if (alter_type ==
"CHANGE_OWNER") {
775 }
else if (alter_type ==
"SET_DATA_WRAPPER") {
777 }
else if (alter_type ==
"SET_OPTIONS") {
779 }
else if (alter_type ==
"RENAME_SERVER") {
788 std::string server_name = ddl_payload[
"serverName"].GetString();
789 std::string new_owner = ddl_payload[
"newOwner"].GetString();
792 throw std::runtime_error(
793 "Only a super user can change a foreign server's owner. "
794 "Current user is not a super-user. "
795 "Foreign server with name \"" +
796 server_name +
"\" will not have owner changed.");
799 if (!sys_cat.getMetadataForUser(new_owner, user)) {
800 throw std::runtime_error(
"User with username \"" + new_owner +
"\" does not exist. " +
801 "Foreign server with name \"" + server_name +
802 "\" can not have owner changed.");
806 bool original_owner_exists = sys_cat.getMetadataForUserById(
807 cat.getForeignServer(server_name)->user_id, original_owner);
809 cat.changeForeignServerOwner(server_name, user.
userId);
813 sys_cat.changeDBObjectOwnership(
814 user, original_owner, db_object,
cat, original_owner_exists);
815 }
catch (
const std::runtime_error& e) {
817 cat.changeForeignServerOwner(server_name, original_owner.
userId);
824 std::string server_name = ddl_payload[
"serverName"].GetString();
825 std::string new_server_name = ddl_payload[
"newServerName"].GetString();
831 if (
cat.getForeignServer(new_server_name)) {
832 throw std::runtime_error(
"Foreign server with name \"" + server_name +
833 "\" can not be renamed to \"" + new_server_name +
"\"." +
834 "Foreign server with name \"" + new_server_name +
838 cat.renameForeignServer(server_name, new_server_name);
842 sys_cat.renameDBObject(server_name,
845 cat.getForeignServer(new_server_name)->id,
847 }
catch (
const std::runtime_error& e) {
849 cat.renameForeignServer(new_server_name, server_name);
856 std::string server_name = ddl_payload[
"serverName"].GetString();
859 const auto foreign_server =
cat.getForeignServer(server_name);
868 std::string server_name = ddl_payload[
"serverName"].GetString();
869 std::string data_wrapper = ddl_payload[
"dataWrapper"].GetString();
872 cat.setForeignServerDataWrapper(server_name, data_wrapper);
878 std::string server_name = ddl_payload[
"serverName"].GetString();
885 std::shared_ptr<Catalog_Namespace::SessionInfo const> session_ptr)
888 throw std::runtime_error(
"Unsupported command: DROP FOREIGN SERVER");
891 CHECK(ddl_payload.HasMember(
"serverName"));
892 CHECK(ddl_payload[
"serverName"].IsString());
893 CHECK(ddl_payload.HasMember(
"ifExists"));
894 CHECK(ddl_payload[
"ifExists"].IsBool());
898 if (read_only_mode) {
899 throw std::runtime_error(
"DROP FOREIGN SERVER invalid in read only mode.");
902 std::string server_name = ddl_payload[
"serverName"].GetString();
904 throw std::runtime_error{
"Default servers cannot be dropped."};
906 bool if_exists = ddl_payload[
"ifExists"].GetBool();
907 if (!
session_ptr_->getCatalog().getForeignServer(server_name)) {
911 throw std::runtime_error{
"Foreign server with name \"" + server_name +
912 "\" can not be dropped. Server does not exist."};
918 throw std::runtime_error(
"Server " + server_name +
919 " will not be dropped. User has no DROP SERVER privileges.");
923 session_ptr_->getCatalog().dropForeignServer(ddl_payload[
"serverName"].GetString());
928 SQLTypes JsonColumnSqlType::getSqlType(
const rapidjson::Value& data_type) {
929 CHECK(data_type.IsObject());
930 CHECK(data_type.HasMember(
"type"));
931 CHECK(data_type[
"type"].IsString());
933 std::string
type = data_type[
"type"].GetString();
934 if (boost::iequals(type,
"ARRAY")) {
935 CHECK(data_type.HasMember(
"array"));
936 CHECK(data_type[
"array"].IsObject());
938 const auto& array = data_type[
"array"].GetObject();
939 CHECK(array.HasMember(
"elementType"));
940 CHECK(array[
"elementType"].IsString());
941 type = array[
"elementType"].GetString();
943 return getSqlType(type);
947 if (boost::iequals(type,
"BIGINT")) {
950 if (boost::iequals(type,
"BOOLEAN")) {
953 if (boost::iequals(type,
"DATE")) {
956 if (boost::iequals(type,
"DECIMAL")) {
959 if (boost::iequals(type,
"DOUBLE")) {
962 if (boost::iequals(type,
"FLOAT")) {
965 if (boost::iequals(type,
"INTEGER")) {
968 if (boost::iequals(type,
"LINESTRING")) {
971 if (boost::iequals(type,
"MULTIPOLYGON")) {
974 if (boost::iequals(type,
"POINT")) {
977 if (boost::iequals(type,
"POLYGON")) {
980 if (boost::iequals(type,
"SMALLINT")) {
983 if (boost::iequals(type,
"TEXT")) {
986 if (boost::iequals(type,
"TIME")) {
989 if (boost::iequals(type,
"TIMESTAMP")) {
992 if (boost::iequals(type,
"TINYINT")) {
996 throw std::runtime_error{
"Unsupported type \"" + type +
"\" specified."};
999 int JsonColumnSqlType::getParam1(
const rapidjson::Value& data_type) {
1001 CHECK(data_type.IsObject());
1002 if (data_type.HasMember(
"precision") && !data_type[
"precision"].IsNull()) {
1003 CHECK(data_type[
"precision"].IsInt());
1004 param1 = data_type[
"precision"].GetInt();
1011 int JsonColumnSqlType::getParam2(
const rapidjson::Value& data_type) {
1013 CHECK(data_type.IsObject());
1014 if (data_type.HasMember(
"scale") && !data_type[
"scale"].IsNull()) {
1015 CHECK(data_type[
"scale"].IsInt());
1016 param2 = data_type[
"scale"].GetInt();
1018 data_type.HasMember(
"coordinateSystem") &&
1019 !data_type[
"coordinateSystem"].IsNull()) {
1020 CHECK(data_type[
"coordinateSystem"].IsInt());
1021 param2 = data_type[
"coordinateSystem"].GetInt();
1026 bool JsonColumnSqlType::isArray(
const rapidjson::Value& data_type) {
1027 CHECK(data_type.IsObject());
1028 CHECK(data_type.HasMember(
"type"));
1029 CHECK(data_type[
"type"].IsString());
1030 return boost::iequals(data_type[
"type"].GetString(),
"ARRAY");
1033 int JsonColumnSqlType::getArraySize(
const rapidjson::Value& data_type) {
1035 if (isArray(data_type)) {
1036 CHECK(data_type.HasMember(
"array"));
1037 CHECK(data_type[
"array"].IsObject());
1039 const auto& array = data_type[
"array"].GetObject();
1040 if (array.HasMember(
"size") && !array[
"size"].IsNull()) {
1041 CHECK(array[
"size"].IsInt());
1042 size = array[
"size"].GetInt();
1048 std::string* JsonColumnEncoding::getEncodingName(
const rapidjson::Value& data_type) {
1049 CHECK(data_type.IsObject());
1050 CHECK(data_type.HasMember(
"encoding"));
1051 CHECK(data_type[
"encoding"].IsObject());
1053 const auto& encoding = data_type[
"encoding"].GetObject();
1054 CHECK(encoding.HasMember(
"type"));
1055 CHECK(encoding[
"type"].IsString());
1056 return new std::string(encoding[
"type"].GetString());
1059 int JsonColumnEncoding::getEncodingParam(
const rapidjson::Value& data_type) {
1060 CHECK(data_type.IsObject());
1061 CHECK(data_type.HasMember(
"encoding"));
1062 CHECK(data_type[
"encoding"].IsObject());
1064 int encoding_size = 0;
1065 const auto& encoding = data_type[
"encoding"].GetObject();
1066 if (encoding.HasMember(
"size") && !encoding[
"size"].IsNull()) {
1067 CHECK(encoding[
"size"].IsInt());
1068 encoding_size = encoding[
"size"].GetInt();
1070 return encoding_size;
1075 std::shared_ptr<Catalog_Namespace::SessionInfo const> session_ptr)
1078 throw std::runtime_error(
"Unsupported command: CREATE FOREIGN TABLE");
1081 CHECK(ddl_payload.HasMember(
"serverName"));
1082 CHECK(ddl_payload[
"serverName"].IsString());
1083 CHECK(ddl_payload.HasMember(
"tableName"));
1084 CHECK(ddl_payload[
"tableName"].IsString());
1085 CHECK(ddl_payload.HasMember(
"ifNotExists"));
1086 CHECK(ddl_payload[
"ifNotExists"].IsBool());
1087 CHECK(ddl_payload.HasMember(
"columns"));
1088 CHECK(ddl_payload[
"columns"].IsArray());
1095 if (read_only_mode) {
1096 throw std::runtime_error(
"CREATE FOREIGN TABLE invalid in read only mode.");
1098 const std::string& table_name = ddl_payload[
"tableName"].GetString();
1101 throw std::runtime_error(
1102 "Foreign table \"" + table_name +
1103 "\" will not be created. User has no CREATE TABLE privileges.");
1106 bool if_not_exists = ddl_payload[
"ifNotExists"].GetBool();
1107 if (!catalog.validateNonExistentTableOrView(table_name, if_not_exists)) {
1112 std::list<ColumnDescriptor> columns{};
1115 catalog.createTable(foreign_table, columns, {},
true);
1121 foreign_table.tableName,
1129 const std::string& table_name,
1131 const std::list<ColumnDescriptor>& columns) {
1142 const std::string server_name = ddl_payload[
"serverName"].GetString();
1144 if (!foreign_table.foreign_server) {
1145 throw std::runtime_error{
1146 "Foreign Table with name \"" + table_name +
1147 "\" can not be created. Associated foreign server with name \"" + server_name +
1148 "\" does not exist."};
1156 throw std::runtime_error(
1157 "Current user does not have USAGE privilege on foreign server: " + server_name);
1160 if (ddl_payload.HasMember(
"options") && !ddl_payload[
"options"].IsNull()) {
1161 CHECK(ddl_payload[
"options"].IsObject());
1162 foreign_table.initializeOptions(ddl_payload[
"options"]);
1167 foreign_table.initializeOptions();
1169 foreign_table.validateSchema(columns);
1171 if (
const auto it = foreign_table.options.find(
"FRAGMENT_SIZE");
1172 it != foreign_table.options.end()) {
1173 foreign_table.maxFragRows = std::stoi(it->second);
1176 if (
const auto it = foreign_table.options.find(
"MAX_CHUNK_SIZE");
1177 it != foreign_table.options.end()) {
1178 foreign_table.maxChunkSize = std::stol(it->second);
1181 if (
const auto it = foreign_table.options.find(
"PARTITIONS");
1182 it != foreign_table.options.end()) {
1183 foreign_table.partitions = it->second;
1189 std::unordered_set<std::string> column_names{};
1190 for (
auto& column_def : ddl_payload[
"columns"].GetArray()) {
1191 CHECK(column_def.IsObject());
1192 CHECK(column_def.HasMember(
"name"));
1193 CHECK(column_def[
"name"].IsString());
1194 const std::string& column_name = column_def[
"name"].GetString();
1196 CHECK(column_def.HasMember(
"dataType"));
1197 CHECK(column_def[
"dataType"].IsObject());
1199 JsonColumnSqlType sql_type{column_def[
"dataType"]};
1200 const auto& data_type = column_def[
"dataType"].GetObject();
1201 CHECK(data_type.HasMember(
"notNull"));
1202 CHECK(data_type[
"notNull"].IsBool());
1204 std::unique_ptr<JsonColumnEncoding> encoding;
1205 if (data_type.HasMember(
"encoding") && !data_type[
"encoding"].IsNull()) {
1206 CHECK(data_type[
"encoding"].IsObject());
1207 encoding = std::make_unique<JsonColumnEncoding>(column_def[
"dataType"]);
1216 data_type[
"notNull"].GetBool(),
1219 columns.emplace_back(cd);
1225 std::shared_ptr<Catalog_Namespace::SessionInfo const> session_ptr)
1228 throw std::runtime_error(
"Unsupported command: DROP FOREIGN TABLE");
1231 CHECK(ddl_payload.HasMember(
"tableName"));
1232 CHECK(ddl_payload[
"tableName"].IsString());
1233 CHECK(ddl_payload.HasMember(
"ifExists"));
1234 CHECK(ddl_payload[
"ifExists"].IsBool());
1241 if (read_only_mode) {
1242 throw std::runtime_error(
"DROP FOREIGN TABLE invalid in read only mode.");
1244 const std::string& table_name = ddl_payload[
"tableName"].GetString();
1246 std::unique_ptr<lockmgr::TableSchemaLockContainer<lockmgr::WriteLock>> td_with_lock;
1250 std::make_unique<lockmgr::TableSchemaLockContainer<lockmgr::WriteLock>>(
1252 catalog, table_name,
false));
1253 CHECK(td_with_lock);
1254 td = (*td_with_lock)();
1255 }
catch (
const std::runtime_error& e) {
1258 if (ddl_payload[
"ifExists"].GetBool()) {
1269 throw std::runtime_error(
1270 "Foreign table \"" + table_name +
1271 "\" will not be dropped. User has no DROP TABLE privileges.");
1275 auto table_data_write_lock =
1277 catalog.dropTable(td);
1287 std::shared_ptr<Catalog_Namespace::SessionInfo const> session_ptr)
1296 std::vector<std::string> labels{
"table_name"};
1297 std::vector<TargetMetaInfo> label_infos;
1298 for (
const auto&
label : labels) {
1308 std::vector<RelLogicalValues::RowValues> logical_values;
1309 for (
auto table_name : table_names) {
1311 logical_values.back().emplace_back(
genLiteralStr(table_name));
1315 std::shared_ptr<ResultSet> rSet = std::shared_ptr<ResultSet>(
1323 std::shared_ptr<Catalog_Namespace::SessionInfo const> session_ptr)
1326 if (ddl_payload.HasMember(
"tableNames")) {
1327 CHECK(ddl_payload[
"tableNames"].IsArray());
1328 for (
const auto& table_name : ddl_payload[
"tableNames"].GetArray()) {
1329 CHECK(table_name.IsString());
1340 std::vector<TargetMetaInfo> label_infos;
1344 {
"table_name",
kTEXT,
true},
1345 {
"column_count",
kBIGINT,
true},
1346 {
"is_sharded_table",
kBOOLEAN,
true},
1347 {
"shard_count",
kBIGINT,
true},
1349 {
"fragment_size",
kBIGINT,
true},
1350 {
"max_rollback_epochs",
kBIGINT,
true},
1353 {
"min_epoch_floor",
kBIGINT,
true},
1354 {
"max_epoch_floor",
kBIGINT,
true},
1355 {
"metadata_file_count",
kBIGINT,
true},
1356 {
"total_metadata_file_size",
kBIGINT,
true},
1357 {
"total_metadata_page_count",
kBIGINT,
true},
1358 {
"total_free_metadata_page_count",
kBIGINT,
false},
1359 {
"data_file_count",
kBIGINT,
true},
1360 {
"total_data_file_size",
kBIGINT,
true},
1361 {
"total_data_page_count",
kBIGINT,
true},
1362 {
"total_free_data_page_count",
kBIGINT,
false}});
1364 std::vector<RelLogicalValues::RowValues> logical_values;
1365 for (
const auto& table_name : filtered_table_names) {
1366 auto [td, td_with_lock] =
1367 get_table_descriptor_with_lock<lockmgr::ReadLock>(*catalog, table_name,
false);
1373 std::shared_ptr<ResultSet> rSet = std::shared_ptr<ResultSet>(
1382 auto all_table_names =
1385 all_table_names.end(),
1386 all_table_names.begin(),
1387 [](
const std::string& s) {
return to_upper(s); });
1388 std::vector<std::string> filtered_table_names;
1389 if (ddl_payload.HasMember(
"tableNames")) {
1390 std::set<std::string> all_table_names_set(all_table_names.begin(),
1391 all_table_names.end());
1392 for (
const auto& table_name_json : ddl_payload[
"tableNames"].GetArray()) {
1393 std::string table_name = table_name_json.GetString();
1394 if (all_table_names_set.find(
to_upper(table_name)) == all_table_names_set.end()) {
1395 throw std::runtime_error{
"Unable to show table details for table: " + table_name +
1396 ". Table does not exist."};
1398 auto [td, td_with_lock] =
1399 get_table_descriptor_with_lock<lockmgr::ReadLock>(*catalog, table_name,
false);
1400 if (td->isForeignTable()) {
1401 throw std::runtime_error{
1402 "SHOW TABLE DETAILS is not supported for foreign tables. Table name: " +
1405 if (td->isTemporaryTable()) {
1406 throw std::runtime_error{
1407 "SHOW TABLE DETAILS is not supported for temporary tables. Table name: " +
1410 filtered_table_names.emplace_back(table_name);
1413 for (
const auto& table_name : all_table_names) {
1414 auto [td, td_with_lock] =
1415 get_table_descriptor_with_lock<lockmgr::ReadLock>(*catalog, table_name,
false);
1416 if (td->isForeignTable() || td->isTemporaryTable()) {
1419 filtered_table_names.emplace_back(table_name);
1422 return filtered_table_names;
1427 std::shared_ptr<Catalog_Namespace::SessionInfo const> session_ptr)
1434 CHECK(ddl_payload.HasMember(
"tableName"));
1435 CHECK(ddl_payload[
"tableName"].IsString());
1436 const std::string& table_name = ddl_payload[
"tableName"].GetString();
1439 auto table_read_lock =
1442 const TableDescriptor* td = catalog.getMetadataForTable(table_name,
false);
1444 throw std::runtime_error(
"Table/View " + table_name +
" does not exist.");
1449 std::vector<DBObject> privObjects = {dbObject};
1453 throw std::runtime_error(
"Table/View " + table_name +
" does not exist.");
1457 auto query_state_proxy = query_state->createQueryStateProxy();
1458 auto calcite_mgr = catalog.getCalciteMgr();
1459 const auto calciteQueryParsingOption =
1460 calcite_mgr->getCalciteQueryParsingOption(
true,
false,
false);
1461 const auto calciteOptimizationOption =
1463 auto result = calcite_mgr->process(query_state_proxy,
1465 calciteQueryParsingOption,
1466 calciteOptimizationOption);
1468 calcite_mgr->checkAccessedObjectsPrivileges(query_state_proxy,
result);
1469 }
catch (
const std::runtime_error&) {
1470 throw std::runtime_error(
"Not enough privileges to show the view SQL");
1482 std::shared_ptr<Catalog_Namespace::SessionInfo const> session_ptr)
1489 std::vector<std::string> labels{
"Database",
"Owner"};
1490 std::vector<TargetMetaInfo> label_infos;
1491 for (
const auto&
label : labels) {
1501 std::vector<RelLogicalValues::RowValues> logical_values;
1502 for (
const auto& db_summary : db_summaries) {
1504 logical_values.back().emplace_back(
genLiteralStr(db_summary.dbName));
1505 logical_values.back().emplace_back(
genLiteralStr(db_summary.dbOwnerName));
1509 std::shared_ptr<ResultSet> rSet = std::shared_ptr<ResultSet>(
1517 std::shared_ptr<Catalog_Namespace::SessionInfo const> session_ptr)
1523 std::vector<TargetMetaInfo> label_infos;
1524 std::vector<RelLogicalValues::RowValues> logical_values;
1526 if (ddl_payload.HasMember(
"ScalarFnNames")) {
1533 for (
const auto& udf_name_json : ddl_payload[
"ScalarFnNames"].GetArray()) {
1534 std::string udf_name = udf_name_json.GetString();
1535 std::vector<ExtensionFunction> ext_funcs =
1541 logical_values.back().emplace_back(
genLiteralStr(udf_name));
1543 logical_values.back().emplace_back(
genLiteralStr(fn.toSignature()));
1555 for (
const auto&
label : {
"Scalar UDF"}) {
1567 std::shared_ptr<ResultSet> rSet = std::shared_ptr<ResultSet>(
1575 std::shared_ptr<Catalog_Namespace::SessionInfo const> session_ptr)
1580 std::vector<TargetMetaInfo> label_infos;
1581 std::vector<RelLogicalValues::RowValues> logical_values;
1584 for (
const auto&
label : {
"Runtime Scalar UDF"}) {
1595 std::shared_ptr<ResultSet> rSet = std::shared_ptr<ResultSet>(
1603 std::shared_ptr<Catalog_Namespace::SessionInfo const> session_ptr)
1611 std::vector<TargetMetaInfo> label_infos;
1612 std::vector<RelLogicalValues::RowValues> logical_values;
1614 if (ddl_payload.HasMember(
"tfNames")) {
1627 for (
const auto& tf_name_json : ddl_payload[
"tfNames"].GetArray()) {
1628 std::string tf_name = tf_name_json.GetString();
1633 logical_values.back().emplace_back(
genLiteralStr(tf.getName(
true,
false)));
1636 tf.getSignature(
false,
true)));
1638 logical_values.back().emplace_back(
1641 logical_values.back().emplace_back(
1644 logical_values.back().emplace_back(
1647 logical_values.back().emplace_back(
1657 !tf.getFunctionAnnotation(
"filter_table_function_transpose",
"").empty()));
1662 for (
const auto&
label : {
"Tabel UDF"}) {
1667 std::unordered_set<std::string> unique_names;
1670 std::string
name = tf.getName(
true,
true);
1671 if (unique_names.find(name) == unique_names.end()) {
1672 unique_names.emplace(name);
1680 std::shared_ptr<ResultSet> rSet = std::shared_ptr<ResultSet>(
1688 std::shared_ptr<Catalog_Namespace::SessionInfo const> session_ptr)
1695 std::vector<TargetMetaInfo> label_infos;
1696 std::vector<RelLogicalValues::RowValues> logical_values;
1699 for (
const auto&
label : {
"Runtime Table UDF"}) {
1704 std::unordered_set<std::string> unique_names;
1707 std::string
name = tf.getName(
true,
true);
1708 if (unique_names.find(name) == unique_names.end()) {
1709 unique_names.emplace(name);
1716 std::shared_ptr<ResultSet> rSet = std::shared_ptr<ResultSet>(
1724 std::shared_ptr<Catalog_Namespace::SessionInfo const> session_ptr)
1727 throw std::runtime_error(
"Unsupported command: SHOW FOREIGN SERVERS");
1731 CHECK(ddl_payload.HasMember(
"command"));
1732 if (ddl_payload.HasMember(
"filters")) {
1733 CHECK(ddl_payload[
"filters"].IsArray());
1734 int num_filters = 0;
1735 for (
auto const& filter_def : ddl_payload[
"filters"].GetArray()) {
1736 CHECK(filter_def.IsObject());
1737 CHECK(filter_def.HasMember(
"attribute"));
1738 CHECK(filter_def[
"attribute"].IsString());
1739 CHECK(filter_def.HasMember(
"value"));
1740 CHECK(filter_def[
"value"].IsString());
1741 CHECK(filter_def.HasMember(
"operation"));
1742 CHECK(filter_def[
"operation"].IsString());
1743 if (num_filters > 0) {
1744 CHECK(filter_def.HasMember(
"chain"));
1745 CHECK(filter_def[
"chain"].IsString());
1747 CHECK(!filter_def.HasMember(
"chain"));
1757 std::vector<TargetMetaInfo> label_infos;
1761 std::vector<std::string> labels{
"server_name",
"data_wrapper",
"created_at",
"options"};
1770 std::vector<const foreign_storage::ForeignServer*> results;
1776 std::vector<RelLogicalValues::RowValues> logical_values;
1777 for (
auto const& server_ptr : results) {
1779 logical_values.back().emplace_back(
genLiteralStr(server_ptr->name));
1780 logical_values.back().emplace_back(
genLiteralStr(server_ptr->data_wrapper_type));
1782 logical_values.back().emplace_back(
1786 std::shared_ptr<ResultSet> rSet = std::shared_ptr<ResultSet>(
1794 std::shared_ptr<Catalog_Namespace::SessionInfo const> session_ptr)
1797 throw std::runtime_error(
"Unsupported command: SHOW CREATE SERVER");
1801 CHECK(payload.HasMember(
"serverName"));
1802 CHECK(payload[
"serverName"].IsString());
1803 server_ = (payload[
"serverName"].GetString());
1809 using namespace Catalog_Namespace;
1811 const auto server = catalog.getForeignServer(
server_);
1813 throw std::runtime_error(
"Foreign server " +
server_ +
" does not exist.");
1817 std::vector<DBObject> privObjects = {dbObject};
1818 if (!SysCatalog::instance().hasAnyPrivileges(
session_ptr_->get_currentUser(),
1820 throw std::runtime_error(
"Foreign server " +
server_ +
" does not exist.");
1822 auto create_stmt = catalog.dumpCreateServer(
server_);
1824 std::vector<std::string> labels{
"create_server_sql"};
1825 std::vector<TargetMetaInfo> label_infos;
1828 std::vector<RelLogicalValues::RowValues> logical_values;
1830 logical_values.back().emplace_back(
genLiteralStr(create_stmt));
1832 std::shared_ptr<ResultSet> rSet = std::shared_ptr<ResultSet>(
1840 std::shared_ptr<Catalog_Namespace::SessionInfo const> session_ptr)
1843 throw std::runtime_error(
"Unsupported command: REFRESH FOREIGN TABLE");
1846 CHECK(ddl_payload.HasMember(
"tableNames"));
1847 CHECK(ddl_payload[
"tableNames"].IsArray());
1848 for (
auto const& tablename_def : ddl_payload[
"tableNames"].GetArray()) {
1849 CHECK(tablename_def.IsString());
1854 if (read_only_mode) {
1855 throw std::runtime_error(
"REFRESH FOREIGN TABLE invalid in read only mode.");
1858 bool evict_cached_entries{
false};
1861 if (ddl_payload.HasMember(
"options") && !ddl_payload[
"options"].IsNull()) {
1863 for (
const auto& entry : opt.
options) {
1864 if (entry.first !=
"EVICT") {
1865 throw std::runtime_error{
1866 "Invalid option \"" + entry.first +
1867 "\" provided for refresh command. Only \"EVICT\" option is supported."};
1872 if (boost::iequals(opt.
options[
"EVICT"],
"true") ||
1873 boost::iequals(opt.
options[
"EVICT"],
"false")) {
1874 if (boost::iequals(opt.
options[
"EVICT"],
"true")) {
1875 evict_cached_entries =
true;
1878 throw std::runtime_error{
1879 "Invalid value \"" + opt.
options[
"EVICT"] +
1880 "\" provided for EVICT option. Value must be either \"true\" or \"false\"."};
1885 const auto& current_user =
session_ptr_->get_currentUser();
1887 if (!current_user.isSuper) {
1888 for (
const auto& table_name_json : ddl_payload[
"tableNames"].GetArray()) {
1889 std::string table_name = table_name_json.GetString();
1892 throw std::runtime_error(
1893 std::string(
"REFRESH FOREIGN TABLES failed on table \"") + table_name +
1894 "\". It can only be executed by super user or "
1901 for (
const auto& table_name_json : ddl_payload[
"tableNames"].GetArray()) {
1902 std::string table_name = table_name_json.GetString();
1903 static const std::array<std::string, 4> log_system_tables{
1909 throw std::runtime_error(
1910 "REFRESH FOREIGN TABLE can only be executed for the following tables: " +
1911 join(log_system_tables,
","));
1924 std::shared_ptr<const Catalog_Namespace::SessionInfo> session_ptr)
1927 throw std::runtime_error(
"Unsupported command: ALTER FOREIGN TABLE");
1930 CHECK(ddl_payload.HasMember(
"tableName"));
1931 CHECK(ddl_payload[
"tableName"].IsString());
1932 CHECK(ddl_payload.HasMember(
"alterType"));
1933 CHECK(ddl_payload[
"alterType"].IsString());
1934 if (ddl_payload[
"alterType"] ==
"RENAME_TABLE") {
1935 CHECK(ddl_payload.HasMember(
"newTableName"));
1936 CHECK(ddl_payload[
"newTableName"].IsString());
1937 }
else if (ddl_payload[
"alterType"] ==
"RENAME_COLUMN") {
1938 CHECK(ddl_payload.HasMember(
"oldColumnName"));
1939 CHECK(ddl_payload[
"oldColumnName"].IsString());
1940 CHECK(ddl_payload.HasMember(
"newColumnName"));
1941 CHECK(ddl_payload[
"newColumnName"].IsString());
1942 }
else if (ddl_payload[
"alterType"] ==
"ALTER_OPTIONS") {
1943 CHECK(ddl_payload.HasMember(
"options"));
1944 CHECK(ddl_payload[
"options"].IsObject());
1946 UNREACHABLE() <<
"Not a valid alter foreign table command: "
1947 << ddl_payload[
"alterType"].GetString();
1952 if (read_only_mode) {
1953 throw std::runtime_error(
"ALTER FOREIGN TABLE invalid in read only mode.");
1958 const std::string& table_name = ddl_payload[
"tableName"].GetString();
1959 auto [td, td_with_lock] =
1960 get_table_descriptor_with_lock<lockmgr::WriteLock>(catalog, table_name,
false);
1966 throw std::runtime_error(
1967 "Current user does not have the privilege to alter foreign table: " + table_name);
1970 auto table_data_write_lock =
1973 CHECK(foreign_table);
1975 std::string alter_type = ddl_payload[
"alterType"].GetString();
1976 if (alter_type ==
"RENAME_TABLE") {
1978 }
else if (alter_type ==
"RENAME_COLUMN") {
1980 }
else if (alter_type ==
"ALTER_OPTIONS") {
1991 const std::string& table_name = ddl_payload[
"tableName"].GetString();
1992 const std::string& new_table_name = ddl_payload[
"newTableName"].GetString();
1993 if (
cat.getForeignTable(new_table_name)) {
1994 throw std::runtime_error(
"Foreign table with name \"" + table_name +
1995 "\" can not be renamed to \"" + new_table_name +
"\". " +
1996 "A different table with name \"" + new_table_name +
1997 "\" already exists.");
1999 cat.renameTable(foreign_table, new_table_name);
2006 const std::string& old_column_name = ddl_payload[
"oldColumnName"].GetString();
2007 const std::string& new_column_name = ddl_payload[
"newColumnName"].GetString();
2008 auto column =
cat.getMetadataForColumn(foreign_table->
tableId, old_column_name);
2010 throw std::runtime_error(
"Column with name \"" + old_column_name +
2011 "\" can not be renamed to \"" + new_column_name +
"\". " +
2012 "Column with name \"" + old_column_name +
2013 "\" does not exist.");
2015 if (
cat.getMetadataForColumn(foreign_table->
tableId, new_column_name)) {
2016 throw std::runtime_error(
"Column with name \"" + old_column_name +
2017 "\" can not be renamed to \"" + new_column_name +
"\". " +
2018 "A column with name \"" + new_column_name +
2019 "\" already exists.");
2021 cat.renameColumn(foreign_table, column, new_column_name);
2027 const std::string& table_name = ddl_payload[
"tableName"].GetString();
2029 auto new_options_map =
2033 cat.setForeignTableOptions(table_name, new_options_map,
false);
2038 std::shared_ptr<Catalog_Namespace::SessionInfo const> session_ptr)
2041 if (ddl_payload.HasMember(
"tableNames")) {
2042 CHECK(ddl_payload[
"tableNames"].IsArray());
2043 for (
auto const& tablename_def : ddl_payload[
"tableNames"].GetArray()) {
2044 CHECK(tablename_def.IsString());
2050 auto table_names =
session_ptr_->get_catalog_ptr()->getTableNamesForUser(
2054 if (ddl_payload.HasMember(
"tableNames")) {
2055 std::vector<std::string> filtered_names;
2056 for (
const auto& tablename_def : ddl_payload[
"tableNames"].GetArray()) {
2057 std::string filter_name = tablename_def.GetString();
2058 if (std::find(table_names.begin(), table_names.end(), filter_name) !=
2059 table_names.end()) {
2060 filtered_names.emplace_back(filter_name);
2062 throw std::runtime_error(
"Can not show disk cache usage for table: " +
2063 filter_name +
". Table does not exist.");
2066 return filtered_names;
2078 const auto disk_cache = cat_ptr->getDataMgr().getPersistentStorageMgr()->getDiskCache();
2080 throw std::runtime_error{
"Disk cache not enabled. Cannot show disk cache usage."};
2084 std::vector<std::string> labels{
"table name",
"current cache size"};
2085 std::vector<TargetMetaInfo> label_infos;
2089 std::vector<RelLogicalValues::RowValues> logical_values;
2091 for (
auto& table_name : table_names) {
2092 auto [td, td_with_lock] =
2093 get_table_descriptor_with_lock<lockmgr::ReadLock>(*cat_ptr, table_name,
false);
2095 auto table_cache_size =
2096 disk_cache->getSpaceReservedByTable(cat_ptr->getDatabaseId(), td->tableId);
2100 logical_values.back().emplace_back(
genLiteralStr(table_name));
2104 std::shared_ptr<ResultSet> rSet = std::shared_ptr<ResultSet>(
2112 std::shared_ptr<Catalog_Namespace::SessionInfo const> session_ptr)
2115 if (ddl_payload.HasMember(
"userNames")) {
2116 CHECK(ddl_payload[
"userNames"].IsArray());
2117 for (
const auto& user_name : ddl_payload[
"userNames"].GetArray()) {
2118 CHECK(user_name.IsString());
2121 CHECK(ddl_payload.HasMember(
"all"));
2122 CHECK(ddl_payload[
"all"].IsBool());
2132 bool all = ddl_payload.HasMember(
"all") ? ddl_payload[
"all"].GetBool() :
false;
2133 if (all && !
self.isSuper) {
2134 throw std::runtime_error(
2135 "SHOW ALL USER DETAILS is only available to superusers. (Try SHOW USER "
2136 "DETAILS instead?)");
2140 std::vector<TargetMetaInfo> label_infos;
2150 std::vector<RelLogicalValues::RowValues> logical_values;
2157 std::map<std::string, Catalog_Namespace::UserMetadata> user_map;
2158 auto user_list = !all ? sys_cat.getAllUserMetadata(
cat->getDatabaseId())
2159 : sys_cat.getAllUserMetadata();
2160 for (
auto& user : user_list) {
2161 if (user.can_login ||
self.isSuper) {
2162 user_map[user.userName] = user;
2166 if (ddl_payload.HasMember(
"userNames")) {
2167 std::map<std::string, Catalog_Namespace::UserMetadata> user_map2;
2168 for (
const auto& user_name_json : ddl_payload[
"userNames"].GetArray()) {
2169 std::string user_name = user_name_json.GetString();
2170 auto uit = user_map.find(user_name);
2171 if (uit == user_map.end()) {
2172 throw std::runtime_error(
"User \"" + user_name +
"\" not found. ");
2174 user_map2[uit->first] = uit->second;
2176 user_map = user_map2;
2180 std::unordered_set<std::string> visible_databases;
2181 if (!
self.isSuper) {
2182 for (
const auto& dbsum : dbsums) {
2183 visible_databases.insert(dbsum.dbName);
2187 for (
const auto& [user_name, user] : user_map) {
2191 if (sys_cat.getMetadataForDBById(user.defaultDbId, db)) {
2192 if (
self.isSuper || visible_databases.count(db.
dbName)) {
2202 logical_values.back().emplace_back(
genLiteralStr(user.userName));
2214 CHECK_EQ(logical_values.size(), user_map.size());
2215 if (logical_values.size() >= 1U) {
2216 CHECK_EQ(logical_values[0].size(), label_infos.size());
2218 std::shared_ptr<ResultSet> rSet = std::shared_ptr<ResultSet>(
2226 std::shared_ptr<Catalog_Namespace::SessionInfo const> session_ptr)
2229 CHECK(ddl_payload[
"userName"].IsString());
2230 CHECK(ddl_payload[
"effective"].IsBool());
2240 std::vector<TargetMetaInfo> label_infos;
2241 std::vector<std::string> labels{
"ROLES"};
2245 std::vector<RelLogicalValues::RowValues> logical_values;
2246 std::vector<std::string> roles_list;
2248 std::string user_name = ddl_payload[
"userName"].GetString();
2249 bool effective = ddl_payload[
"effective"].GetBool();
2250 if (user_name.empty()) {
2251 user_name =
self.userName;
2254 bool is_user = sys_cat.getMetadataForUser(user_name, user);
2255 if (!
self.isSuper) {
2257 if (
self.userId != user.
userId) {
2258 throw std::runtime_error(
2259 "Only a superuser is authorized to request list of roles granted to another "
2263 if (!sys_cat.isRoleGrantedToGrantee(
2264 self.userName, user_name,
false)) {
2265 throw std::runtime_error(
2266 "Only a superuser is authorized to request list of roles granted to a role "
2267 "they don't have.");
2272 auto s = sys_cat.getCreatedRoles();
2273 roles_list.insert(roles_list.end(), s.begin(), s.end());
2275 roles_list = sys_cat.getRoles(user_name, effective);
2277 for (
const std::string& role_name : roles_list) {
2279 logical_values.back().emplace_back(
genLiteralStr(role_name));
2283 std::shared_ptr<ResultSet> rSet = std::shared_ptr<ResultSet>(
2291 std::shared_ptr<Catalog_Namespace::SessionInfo const> session_ptr)
2294 CHECK(ddl_payload.HasMember(
"oldOwners"));
2295 CHECK(ddl_payload[
"oldOwners"].IsArray());
2296 for (
const auto& old_owner : ddl_payload[
"oldOwners"].GetArray()) {
2297 CHECK(old_owner.IsString());
2300 CHECK(ddl_payload.HasMember(
"newOwner"));
2301 CHECK(ddl_payload[
"newOwner"].IsString());
2302 new_owner_ = ddl_payload[
"newOwner"].GetString();
2306 if (read_only_mode) {
2307 throw std::runtime_error(
"REASSIGN OWNER invalid in read only mode.");
2310 throw std::runtime_error{
2311 "Only super users can reassign ownership of database objects."};
static std::shared_ptr< WrapperType< MutexType > > getMutex(const LockType lockType, const KeyType &key)
bool contains(const T &container, const U &element)
int32_t maxRollbackEpochs
ShowForeignServersCommand(const DdlCommandData &ddl_data, std::shared_ptr< Catalog_Namespace::SessionInfo const > session_ptr)
static constexpr const char * WS_SERVER_ACCESS_LOGS_SYS_TABLE_NAME
ExecutionResult execute(bool read_only_mode) override
ShowRolesCommand(const DdlCommandData &ddl_data, std::shared_ptr< Catalog_Namespace::SessionInfo const > session_ptr)
static constexpr const char * SERVER_LOGS_SYS_TABLE_NAME
ExecutionResult execute(bool read_only_mode) override
AlterForeignServerCommand(const DdlCommandData &ddl_data, std::shared_ptr< Catalog_Namespace::SessionInfo const > session_ptr)
static std::vector< TableFunction > get_table_funcs()
void alterOptions(const foreign_storage::ForeignTable &foreign_table)
uint64_t total_data_page_count
const std::string getTargetQuerySessionToKill() const
declare this class scoped local to avoid exposing rapidjson in the header file
static WriteLock getWriteLockForTable(Catalog_Namespace::Catalog &cat, const std::string &table_name)
ShowCreateTableCommand(const DdlCommandData &ddl_data, std::shared_ptr< Catalog_Namespace::SessionInfo const > session_ptr)
JsonColumnSqlType(const rapidjson::Value &data_type)
static const AccessPrivileges DROP_SERVER
ShowCreateServerCommand(const DdlCommandData &ddl_data, std::shared_ptr< Catalog_Namespace::SessionInfo const > session_ptr)
std::unique_ptr< DdlCommandData > ddl_data_
std::string getOptionsAsJsonString() const
static std::vector< ExtensionFunction > get_ext_funcs(const std::string &name)
class for a per-database catalog. also includes metadata for the current database and the current use...
const std::string commandStr() const
uint32_t metadata_file_count
ExecutionResult execute(bool read_only_mode) override
static const AccessPrivileges ALTER_TABLE
CreateForeignServerCommand(const DdlCommandData &ddl_data, std::shared_ptr< Catalog_Namespace::SessionInfo const > session_ptr)
Data_Namespace::DataMgr & getDataMgr() const
void validateAlterOptions(const OptionsMap &options_map) const
Verifies that the given options map only contains options that can be legally altered.
ExecutionResult execute(bool read_only_mode) override
void renameForeignServer()
ShowDatabasesCommand(const DdlCommandData &ddl_data, std::shared_ptr< Catalog_Namespace::SessionInfo const > session_ptr)
ExecutionResult execute(bool read_only_mode) override
ExecutionResult execute(bool read_only_mode) override
void revokeDBObjectPrivilegesFromAll(DBObject object, Catalog *catalog)
static const AccessPrivileges SERVER_USAGE
static std::shared_ptr< QueryState > create(ARGS &&...args)
DropForeignTableCommand(const DdlCommandData &ddl_data, std::shared_ptr< Catalog_Namespace::SessionInfo const > session_ptr)
void throw_reserved_server_prefix_exception()
CreateForeignTableCommand(const DdlCommandData &ddl_data, std::shared_ptr< Catalog_Namespace::SessionInfo const > session_ptr)
void validateSupportedOptionKeys(const OptionsMap &options_map) const
Verifies that the options_map contains the keys required by a foreign table; including those specifie...
void add_table_details(std::vector< RelLogicalValues::RowValues > &logical_values, const TableDescriptor *logical_table, const AggregratedStorageStats &agg_storage_stats)
void aggregate(const File_Namespace::StorageStats &storage_stats)
std::optional< uint64_t > total_free_data_page_count
void refresh_foreign_table(Catalog_Namespace::Catalog &catalog, const std::string &table_name, const bool evict_cached_entries)
static void invalidateCaches()
ShowTablesCommand(const DdlCommandData &ddl_data, std::shared_ptr< Catalog_Namespace::SessionInfo const > session_ptr)
ShowDiskCacheUsageCommand(const DdlCommandData &ddl_data, std::shared_ptr< Catalog_Namespace::SessionInfo const > session_ptr)
ExecutionResult execute(bool read_only_mode) override
void createDBObject(const UserMetadata &user, const std::string &objectName, DBObjectType type, const Catalog_Namespace::Catalog &catalog, int32_t objectId=-1)
void set_headers_with_type(std::vector< TargetMetaInfo > &label_infos, const std::vector< std::tuple< std::string, SQLTypes, bool >> &headers)
DistributedExecutionDetails getDistributedExecutionDetails() const
std::pair< std::string, std::string > getSessionParameter() const
ExecutionResult execute(bool read_only_mode) override
void validate_non_duplicate_column(const std::string &column_name, std::unordered_set< std::string > &upper_column_names)
ExecutionResult execute(bool read_only_mode) override
std::set< std::string > old_owners_
bool isShowQueries() const
static constexpr const char * REQUEST_LOGS_SYS_TABLE_NAME
void set_column_descriptor(const std::string &column_name, ColumnDescriptor &cd, SqlType *column_type, const bool not_null, const Encoding *encoding, const std::string *default_value)
static OptionsMap createOptionsMap(const rapidjson::Value &json_options)
Creates an options map from given options. Converts options that must be upper case appropriately...
static const AccessPrivileges ALTER_SERVER
std::unique_ptr< RexLiteral > genLiteralBigInt(int64_t val)
This file contains the class specification and related data structures for Catalog.
ExecutionResult execute(bool read_only_mode) override
void setTableDetails(const std::string &table_name, TableDescriptor &td, const std::list< ColumnDescriptor > &columns)
bool isAlterSystemClear() const
ExecutionResult execute(bool read_only_mode) override
const DdlCommandData & ddl_data_
bool is_default_server(const std::string &server_name)
static SysCatalog & instance()
This file contains the class specification and related data structures for SysCatalog.
Classes representing a parse tree.
ExecutionResult execute(bool read_only_mode) override
ShowTableDetailsCommand(const DdlCommandData &ddl_data, std::shared_ptr< Catalog_Namespace::SessionInfo const > session_ptr)
void setColumnDetails(std::list< ColumnDescriptor > &columns)
const rapidjson::Value & query() const
DropForeignServerCommand(const DdlCommandData &ddl_data, std::shared_ptr< Catalog_Namespace::SessionInfo const > session_ptr)
static const AccessPrivileges DROP_TABLE
std::string ddl_statement_
std::optional< uint64_t > total_free_metadata_page_count
ExecutionResult execute(bool read_only_mode) override
void populateOptionsMap(OptionsMap &&options_map, bool clear=false)
bool hasAlterServerPrivileges()
const rapidjson::Value & extractPayload(const DdlCommandData &ddl_data)
static std::unordered_set< std::string > get_udfs_name(const bool is_runtime)
std::unique_ptr< RexLiteral > genLiteralTimestamp(time_t val)
bool isShowUserSessions() const
std::unique_lock< T > unique_lock
ExecutionResult execute(bool read_only_mode) override
DBSummaryList getDatabaseListForUser(const UserMetadata &user)
void setForeignServerOptions()
int getDatabaseId() const
uint64_t total_metadata_page_count
static const AccessPrivileges CREATE_SERVER
void updateResultSet(const std::string &query_ra, RType type, bool success=true)
std::unique_ptr< RexLiteral > genLiteralBoolean(bool val)
void validate_non_reserved_keyword(const std::string &column_name)
specifies the content in-memory of a row in the column metadata table
OUTPUT transform(INPUT const &input, FUNC const &func)
AggregationType aggregation_type
static const AccessPrivileges CREATE_TABLE
std::vector< const TableDescriptor * > getPhysicalTablesDescriptors(const TableDescriptor *logical_table_desc, bool populate_fragmenter=true) const
ExecutionResult execute(bool read_only_mode) override
void set_default_table_attributes(const std::string &table_name, TableDescriptor &td, const int32_t column_count)
File_Namespace::GlobalFileMgr * getGlobalFileMgr() const
static ResultSet * create(std::vector< TargetMetaInfo > &label_infos, std::vector< RelLogicalValues::RowValues > &logical_values)
JsonColumnEncoding(const rapidjson::Value &data_type)
bool isAlterSessionSet() const
const rapidjson::Value & payload() const
std::shared_ptr< Catalog_Namespace::SessionInfo const > session_ptr_
std::vector< std::string > getFilteredTableNames()
DdlCommandExecutor(const std::string &ddl_statement, std::shared_ptr< Catalog_Namespace::SessionInfo const > session_ptr)
ExecutionResult execute(bool read_only_mode)
AggregratedStorageStats get_agg_storage_stats(const TableDescriptor *td, const Catalog_Namespace::Catalog *catalog)
ExecutionResult execute(bool read_only_mode) override
rapidjson::Document ddl_query
uint64_t total_metadata_file_size
void changeForeignServerOwner()
static ReadLock getReadLockForTable(Catalog_Namespace::Catalog &cat, const std::string &table_name)
ExecutionResult execute(bool read_only_mode) override
Basic constructors and methods of the row set interface.
std::tuple< const TableDescriptor *, std::unique_ptr< lockmgr::TableSchemaLockContainer< LockType > > > get_table_descriptor_with_lock(Catalog_Namespace::Catalog &cat, const std::string &table_name, const bool populate_fragmenter)
uint64_t total_data_file_size
~DdlCommandDataImpl() override
static const AccessPrivileges ACCESS
ReassignOwnedCommand(const DdlCommandData &ddl_data, std::shared_ptr< Catalog_Namespace::SessionInfo const > session_ptr)
std::vector< std::string > getFilteredTableNames()
static std::unique_ptr< RexLiteral > genLiteralStr(std::string val)
std::string returnCacheType() const
void validate_table_type(const TableDescriptor *td, const TableType expected_table_type, const std::string &command)
const ForeignServer * foreign_server
void renameTable(const foreign_storage::ForeignTable *foreign_table)
ShowFunctionsCommand(const DdlCommandData &ddl_data, std::shared_ptr< Catalog_Namespace::SessionInfo const > session_ptr)
ExecutionResult execute(bool read_only_mode) override
ExecutionResult execute(bool read_only_mode) override
std::list< DBSummary > DBSummaryList
AggregratedStorageStats(const File_Namespace::StorageStats &storage_stats)
std::shared_ptr< Catalog_Namespace::SessionInfo const > session_ptr_
std::vector< std::unique_ptr< const RexScalar >> RowValues
ExecutionResult execute(bool read_only_mode) override
ExecutionLocation execution_location
const rapidjson::Value * extractFilters(const rapidjson::Value &payload)
AlterForeignTableCommand(const DdlCommandData &ddl_data, std::shared_ptr< Catalog_Namespace::SessionInfo const > session_ptr)
void renameColumn(const foreign_storage::ForeignTable *foreign_table)
const std::array< std::string, 3 > kReservedServerPrefixes
std::string commandStr() override
static constexpr char const * FOREIGN_TABLE
ShowRuntimeFunctionsCommand(const DdlCommandData &ddl_data, std::shared_ptr< Catalog_Namespace::SessionInfo const > session_ptr)
static constexpr const char * WS_SERVER_LOGS_SYS_TABLE_NAME
ShowUserDetailsCommand(const DdlCommandData &ddl_data, std::shared_ptr< Catalog_Namespace::SessionInfo const > session_ptr)
void setForeignServerDataWrapper()
static std::unique_ptr< Parser::DDLStmt > delegate(const rapidjson::Value &payload)
ShowRuntimeTableFunctionsCommand(const DdlCommandData &ddl_data, std::shared_ptr< Catalog_Namespace::SessionInfo const > session_ptr)
RefreshForeignTablesCommand(const DdlCommandData &ddl_data, std::shared_ptr< Catalog_Namespace::SessionInfo const > session_ptr)
ExecutionResult execute(bool read_only_mode) override
ShowTableFunctionsCommand(const DdlCommandData &ddl_data, std::shared_ptr< Catalog_Namespace::SessionInfo const > session_ptr)