#include <RelAlgDag.h>

Inheritance diagram for RelModify:

Collaboration diagram for RelModify:

Public Types
enum	ModifyOperation { ModifyOperation::Insert, ModifyOperation::Delete, ModifyOperation::Update }

using	RelAlgNodeInputPtr = std::shared_ptr< const RelAlgNode >

using	TargetColumnList = std::vector< std::string >

Public Member Functions
	RelModify (Catalog_Namespace::Catalog const &cat, TableDescriptor const *const td)

	RelModify (Catalog_Namespace::Catalog const &cat, TableDescriptor const *const td, bool flattened, std::string const &op_string, TargetColumnList const &target_column_list, RelAlgNodeInputPtr input)

	RelModify (Catalog_Namespace::Catalog const &cat, TableDescriptor const *const td, bool flattened, ModifyOperation op, TargetColumnList const &target_column_list, RelAlgNodeInputPtr input)

virtual void	acceptChildren (Visitor &v) const override

virtual void	accept (Visitor &v, std::string name) const override

TableDescriptor const *const	getTableDescriptor () const

const Catalog_Namespace::Catalog &	getCatalog () const

bool const	isFlattened () const

ModifyOperation	getOperation () const

TargetColumnList const &	getUpdateColumnNames () const

int	getUpdateColumnCount () const

size_t	size () const override

std::shared_ptr< RelAlgNode >	deepCopy () const override

std::string	toString (RelRexToStringConfig config=RelRexToStringConfig::defaults()) const override

void	applyUpdateModificationsToInputNode ()

void	applyDeleteModificationsToInputNode ()

virtual size_t	toHash () const override

Public Member Functions inherited from RelAlgNode
	RelAlgNode (RelAlgInputs inputs={})

virtual	~RelAlgNode ()

void	resetQueryExecutionState ()

void	setContextData (const RaExecutionDesc *context_data) const

void	setOutputMetainfo (std::vector< TargetMetaInfo > targets_metainfo) const

void	setQueryPlanDag (const std::string &extracted_query_plan_dag) const

std::string	getQueryPlanDag () const

size_t	getQueryPlanDagHash () const

const std::vector < TargetMetaInfo > &	getOutputMetainfo () const

unsigned	getId () const

bool	hasContextData () const

const RaExecutionDesc *	getContextData () const

const size_t	inputCount () const

const RelAlgNode *	getInput (const size_t idx) const

const std::vector< RelAlgNode const * >	getInputs () const

std::shared_ptr< const RelAlgNode >	getAndOwnInput (const size_t idx) const

void	addManagedInput (std::shared_ptr< const RelAlgNode > input)

bool	hasInput (const RelAlgNode *needle) const

virtual void	replaceInput (std::shared_ptr< const RelAlgNode > old_input, std::shared_ptr< const RelAlgNode > input)

void	setRelNodeDagId (const size_t id) const

size_t	getRelNodeDagId () const

bool	isNop () const

void	markAsNop ()

void	clearContextData () const

Public Member Functions inherited from RelAlgDagNode
	RelAlgDagNode ()

virtual size_t	getStepNumber () const

virtual void	setStepNumber (size_t step) const

std::optional< size_t >	getIdInPlanTree () const

void	setIdInPlanTree (size_t id) const

Static Public Member Functions
static std::string	yieldModifyOperationString (ModifyOperation const op)

static ModifyOperation	yieldModifyOperationEnum (std::string const &op_string)

Static Public Member Functions inherited from RelAlgNode
static void	resetRelAlgFirstId () noexcept

Private Attributes
Catalog_Namespace::Catalog const &	catalog_

const TableDescriptor *	table_descriptor_

bool	flattened_

ModifyOperation	operation_

TargetColumnList	target_column_list_

Friends
struct	RelAlgDagSerializer

std::size_t	hash_value (RelModify const &)

Additional Inherited Members
Protected Attributes inherited from RelAlgNode
RelAlgInputs	inputs_

unsigned	id_

std::optional< size_t >	hash_

Protected Attributes inherited from RelAlgDagNode
size_t	step_ {0}

std::optional< size_t >	id_in_plan_tree_

Detailed Description

Definition at line 2287 of file RelAlgDag.h.

Member Typedef Documentation

using RelModify::RelAlgNodeInputPtr = std::shared_ptr<const RelAlgNode>

