#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, 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::string	view_name_

std::string	select_query_

bool	if_not_exists_

Detailed Description

Definition at line 1883 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 1885 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 6404 of file ParserNode.cpp.

References CHECK, if_not_exists_, json_bool(), json_str(), select_query_, and view_name_.

                                                             {
   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,
		bool	read_only_mode
	)

overridevirtual

Implements Parser::DDLStmt.

Definition at line 6423 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, g_enable_watchdog, Catalog_Namespace::SessionInfo::get_currentUser(), Catalog_Namespace::SessionInfo::getCatalog(), legacylockmgr::LockMgr< MutexType, KeyType >::getMutex(), if_not_exists_, Fragmenter_Namespace::INSERT_ORDER, pg_shim(), select_query_, STDLOG, TableDescriptor::tableName, Catalog_Namespace::UserMetadata::userId, view_name_, and ViewDBObjectType.

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

                                                   {
   if (read_only_mode) {
     throw std::runtime_error("CREATE VIEW invalid in read only mode.");
   }
   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_);
   auto calcite_mgr = catalog.getCalciteMgr();
 
   // this now also ensures that access permissions are checked
   const auto calciteQueryParsingOption =
       calcite_mgr->getCalciteQueryParsingOption(true, false, true);
   const auto calciteOptimizationOption = calcite_mgr->getCalciteOptimizationOption(
       false, g_enable_watchdog, {}, SysCatalog::instance().isAggregator());
   calcite_mgr->process(query_state->createQueryStateProxy(),
                        query_after_shim,
                        calciteQueryParsingOption,
                        calciteOptimizationOption);
 
   // Take write lock after the query is processed to ensure no deadlocks
   const auto execute_write_lock =
       heavyai::unique_lock<legacylockmgr::WrapperType<heavyai::shared_mutex>>(
           *legacylockmgr::LockMgr<heavyai::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);
 }