PhysicalOperator is the base class of the physical operators present in the execution plan. More...

#include <duckdb.hpp>

Inheritance diagram for duckdb::PhysicalOperator:

[legend]

Collaboration diagram for duckdb::PhysicalOperator:

[legend]

Public Member Functions
	PhysicalOperator (PhysicalPlan &physical_plan, PhysicalOperatorType type, vector< LogicalType > types, idx_t estimated_cardinality)

	PhysicalOperator (const PhysicalOperator &other)=delete
	Deleted copy constructors.

PhysicalOperator &	operator= (const PhysicalOperator &)=delete

virtual string	GetName () const

virtual InsertionOrderPreservingMap< string >	ParamsToString () const

virtual string	ToString (ExplainFormat format=ExplainFormat::DEFAULT) const

void	Print () const

virtual vector< const_reference< PhysicalOperator > >	GetChildren () const

const vector< LogicalType > &	GetTypes () const
	Return a vector of the types that will be returned by this operator.

virtual bool	Equals (const PhysicalOperator &other) const

idx_t	EstimatedThreadCount () const
	Functions to help decide how to set up pipeline dependencies.

bool	CanSaturateThreads (ClientContext &context) const

virtual void	Verify ()

virtual unique_ptr< OperatorState >	GetOperatorState (ExecutionContext &context) const

virtual unique_ptr< GlobalOperatorState >	GetGlobalOperatorState (ClientContext &context) const

virtual OperatorResultType	Execute (ExecutionContext &context, DataChunk &input, DataChunk &chunk, GlobalOperatorState &gstate, OperatorState &state) const

virtual OperatorFinalizeResultType	FinalExecute (ExecutionContext &context, DataChunk &chunk, GlobalOperatorState &gstate, OperatorState &state) const

virtual OperatorFinalResultType	OperatorFinalize (Pipeline &pipeline, Event &event, ClientContext &context, OperatorFinalizeInput &input) const

virtual bool	ParallelOperator () const

virtual bool	RequiresFinalExecute () const

virtual bool	RequiresOperatorFinalize () const

virtual OrderPreservationType	OperatorOrder () const
	The influence the operator has on order (insertion order means no influence)

virtual unique_ptr< LocalSourceState >	GetLocalSourceState (ExecutionContext &context, GlobalSourceState &gstate) const

virtual unique_ptr< GlobalSourceState >	GetGlobalSourceState (ClientContext &context) const

SourceResultType	GetData (ExecutionContext &context, DataChunk &chunk, OperatorSourceInput &input) const

virtual OperatorPartitionData	GetPartitionData (ExecutionContext &context, DataChunk &chunk, GlobalSourceState &gstate, LocalSourceState &lstate, const OperatorPartitionInfo &partition_info) const

virtual bool	IsSource () const

virtual bool	ParallelSource () const

virtual bool	SupportsPartitioning (const OperatorPartitionInfo &partition_info) const

virtual OrderPreservationType	SourceOrder () const
	The type of order emitted by the operator (as a source)

virtual ProgressData	GetProgress (ClientContext &context, GlobalSourceState &gstate) const
	Returns the current progress percentage, or a negative value if progress bars are not supported.

virtual ProgressData	GetSinkProgress (ClientContext &context, GlobalSinkState &gstate, const ProgressData source_progress) const
	Returns the current progress percentage, or a negative value if progress bars are not supported.

virtual InsertionOrderPreservingMap< string >	ExtraSourceParams (GlobalSourceState &gstate, LocalSourceState &lstate) const

virtual SinkResultType	Sink (ExecutionContext &context, DataChunk &chunk, OperatorSinkInput &input) const

virtual SinkCombineResultType	Combine (ExecutionContext &context, OperatorSinkCombineInput &input) const

virtual void	PrepareFinalize (ClientContext &context, GlobalSinkState &sink_state) const

virtual SinkFinalizeType	Finalize (Pipeline &pipeline, Event &event, ClientContext &context, OperatorSinkFinalizeInput &input) const

virtual SinkNextBatchType	NextBatch (ExecutionContext &context, OperatorSinkNextBatchInput &input) const

virtual unique_ptr< LocalSinkState >	GetLocalSinkState (ExecutionContext &context) const

virtual unique_ptr< GlobalSinkState >	GetGlobalSinkState (ClientContext &context) const

virtual bool	IsSink () const

virtual bool	ParallelSink () const

virtual OperatorPartitionInfo	RequiredPartitionInfo () const

virtual bool	SinkOrderDependent () const

virtual vector< const_reference< PhysicalOperator > >	GetSources () const

bool	AllSourcesSupportBatchIndex () const

virtual void	BuildPipelines (Pipeline &current, MetaPipeline &meta_pipeline)

template<class TARGET >
TARGET &	Cast ()

