duckdb::LogicalOperator Class Reference

#include <duckdb.hpp>

Inheritance diagram for duckdb::LogicalOperator:

Collaboration diagram for duckdb::LogicalOperator:

Public Member Functions
	LogicalOperator (LogicalOperatorType type)
	LogicalOperator (LogicalOperatorType type, vector< unique_ptr< Expression > > expressions)
virtual vector< ColumnBinding >	GetColumnBindings ()
virtual idx_t	GetRootIndex ()
void	PrintColumnBindings ()
void	ResolveOperatorTypes ()
	Resolve the types of the logical operator and its children.
virtual string	GetName () const
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)
virtual idx_t	EstimateCardinality (ClientContext &context)
void	SetEstimatedCardinality (idx_t _estimated_cardinality)
void	SetParamsEstimatedCardinality (InsertionOrderPreservingMap< string > &result) const
virtual void	Serialize (Serializer &serializer) 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 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
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

Protected Member Functions
virtual void	ResolveTypes ()=0
	Resolve types for this specific operator.

Detailed Description

LogicalOperator is the base class of the logical operators present in the logical query tree

Member Function Documentation

RequireOptimizer()

virtual bool duckdb::LogicalOperator::RequireOptimizer ( ) const

inlinevirtual

                                          {
        return true;
    }

SupportSerialization()

virtual bool duckdb::LogicalOperator::SupportSerialization ( ) const

inlinevirtual

Allows LogicalOperators to opt out of serialization.

Reimplemented in duckdb::LogicalGet.

                                              {
        return true;
    };

HasProjectionMap()

virtual bool duckdb::LogicalOperator::HasProjectionMap ( ) const

inlinevirtual

                                          {
        return false;
    }

GetTableIndex()

virtual vector< idx_t > duckdb::LogicalOperator::GetTableIndex ( ) const

virtual

Returns the set of table indexes of this operator.

Reimplemented in duckdb::LogicalGet, and duckdb::LogicalProjection.

ResolveTypes()

virtual void duckdb::LogicalOperator::ResolveTypes ( )

protectedpure virtual

Resolve types for this specific operator.

Implemented in duckdb::LogicalGet, duckdb::LogicalProjection, and duckdb::LogicalUpdate.

Cast() [1/2]

template<class TARGET >

TARGET & duckdb::LogicalOperator::Cast ( )

inline

                   {
        if (TARGET::TYPE != LogicalOperatorType::LOGICAL_INVALID && type != TARGET::TYPE) {
            throw InternalException("Failed to cast logical operator to type - logical operator type mismatch");
        }
        return reinterpret_cast<TARGET &>(*this);
    }

Cast() [2/2]

template<class TARGET >

const TARGET & duckdb::LogicalOperator::Cast ( ) const

inline

                               {
        if (TARGET::TYPE != LogicalOperatorType::LOGICAL_INVALID && type != TARGET::TYPE) {
            throw InternalException("Failed to cast logical operator to type - logical operator type mismatch");
        }
        return reinterpret_cast<const TARGET &>(*this);
    }

---

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

• external/duckdb/duckdb.hpp