duckdb::LogicalUpdate Class Reference

Inheritance diagram for duckdb::LogicalUpdate:

Collaboration diagram for duckdb::LogicalUpdate:

Public Member Functions
	LogicalUpdate (TableCatalogEntry &table)
void	Serialize (Serializer &serializer) const override
idx_t	EstimateCardinality (ClientContext &context) override
string	GetName () const override
Public Member Functions inherited from duckdb::LogicalOperator
	LogicalOperator (LogicalOperatorType type)
	LogicalOperator (LogicalOperatorType type, vector< unique_ptr< Expression > > expressions)
virtual idx_t	GetRootIndex ()
void	PrintColumnBindings ()
void	ResolveOperatorTypes ()
	Resolve the types of the logical operator and its children.
virtual InsertionOrderPreservingMap< string >	ParamsToString () const
virtual string	ToString (ExplainFormat format=ExplainFormat::DEFAULT) const
DUCKDB_API void	Print ()
virtual void	Verify (ClientContext &context)
	Debug method: verify that the integrity of expressions & child nodes are maintained.
void	AddChild (unique_ptr< LogicalOperator > child)
void	SetEstimatedCardinality (idx_t _estimated_cardinality)
void	SetParamsEstimatedCardinality (InsertionOrderPreservingMap< string > &result) const
virtual unique_ptr< LogicalOperator >	Copy (ClientContext &context) const
virtual bool	RequireOptimizer () const
virtual bool	SupportSerialization () const
	Allows LogicalOperators to opt out of serialization.
virtual bool	HasProjectionMap () const
virtual vector< idx_t >	GetTableIndex () const
	Returns the set of table indexes of this operator.
template<class TARGET >
TARGET &	Cast ()
template<class TARGET >
const TARGET &	Cast () const

Static Public Member Functions
static unique_ptr< LogicalOperator >	Deserialize (Deserializer &deserializer)
static DUCKDB_API void	BindExtraColumns (TableCatalogEntry &table, LogicalGet &get, LogicalProjection &proj, LogicalUpdate &update, physical_index_set_t &bound_columns)
static void	RewriteInPlaceUpdates (LogicalOperator &update_op)
Static Public Member Functions inherited from duckdb::LogicalOperator
static string	ColumnBindingsToString (const vector< ColumnBinding > &bindings)
static vector< ColumnBinding >	GenerateColumnBindings (idx_t table_idx, idx_t column_count)
static vector< LogicalType >	MapTypes (const vector< LogicalType > &types, const vector< idx_t > &projection_map)
static vector< ColumnBinding >	MapBindings (const vector< ColumnBinding > &types, const vector< idx_t > &projection_map)
static unique_ptr< LogicalOperator >	Deserialize (Deserializer &deserializer)

Public Attributes
TableCatalogEntry &	table
	The base table to update.
idx_t	table_index
	projection index
bool	return_chunk
	if returning option is used, return the update chunk
vector< PhysicalIndex >	columns
vector< unique_ptr< Expression > >	bound_defaults
vector< unique_ptr< BoundConstraint > >	bound_constraints
bool	update_is_del_and_insert
Public Attributes inherited from duckdb::LogicalOperator
LogicalOperatorType	type
	The type of the logical operator.
vector< unique_ptr< LogicalOperator > >	children
	The set of children of the operator.
vector< unique_ptr< Expression > >	expressions
	The set of expressions contained within the operator, if any.
vector< LogicalType >	types
	The types returned by this logical operator. Set by calling LogicalOperator::ResolveTypes.
idx_t	estimated_cardinality
	Estimated Cardinality.
bool	has_estimated_cardinality

Static Public Attributes
static constexpr const LogicalOperatorType	TYPE = LogicalOperatorType::LOGICAL_UPDATE

Protected Member Functions
vector< ColumnBinding >	GetColumnBindings () override
void	ResolveTypes () override
	Resolve types for this specific operator.

Private Member Functions
	LogicalUpdate (ClientContext &context, const unique_ptr< CreateInfo > &table_info)

Member Function Documentation

Serialize()

void duckdb::LogicalUpdate::Serialize ( Serializer &  serializer ) const

overridevirtual

Reimplemented from duckdb::LogicalOperator.

EstimateCardinality()

idx_t duckdb::LogicalUpdate::EstimateCardinality ( ClientContext &  context )

overridevirtual

Reimplemented from duckdb::LogicalOperator.

GetName()

string duckdb::LogicalUpdate::GetName ( ) const

overridevirtual

Reimplemented from duckdb::LogicalOperator.

BindExtraColumns()

void duckdb::LogicalUpdate::BindExtraColumns ( TableCatalogEntry &  table, LogicalGet &  get, LogicalProjection &  proj, LogicalUpdate &  update, physical_index_set_t &  bound_columns  )

static

                                                                                                 {
    if (bound_columns.size() <= 1) {
        return;
    }
    idx_t found_column_count = 0;
    physical_index_set_t found_columns;
    for (idx_t i = 0; i < update.columns.size(); i++) {
        if (bound_columns.find(update.columns[i]) != bound_columns.end()) {
            // this column is referenced in the CHECK constraint
            found_column_count++;
            found_columns.insert(update.columns[i]);
        }
    }
    if (found_column_count != bound_columns.size()) {
        // columns that were required are not all part of the UPDATE
        // add them to the scan and update set
        for (auto &physical_id : bound_columns) {
            if (found_columns.find(physical_id) != found_columns.end()) {
                // column is already projected
                continue;
            }
            // column is not projected yet: project it by adding the clause "i=i" to the set of updated columns
            auto &column = table.GetColumns().GetColumn(physical_id);
            update.expressions.push_back(make_uniq<BoundColumnRefExpression>(
                column.Type(), ColumnBinding(proj.table_index, proj.expressions.size())));
            proj.expressions.push_back(make_uniq<BoundColumnRefExpression>(
                column.Type(), ColumnBinding(get.table_index, get.GetColumnIds().size())));
            get.AddColumnId(column.Logical().index);
            update.columns.push_back(physical_id);
        }
    }
}

GetColumnBindings()

vector< ColumnBinding > duckdb::LogicalUpdate::GetColumnBindings ( )

overrideprotectedvirtual

Reimplemented from duckdb::LogicalOperator.

ResolveTypes()

void duckdb::LogicalUpdate::ResolveTypes ( )

overrideprotectedvirtual

Resolve types for this specific operator.

Implements duckdb::LogicalOperator.

---

The documentation for this class was generated from the following file:

• external/duckdb/duckdb.cpp