template<class TARGET >
const TARGET &	Cast () const

Static Public Member Functions
static void	SetEstimatedCardinality (InsertionOrderPreservingMap< string > &result, idx_t estimated_cardinality)

static idx_t	GetMaxThreadMemory (ClientContext &context)
	The maximum amount of memory the operator should use per thread.

static OperatorCachingMode	SelectOperatorCachingMode (ExecutionContext &context)
	Whether operator caching is allowed in the current execution context.

Public Attributes
ArenaLinkedList< reference< PhysicalOperator > >	children
	The child operators.

PhysicalOperatorType	type
	The physical operator type.

vector< LogicalType >	types
	The return types.

idx_t	estimated_cardinality
	The estimated cardinality.

unique_ptr< GlobalSinkState >	sink_state
	The global sink state.

unique_ptr< GlobalOperatorState >	op_state
	The global operator state.

mutex	lock
	Lock for (re)setting any of the operator states.

Static Public Attributes
static constexpr const PhysicalOperatorType	TYPE = PhysicalOperatorType::INVALID

Protected Member Functions
virtual SourceResultType	GetDataInternal (ExecutionContext &context, DataChunk &chunk, OperatorSourceInput &input) const

Detailed Description

PhysicalOperator is the base class of the physical operators present in the execution plan.

Constructor & Destructor Documentation

◆ ~PhysicalOperator()

virtual duckdb::PhysicalOperator::~PhysicalOperator ( )

inlinevirtual

22140 {

22141 }

Member Function Documentation

◆ ParamsToString()

virtual InsertionOrderPreservingMap< string > duckdb::PhysicalOperator::ParamsToString ( ) const

inlinevirtual

                                                                       {
        return InsertionOrderPreservingMap<string>();
    }

◆ GetTypes()

const vector< LogicalType > & duckdb::PhysicalOperator::GetTypes ( ) const

inline

Return a vector of the types that will be returned by this operator.

                                                {
        return types;
    }

◆ Equals()

virtual bool duckdb::PhysicalOperator::Equals ( const PhysicalOperator & other ) const

inlinevirtual

                                                             {
        return false;
    }

◆ Execute()

virtual OperatorResultType duckdb::PhysicalOperator::Execute	(	ExecutionContext &	context,
		DataChunk &	input,
		DataChunk &	chunk,
		GlobalOperatorState &	gstate,
		OperatorState &	state
	)		const

virtual

Reimplemented in duckdb::CachingPhysicalOperator.

◆ FinalExecute()

virtual OperatorFinalizeResultType duckdb::PhysicalOperator::FinalExecute	(	ExecutionContext &	context,
		DataChunk &	chunk,
		GlobalOperatorState &	gstate,
		OperatorState &	state
	)		const

virtual

Reimplemented in duckdb::CachingPhysicalOperator.

◆ ParallelOperator()

virtual bool duckdb::PhysicalOperator::ParallelOperator ( ) const

inlinevirtual

                                          {
        return false;
    }

◆ RequiresFinalExecute()

virtual bool duckdb::PhysicalOperator::RequiresFinalExecute ( ) const

inlinevirtual

                                              {
        return false;
    }

◆ RequiresOperatorFinalize()

virtual bool duckdb::PhysicalOperator::RequiresOperatorFinalize ( ) const

inlinevirtual

                                                  {
        return false;
    }

◆ OperatorOrder()

virtual OrderPreservationType duckdb::PhysicalOperator::OperatorOrder ( ) const

inlinevirtual

The influence the operator has on order (insertion order means no influence)

                                                        {
        return OrderPreservationType::INSERTION_ORDER;
    }

◆ IsSource()

virtual bool duckdb::PhysicalOperator::IsSource ( ) const

inlinevirtual

                                  {
        return false;
    }

◆ ParallelSource()

virtual bool duckdb::PhysicalOperator::ParallelSource ( ) const

inlinevirtual

                                        {
        return false;
    }

◆ SupportsPartitioning()

virtual bool duckdb::PhysicalOperator::SupportsPartitioning ( const OperatorPartitionInfo & partition_info ) const

inlinevirtual

                                                                                         {
        if (partition_info.AnyRequired()) {
            return false;
        }
        return true;
    }

◆ SourceOrder()

virtual OrderPreservationType duckdb::PhysicalOperator::SourceOrder ( ) const

inlinevirtual

The type of order emitted by the operator (as a source)

                                                      {
        return OrderPreservationType::INSERTION_ORDER;
    }

◆ GetSinkProgress()

virtual ProgressData duckdb::PhysicalOperator::GetSinkProgress	(	ClientContext &	context,
		GlobalSinkState &	gstate,
		const ProgressData	source_progress
	)		const

inlinevirtual

Returns the current progress percentage, or a negative value if progress bars are not supported.

                                                                                   {
        return source_progress;
    }