Definition at line 2290 of file RelAlgDag.h.

using RelModify::TargetColumnList = std::vector<std::string>

Definition at line 2291 of file RelAlgDag.h.

Member Enumeration Documentation

enum RelModify::ModifyOperation

strong

Enumerator
Insert
Delete
Update

Definition at line 2289 of file RelAlgDag.h.

2289 { Insert, Delete, Update };

Constructor & Destructor Documentation

RelModify::RelModify	(	Catalog_Namespace::Catalog const &	cat,
		TableDescriptor const *const	td
	)

inline

Definition at line 2321 of file RelAlgDag.h.

       : catalog_{cat}
       , table_descriptor_{td}
       , flattened_{false}
       , operation_{ModifyOperation::Insert} {}

RelModify::RelModify	(	Catalog_Namespace::Catalog const &	cat,
		TableDescriptor const *const	td,
		bool	flattened,
		std::string const &	op_string,
		TargetColumnList const &	target_column_list,
		RelAlgNodeInputPtr	input
	)

inline

Definition at line 2327 of file RelAlgDag.h.

References RelAlgNode::inputs_, table_descriptor_, and foreign_storage::validate_non_foreign_table_write().

       : catalog_(cat)
       , table_descriptor_(td)
       , flattened_(flattened)
       , operation_(yieldModifyOperationEnum(op_string))
       , target_column_list_(target_column_list) {
     foreign_storage::validate_non_foreign_table_write(table_descriptor_);
     inputs_.push_back(input);
   }

Here is the call graph for this function:

RelModify::RelModify	(	Catalog_Namespace::Catalog const &	cat,
		TableDescriptor const *const	td,
		bool	flattened,
		ModifyOperation	op,
		TargetColumnList const &	target_column_list,
		RelAlgNodeInputPtr	input
	)

inline

Definition at line 2342 of file RelAlgDag.h.

References RelAlgNode::inputs_, table_descriptor_, and foreign_storage::validate_non_foreign_table_write().

       : catalog_(cat)
       , table_descriptor_(td)
       , flattened_(flattened)
       , operation_(op)
       , target_column_list_(target_column_list) {
     foreign_storage::validate_non_foreign_table_write(table_descriptor_);
     inputs_.push_back(input);
   }

Here is the call graph for this function:

Member Function Documentation

virtual void RelModify::accept	(	Visitor &	v,
		std::string	name
	)		const

inlineoverridevirtual

Implements RelAlgDagNode.

Definition at line 2364 of file RelAlgDag.h.

References acceptChildren(), and RelAlgDagNode::Visitor::visit().

Referenced by TableFunctionsFactory_node.PrintNode::__str__().

                                                                  {
     if (v.visit(this, std::move(name))) {
       acceptChildren(v);
     }
   }

Here is the call graph for this function:

Here is the caller graph for this function:

virtual void RelModify::acceptChildren ( Visitor & v ) const

inlineoverridevirtual

Implements RelAlgDagNode.

Definition at line 2357 of file RelAlgDag.h.

References RelAlgNode::getInputs(), and anonymous_namespace{Utm.h}::n.

Referenced by accept().

                                                          {
     for (auto& n : getInputs()) {
       if (n) {
         n->accept(v, "input");
       }
     }
   }

Here is the call graph for this function:

Here is the caller graph for this function:

void RelModify::applyDeleteModificationsToInputNode ( )

inline

Definition at line 2479 of file RelAlgDag.h.

References catalog_, CHECK, RelAlgNode::inputs_, ModifyManipulationTarget::setDeleteViaSelectFlag(), and table_descriptor_.

                                              {
     auto previous_node = dynamic_cast<RelProject const*>(inputs_[0].get());
     CHECK(previous_node != nullptr);
     auto previous_project_node = const_cast<RelProject*>(previous_node);
     previous_project_node->setDeleteViaSelectFlag(true);
     previous_project_node->setModifiedTableDescriptor(table_descriptor_);
     previous_project_node->setModifiedTableCatalog(&catalog_);
   }

Here is the call graph for this function:

void RelModify::applyUpdateModificationsToInputNode ( )

inline

Definition at line 2411 of file RelAlgDag.h.

