#include <ParserNode.h>

Inheritance diagram for Parser::RevokePrivilegesStmt:

Collaboration diagram for Parser::RevokePrivilegesStmt:

Public Member Functions
	RevokePrivilegesStmt (std::list< std::string * > p, std::string t, std::string o, std::list< std::string > *g)

	RevokePrivilegesStmt (const rapidjson::Value &payload)

const std::vector< std::string > &	get_privs () const

const std::string &	get_object_type () const

const std::string &	get_object () const

const std::vector< std::string > &	get_grantees () const

void	execute (const Catalog_Namespace::SessionInfo &session, bool read_only_mode) override

Public Member Functions inherited from Parser::DDLStmt
void	setColumnDescriptor (ColumnDescriptor &cd, const ColumnDef *coldef)

Public Member Functions inherited from Parser::Node
virtual	~Node ()

Private Attributes
std::vector< std::string >	privileges_

std::unique_ptr< std::string >	type_

std::unique_ptr< std::string >	target_

std::vector< std::string >	grantees_

Detailed Description

Definition at line 1585 of file ParserNode.h.

Constructor & Destructor Documentation

Parser::RevokePrivilegesStmt::RevokePrivilegesStmt	(	std::list< std::string * > *	p,
		std::string *	t,
		std::string *	o,
		std::list< std::string * > *	g
	)

inline

Definition at line 1587 of file ParserNode.h.

References grantees_, Parser::parser_slistval_to_vector(), and privileges_.

       : type_(t), target_(o) {
     parser_slistval_to_vector(p, privileges_);
     parser_slistval_to_vector(g, grantees_);
   }

Here is the call graph for this function:

Parser::RevokePrivilegesStmt::RevokePrivilegesStmt ( const rapidjson::Value & payload )

Definition at line 6222 of file ParserNode.cpp.

References CHECK, grantees_, json_str(), privileges_, target_, and type_.

                                                                         {
   CHECK(payload.HasMember("type"));
   type_ = std::make_unique<std::string>(json_str(payload["type"]));
 
   CHECK(payload.HasMember("target"));
   target_ = std::make_unique<std::string>(json_str(payload["target"]));
 
   if (payload.HasMember("privileges")) {
     CHECK(payload["privileges"].IsArray());
     for (auto& privilege : payload["privileges"].GetArray()) {
       auto r = json_str(privilege);
       // privilege was a StringLiteral
       //   and is wrapped with quotes which need to get removed
       boost::algorithm::trim_if(r, boost::is_any_of(" \"'`"));
       privileges_.emplace_back(r);
     }
   }
   if (payload.HasMember("grantees")) {
     CHECK(payload["grantees"].IsArray());
     for (auto& grantee : payload["grantees"].GetArray()) {
       std::string g = json_str(grantee);
       grantees_.emplace_back(g);
     }
   }
 }

Here is the call graph for this function:

Member Function Documentation

void Parser::RevokePrivilegesStmt::execute	(	const Catalog_Namespace::SessionInfo &	session,
		bool	read_only_mode
	)

overridevirtual

Implements Parser::DDLStmt.

Definition at line 6248 of file ParserNode.cpp.

References Parser::createObject(), DBObjectTypeFromString(), Parser::extractObjectNameFromHierName(), g_enable_fsi, Catalog_Namespace::SessionInfo::get_currentUser(), get_object(), get_object_type(), get_privs(), Catalog_Namespace::SessionInfo::getCatalog(), grantees_, lockmgr::instance(), Parser::parseStringPrivs(), ServerDBObjectType, and Parser::verifyObject().

Referenced by heavydb.cursor.Cursor::executemany().

                                                         {
   if (read_only_mode) {
     throw std::runtime_error("REVOKE invalid in read only mode.");
   }
   auto& catalog = session.getCatalog();
   const auto& currentUser = session.get_currentUser();
   const auto parserObjectType = boost::to_upper_copy<std::string>(get_object_type());
   const auto objectName =
       extractObjectNameFromHierName(get_object(), parserObjectType, catalog);
   auto objectType = DBObjectTypeFromString(parserObjectType);
   if (objectType == ServerDBObjectType && !g_enable_fsi) {
     throw std::runtime_error("REVOKE failed. SERVER object unrecognized.");
   }
   /* verify object exists and is of proper type *before* trying to execute */
   verifyObject(catalog, objectName, objectType, "REVOKE");
 
   DBObject dbObject = createObject(objectName, objectType);
   /* verify object ownership if not suser */
   if (!currentUser.isSuper) {
     if (!SysCatalog::instance().verifyDBObjectOwnership(currentUser, dbObject, catalog)) {
       throw std::runtime_error(
           "REVOKE failed. It can only be executed by super user or owner of the "
           "object.");
     }
   }
   /* set proper values of privileges & grant them to the object */
   std::vector<DBObject> objects(get_privs().size(), dbObject);
   for (size_t i = 0; i < get_privs().size(); ++i) {
     std::pair<AccessPrivileges, DBObjectType> priv = parseStringPrivs(
         boost::to_upper_copy<std::string>(get_privs()[i]), objectType, get_object());
     objects[i].setPrivileges(priv.first);
     objects[i].setPermissionType(priv.second);
     if (priv.second == ServerDBObjectType && !g_enable_fsi) {
       throw std::runtime_error("REVOKE failed. SERVER object unrecognized.");
     }
   }
   SysCatalog::instance().revokeDBObjectPrivilegesBatch(grantees_, objects, catalog);
 }