#include <ParserNode.h>

Inheritance diagram for Parser::CreateViewStmt:

Collaboration diagram for Parser::CreateViewStmt:

Public Member Functions
	CreateViewStmt (const std::string &view_name, const std::string &select_query, const bool if_not_exists)

	CreateViewStmt (const rapidjson::Value &payload)

const std::string &	get_view_name () const

const std::string &	get_select_query () const

void	execute (const Catalog_Namespace::SessionInfo &session) 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::string	view_name_

std::string	select_query_

bool	if_not_exists_

Detailed Description

Definition at line 1893 of file ParserNode.h.

Constructor & Destructor Documentation

Parser::CreateViewStmt::CreateViewStmt	(	const std::string &	view_name,
		const std::string &	select_query,
		const bool	if_not_exists
	)

inline

Definition at line 1895 of file ParserNode.h.

       : view_name_(view_name)
       , select_query_(select_query)
       , if_not_exists_(if_not_exists) {}

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

Definition at line 5507 of file ParserNode.cpp.

References CHECK, json_bool(), and json_str().

                                                             {
   CHECK(payload.HasMember("name"));
   view_name_ = json_str(payload["name"]);
 
   if_not_exists_ = false;
   if (payload.HasMember("ifNotExists")) {
     if_not_exists_ = json_bool(payload["ifNotExists"]);
   }
 
   CHECK(payload.HasMember("query"));
   select_query_ = json_str(payload["query"]);
   std::regex newline_re("\\n");
   select_query_ = std::regex_replace(select_query_, newline_re, " ");
   // ensure a trailing semicolon is present on the select query
   if (select_query_.back() != ';') {
     select_query_.push_back(';');
   }
 }

Here is the call graph for this function:

Member Function Documentation

void Parser::CreateViewStmt::execute ( const Catalog_Namespace::SessionInfo & session )

overridevirtual

Implements Parser::DDLStmt.

Definition at line 5526 of file ParserNode.cpp.

References Catalog_Namespace::SessionInfo::checkDBAccessPrivileges(), query_state::QueryState::create(), AccessPrivileges::CREATE_VIEW, DEFAULT_FRAGMENT_ROWS, DEFAULT_MAX_CHUNK_SIZE, DEFAULT_MAX_ROWS, DEFAULT_PAGE_SIZE, legacylockmgr::ExecutorOuterLock, Catalog_Namespace::SessionInfo::get_currentUser(), Catalog_Namespace::SessionInfo::getCatalog(), legacylockmgr::LockMgr< MutexType, KeyType >::getMutex(), Fragmenter_Namespace::INSERT_ORDER, pg_shim(), STDLOG, TableDescriptor::tableName, Catalog_Namespace::UserMetadata::userId, and ViewDBObjectType.

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

                                                                         {
   auto session_copy = session;
   auto session_ptr = std::shared_ptr<Catalog_Namespace::SessionInfo>(
       &session_copy, boost::null_deleter());
   auto query_state = query_state::QueryState::create(session_ptr, select_query_);
   auto stdlog = STDLOG(query_state);
   auto& catalog = session.getCatalog();
 
   if (!catalog.validateNonExistentTableOrView(view_name_, if_not_exists_)) {
     return;
   }
   if (!session.checkDBAccessPrivileges(DBObjectType::ViewDBObjectType,
                                        AccessPrivileges::CREATE_VIEW)) {
     throw std::runtime_error("View " + view_name_ +
                              " will not be created. User has no create view privileges.");
   }
 
   const auto query_after_shim = pg_shim(select_query_);
 
   // this now also ensures that access permissions are checked
   catalog.getCalciteMgr()->process(query_state->createQueryStateProxy(),
                                    query_after_shim,
                                    {},
                                    true,
                                    false,
                                    false,
                                    true);
 
   // Take write lock after the query is processed to ensure no deadlocks
   const auto execute_write_lock = mapd_unique_lock<mapd_shared_mutex>(
       *legacylockmgr::LockMgr<mapd_shared_mutex, bool>::getMutex(
           legacylockmgr::ExecutorOuterLock, true));
 
   TableDescriptor td;
   td.tableName = view_name_;
   td.userId = session.get_currentUser().userId;
   td.nColumns = 0;
   td.isView = true;
   td.viewSQL = query_after_shim;
   td.fragmenter = nullptr;
   td.fragType = Fragmenter_Namespace::FragmenterType::INSERT_ORDER;
   td.maxFragRows =
       DEFAULT_FRAGMENT_ROWS;  // @todo this stuff should not be InsertOrderFragmenter
   td.maxChunkSize =
       DEFAULT_MAX_CHUNK_SIZE;  // @todo this stuff should not be InsertOrderFragmenter
   td.fragPageSize = DEFAULT_PAGE_SIZE;
   td.maxRows = DEFAULT_MAX_ROWS;
   catalog.createTable(td, {}, {}, true);
 
   // TODO (max): It's transactionally unsafe, should be fixed: we may create object
   // w/o privileges
   SysCatalog::instance().createDBObject(
       session.get_currentUser(), view_name_, ViewDBObjectType, catalog);
 }