References catalog_, CHECK, TableDescriptor::fragmenter, Catalog_Namespace::Catalog::getMetadataForColumn(), Catalog_Namespace::Catalog::getShardColumnMetadataForTable(), RelAlgNode::inputs_, TableDescriptor::nShards, table_descriptor_, TableDescriptor::tableId, and target_column_list_.

                                              {
     auto previous_node = dynamic_cast<RelProject const*>(inputs_[0].get());
     CHECK(previous_node != nullptr);
     auto previous_project_node = const_cast<RelProject*>(previous_node);
 
     if (previous_project_node->hasWindowFunctionExpr()) {
       if (table_descriptor_->fragmenter->getNumFragments() > 1) {
         throw std::runtime_error(
             "UPDATE of a column of multi-fragmented table using window function not "
             "currently supported.");
       }
       if (table_descriptor_->nShards > 0) {
         throw std::runtime_error(
             "UPDATE of a column of sharded table using window function not "
             "currently supported.");
       }
     }
 
     previous_project_node->setUpdateViaSelectFlag(true);
     // remove the offset column in the projection for update handling
     target_column_list_.pop_back();
 
     previous_project_node->setModifiedTableDescriptor(table_descriptor_);
     previous_project_node->setTargetColumns(target_column_list_);
     previous_project_node->setModifiedTableCatalog(&catalog_);
 
     int target_update_column_expr_start = 0;
     int target_update_column_expr_end = (int)(target_column_list_.size() - 1);
     CHECK(target_update_column_expr_start >= 0);
     CHECK(target_update_column_expr_end >= 0);
 
     bool varlen_update_required = false;
 
     auto varlen_scan_visitor = [this,
                                 &varlen_update_required,
                                 target_update_column_expr_start,
                                 target_update_column_expr_end](int index) {
       if (index >= target_update_column_expr_start &&
           index <= target_update_column_expr_end) {
         auto target_index = index - target_update_column_expr_start;
 
         auto* column_desc = catalog_.getMetadataForColumn(
             table_descriptor_->tableId, target_column_list_[target_index]);
         CHECK(column_desc);
 
         if (table_descriptor_->nShards) {
           const auto shard_cd =
               catalog_.getShardColumnMetadataForTable(table_descriptor_);
           CHECK(shard_cd);
           if ((column_desc->columnName == shard_cd->columnName)) {
             throw std::runtime_error("UPDATE of a shard key is currently unsupported.");
           }
         }
 
         // Check for valid types
         if (column_desc->columnType.is_varlen()) {
           varlen_update_required = true;
         }
         if (column_desc->columnType.is_geometry()) {
           throw std::runtime_error("UPDATE of a geo column is unsupported.");
         }
       }
     };
 
     previous_project_node->visitScalarExprs(varlen_scan_visitor);
     previous_project_node->setVarlenUpdateRequired(varlen_update_required);
   }

Here is the call graph for this function:

std::shared_ptr<RelAlgNode> RelModify::deepCopy ( ) const

inlineoverridevirtual

Implements RelAlgNode.

Definition at line 2380 of file RelAlgDag.h.

                                                       {
     return std::make_shared<RelModify>(*this);
   }

const Catalog_Namespace::Catalog& RelModify::getCatalog ( ) const

inline

Definition at line 2372 of file RelAlgDag.h.

References catalog_.

2372 { return catalog_; }

RelModify::catalog_

Catalog_Namespace::Catalog const & catalog_

Definition: RelAlgDag.h:2493

ModifyOperation RelModify::getOperation ( ) const

inline

Definition at line 2375 of file RelAlgDag.h.

References operation_.

2375 { return operation_; }

RelModify::operation_

ModifyOperation operation_

Definition: RelAlgDag.h:2496

TableDescriptor const* const RelModify::getTableDescriptor ( ) const

inline

Definition at line 2370 of file RelAlgDag.h.

References table_descriptor_.

2370 { return table_descriptor_; }

RelModify::table_descriptor_

const TableDescriptor * table_descriptor_

Definition: RelAlgDag.h:2494

int RelModify::getUpdateColumnCount ( ) const

inline

Definition at line 2377 of file RelAlgDag.h.

References target_column_list_.

2377 { return target_column_list_.size(); }

RelModify::target_column_list_

TargetColumnList target_column_list_

Definition: RelAlgDag.h:2497

TargetColumnList const& RelModify::getUpdateColumnNames ( ) const

inline

Definition at line 2376 of file RelAlgDag.h.