◆ ExtraSourceParams()

virtual InsertionOrderPreservingMap< string > duckdb::PhysicalOperator::ExtraSourceParams	(	GlobalSourceState &	gstate,
		LocalSourceState &	lstate
	)		const

inlinevirtual

                                                                                                  {
        return InsertionOrderPreservingMap<string>();
    }

◆ Sink()

virtual SinkResultType duckdb::PhysicalOperator::Sink	(	ExecutionContext &	context,
		DataChunk &	chunk,
		OperatorSinkInput &	input
	)		const

virtual

The sink method is called constantly with new input, as long as new input is available. Note that this method CAN be called in parallel, proper locking is needed when accessing dat a inside the GlobalSinkState.

Reimplemented in duckdb::PhysicalBatchCollector, and duckdb::PhysicalArrowCollector.

◆ Combine()

virtual SinkCombineResultType duckdb::PhysicalOperator::Combine	(	ExecutionContext &	context,
		OperatorSinkCombineInput &	input
	)		const

virtual

The combine is called when a single thread has completed execution of its part of the pipeline, it is the final time that a specific LocalSinkState is accessible. This method can be called in parallel while other Sink() or Combine() calls are active on the same GlobalSinkState.

Reimplemented in duckdb::PhysicalBatchCollector, and duckdb::PhysicalArrowCollector.

◆ PrepareFinalize()

virtual void duckdb::PhysicalOperator::PrepareFinalize	(	ClientContext &	context,
		GlobalSinkState &	sink_state
	)		const

virtual

(optional) function that will be called before Finalize For now, its only use is to to communicate memory usage in multi-join pipelines through TemporaryMemoryManager

◆ Finalize()

virtual SinkFinalizeType duckdb::PhysicalOperator::Finalize	(	Pipeline &	pipeline,
		Event &	event,
		ClientContext &	context,
		OperatorSinkFinalizeInput &	input
	)		const

virtual

The finalize is called when ALL threads are finished execution. It is called only once per pipeline, and is entirely single threaded. If Finalize returns SinkResultType::Finished, the sink is marked as finished

Reimplemented in duckdb::PhysicalBatchCollector, duckdb::PhysicalArrowBatchCollector, and duckdb::PhysicalArrowCollector.

◆ NextBatch()

virtual SinkNextBatchType duckdb::PhysicalOperator::NextBatch	(	ExecutionContext &	context,
		OperatorSinkNextBatchInput &	input
	)		const

virtual

For sinks with RequiresBatchIndex set to true, when a new batch starts being processed this method is called This allows flushing of the current batch (e.g. to disk)

◆ IsSink()

virtual bool duckdb::PhysicalOperator::IsSink ( ) const

inlinevirtual

                                {
        return false;
    }

◆ ParallelSink()

virtual bool duckdb::PhysicalOperator::ParallelSink ( ) const

inlinevirtual

                                      {
        return false;
    }

◆ RequiredPartitionInfo()

virtual OperatorPartitionInfo duckdb::PhysicalOperator::RequiredPartitionInfo ( ) const

inlinevirtual

                                                                {
        return OperatorPartitionInfo::NoPartitionInfo();
    }

◆ SinkOrderDependent()

virtual bool duckdb::PhysicalOperator::SinkOrderDependent ( ) const

inlinevirtual

Whether or not the sink operator depends on the order of the input chunks If this is set to true, we cannot do things like caching intermediate vectors

Reimplemented in duckdb::PhysicalArrowCollector.

                                            {
        return false;
    }

◆ Cast() [1/2]

template<class TARGET >

TARGET & duckdb::PhysicalOperator::Cast ( )

inline

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

◆ Cast() [2/2]

template<class TARGET >

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

inline

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

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

external/duckdb/duckdb.hpp

Public Member Functions

Static Public Member Functions

Public Attributes

Static Public Attributes

Protected Member Functions

Detailed Description

Constructor & Destructor Documentation

◆ ~PhysicalOperator()

Member Function Documentation

◆ ParamsToString()

◆ GetTypes()

◆ Equals()

◆ Execute()

◆ FinalExecute()

◆ ParallelOperator()

◆ RequiresFinalExecute()

◆ RequiresOperatorFinalize()

◆ OperatorOrder()

◆ IsSource()

◆ ParallelSource()

◆ SupportsPartitioning()

◆ SourceOrder()

◆ GetSinkProgress()

◆ ExtraSourceParams()

◆ Sink()

◆ Combine()

◆ PrepareFinalize()

◆ Finalize()

◆ NextBatch()

◆ IsSink()

◆ ParallelSink()

◆ RequiredPartitionInfo()

◆ SinkOrderDependent()

◆ Cast() [1/2]

◆ Cast() [2/2]