References target_column_list_.

2376 { return target_column_list_; }

RelModify::target_column_list_

TargetColumnList target_column_list_

Definition: RelAlgDag.h:2497

bool const RelModify::isFlattened ( ) const

inline

Definition at line 2374 of file RelAlgDag.h.

References flattened_.

2374 { return flattened_; }

RelModify::flattened_

bool flattened_

Definition: RelAlgDag.h:2495

size_t RelModify::size ( ) const

inlineoverridevirtual

Implements RelAlgNode.

Definition at line 2379 of file RelAlgDag.h.

2379 { return 0; }

virtual size_t RelModify::toHash ( ) const

inlineoverridevirtual

Implements RelAlgNode.

Definition at line 2488 of file RelAlgDag.h.

References hash_value.

2488 { return hash_value(*this); }

RelModify::hash_value

friend std::size_t hash_value(RelModify const &)

Definition: RelAlgDag.cpp:3804

std::string RelModify::toString ( RelRexToStringConfig config = RelRexToStringConfig::defaults() ) const

inlineoverridevirtual

Implements RelAlgNode.

Definition at line 2384 of file RelAlgDag.h.

References cat(), flattened_, RelAlgNode::inputs_, operation_, table_descriptor_, TableDescriptor::tableName, target_column_list_, to_string(), typeName(), and yieldModifyOperationString().

                                                                                    {
     auto ret = cat(::typeName(this),
                    "(",
                    table_descriptor_->tableName,
                    ", flattened=",
                    std::to_string(flattened_),
                    ", op=",
                    yieldModifyOperationString(operation_),
                    ", target_column_list=",
                    ::toString(target_column_list_));
 
     if (!config.skip_input_nodes) {
       ret += ", inputs=", ::toString(inputs_);
     } else {
       ret += ", input node id={";
       for (auto& input : inputs_) {
         auto node_id_in_plan = input->getIdInPlanTree();
         auto node_id_str = node_id_in_plan ? std::to_string(*node_id_in_plan)
                                            : std::to_string(input->getId());
         ret += node_id_str + " ";
       }
       ret += "}";
     }
     return cat(ret, ")");
   }

Here is the call graph for this function:

static ModifyOperation RelModify::yieldModifyOperationEnum ( std::string const & op_string )

inlinestatic

Definition at line 2307 of file RelAlgDag.h.

References Delete, Insert, and Update.

                                                                               {
     if (op_string == "INSERT") {
       return ModifyOperation::Insert;
     } else if (op_string == "DELETE") {
       return ModifyOperation::Delete;
     } else if (op_string == "UPDATE") {
       return ModifyOperation::Update;
     }
 
     throw std::runtime_error(
         std::string("Unsupported logical modify operation encountered " + op_string));
   }

static std::string RelModify::yieldModifyOperationString ( ModifyOperation const op )

inlinestatic

Definition at line 2293 of file RelAlgDag.h.

References Delete, Insert, and Update.

Referenced by hash_value(), and toString().

                                                                         {
     switch (op) {
       case ModifyOperation::Delete:
         return "DELETE";
       case ModifyOperation::Insert:
         return "INSERT";
       case ModifyOperation::Update:
         return "UPDATE";
       default:
         break;
     }
     throw std::runtime_error("Unexpected ModifyOperation enum encountered.");
   }

Here is the caller graph for this function:

Friends And Related Function Documentation

std::size_t hash_value ( RelModify const & rel_modify )

friend

Definition at line 3804 of file RelAlgDag.cpp.

Referenced by toHash().

                                                   {
   if (rel_modify.hash_) {
     return *rel_modify.hash_;
   }
   rel_modify.hash_ = typeid(RelModify).hash_code();
   boost::hash_combine(*rel_modify.hash_, rel_modify.table_descriptor_->tableName);
   boost::hash_combine(*rel_modify.hash_, rel_modify.table_descriptor_->tableId);
   boost::hash_combine(*rel_modify.hash_, rel_modify.flattened_);
   boost::hash_combine(*rel_modify.hash_,
                       RelModify::yieldModifyOperationString(rel_modify.operation_));
   boost::hash_combine(*rel_modify.hash_, rel_modify.target_column_list_);
   boost::hash_combine(*rel_modify.hash_, rel_modify.inputs_);
   return *rel_modify.hash_;
 }