Inheritance diagram for duckdb::ExpressionBinder:

[legend]

Collaboration diagram for duckdb::ExpressionBinder:

[legend]

Public Member Functions
	ExpressionBinder (Binder &binder, ClientContext &context, bool replace_binder=false)

virtual bool	TryResolveAliasReference (ColumnRefExpression &colref, idx_t depth, bool root_expression, BindResult &result, unique_ptr< ParsedExpression > &expr_ptr)

virtual bool	DoesColumnAliasExist (const ColumnRefExpression &colref)

unique_ptr< Expression >	Bind (unique_ptr< ParsedExpression > &expr, optional_ptr< LogicalType > result_type=nullptr, bool root_expression=true)

bool	HasBoundColumns ()
	Returns whether or not any columns have been bound by the expression binder.

const vector< BoundColumnReferenceInfo > &	GetBoundColumns ()

void	SetCatalogLookupCallback (catalog_entry_callback_t callback)

ErrorData	Bind (unique_ptr< ParsedExpression > &expr, idx_t depth, bool root_expression=false)

unique_ptr< ParsedExpression >	CreateStructExtract (unique_ptr< ParsedExpression > base, const string &field_name)
	Returns the STRUCT_EXTRACT operator expression.

unique_ptr< ParsedExpression >	CreateStructPack (ColumnRefExpression &col_ref)
	Returns a STRUCT_PACK function expression.

BindResult	BindQualifiedColumnName (ColumnRefExpression &colref, const string &table_name)

unique_ptr< ParsedExpression >	QualifyColumnName (const ParsedExpression &expr, const string &column_name, ErrorData &error)
	Returns a qualified column reference from a column name.

unique_ptr< ParsedExpression >	QualifyColumnNameWithManyDots (ColumnRefExpression &col_ref, ErrorData &error)
	Returns a qualified column reference from a column reference with column_names.size() > 2.

virtual unique_ptr< ParsedExpression >	QualifyColumnName (ColumnRefExpression &col_ref, ErrorData &error)
	Returns a qualified column reference from a column reference.

void	QualifyColumnNamesInLambda (FunctionExpression &function, vector< unordered_set< string > > &lambda_params)
	Enables special-handling of lambda parameters by tracking them in the lambda_params vector.

void	QualifyColumnNames (unique_ptr< ParsedExpression > &expr, vector< unordered_set< string > > &lambda_params, const bool within_function_expression=false)

BindResult	BindCorrelatedColumns (unique_ptr< ParsedExpression > &expr, ErrorData error_message)

void	BindChild (unique_ptr< ParsedExpression > &expr, idx_t depth, ErrorData &error)

virtual BindResult	BindExpression (unique_ptr< ParsedExpression > &expr_ptr, idx_t depth, bool root_expression=false)

void	ReplaceMacroParameters (unique_ptr< ParsedExpression > &expr, vector< unordered_set< string > > &lambda_params)

void	ReplaceMacroParametersInLambda (FunctionExpression &function, vector< unordered_set< string > > &lambda_params)

Static Public Member Functions
static bool	IsPotentialAlias (const ColumnRefExpression &colref)

static void	QualifyColumnNames (Binder &binder, unique_ptr< ParsedExpression > &expr)
	Entry point for qualifying the column references of the expression.

static void	QualifyColumnNames (ExpressionBinder &binder, unique_ptr< ParsedExpression > &expr)

static bool	PushCollation (ClientContext &context, unique_ptr< Expression > &source, const LogicalType &sql_type, CollationType type=CollationType::ALL_COLLATIONS)

static void	TestCollation (ClientContext &context, const string &collation)

static void	ExtractCorrelatedExpressions (Binder &binder, Expression &expr)

static bool	ContainsNullType (const LogicalType &type)

static LogicalType	ExchangeNullType (const LogicalType &type)

static bool	ContainsType (const LogicalType &type, LogicalTypeId target)

static LogicalType	ExchangeType (const LogicalType &type, LogicalTypeId target, LogicalType new_type)

static LogicalType	GetExpressionReturnType (const Expression &expr)

static bool	IsUnnestFunction (const string &function_name)
	Returns true if the function name is an alias for the UNNEST function.

Public Attributes
LogicalType	target_type

optional_ptr< DummyBinding >	macro_binding

optional_ptr< vector< DummyBinding > >	lambda_bindings

Protected Member Functions
BindResult	BindExpression (BetweenExpression &expr, idx_t depth)

BindResult	BindExpression (CaseExpression &expr, idx_t depth)

BindResult	BindExpression (CollateExpression &expr, idx_t depth)

BindResult	BindExpression (CastExpression &expr, idx_t depth)

BindResult	BindExpression (ColumnRefExpression &expr, idx_t depth, bool root_expression, unique_ptr< ParsedExpression > &expr_ptr)

BindResult	BindExpression (LambdaRefExpression &expr, idx_t depth)

BindResult	BindExpression (ComparisonExpression &expr, idx_t depth)

BindResult	BindExpression (ConjunctionExpression &expr, idx_t depth)

BindResult	BindExpression (ConstantExpression &expr, idx_t depth)

BindResult	BindExpression (FunctionExpression &expr, idx_t depth, unique_ptr< ParsedExpression > &expr_ptr)

BindResult	BindExpression (TypeExpression &expr, idx_t depth)

BindResult	BindExpression (LambdaExpression &expr, idx_t depth, const vector< LogicalType > &function_child_types, optional_ptr< bind_lambda_function_t > bind_lambda_function)

BindResult	BindExpression (OperatorExpression &expr, idx_t depth)

BindResult	BindExpression (ParameterExpression &expr, idx_t depth)

BindResult	BindExpression (SubqueryExpression &expr, idx_t depth)

BindResult	BindPositionalReference (unique_ptr< ParsedExpression > &expr, idx_t depth, bool root_expression)

void	TransformCapturedLambdaColumn (unique_ptr< Expression > &original, unique_ptr< Expression > &replacement, BoundLambdaExpression &bound_lambda_expr, const optional_ptr< bind_lambda_function_t > bind_lambda_function, const vector< LogicalType > &function_child_types)

void	CaptureLambdaColumns (BoundLambdaExpression &bound_lambda_expr, unique_ptr< Expression > &expr, const optional_ptr< bind_lambda_function_t > bind_lambda_function, const vector< LogicalType > &function_child_types)

virtual unique_ptr< ParsedExpression >	GetSQLValueFunction (const string &column_name)

LogicalType	ResolveOperatorType (OperatorExpression &op, vector< unique_ptr< Expression > > &children)

LogicalType	ResolveCoalesceType (OperatorExpression &op, vector< unique_ptr< Expression > > &children)

LogicalType	ResolveNotType (OperatorExpression &op, vector< unique_ptr< Expression > > &children)

BindResult	BindUnsupportedExpression (ParsedExpression &expr, idx_t depth, const string &message)

optional_ptr< CatalogEntry >	BindAndQualifyFunction (FunctionExpression &function, bool allow_throw)

virtual BindResult	BindGroupingFunction (OperatorExpression &op, idx_t depth)

virtual BindResult	BindFunction (FunctionExpression &expr, ScalarFunctionCatalogEntry &function, idx_t depth)

virtual BindResult	BindLambdaFunction (FunctionExpression &expr, ScalarFunctionCatalogEntry &function, idx_t depth)

virtual BindResult	BindAggregate (FunctionExpression &expr, AggregateFunctionCatalogEntry &function, idx_t depth)

virtual BindResult	BindUnnest (FunctionExpression &expr, idx_t depth, bool root_expression)

virtual BindResult	BindMacro (FunctionExpression &expr, ScalarMacroCatalogEntry &macro, idx_t depth, unique_ptr< ParsedExpression > &expr_ptr)

void	UnfoldMacroExpression (FunctionExpression &function, ScalarMacroCatalogEntry &macro_func, unique_ptr< ParsedExpression > &expr, idx_t depth)

virtual string	UnsupportedAggregateMessage ()

virtual string	UnsupportedUnnestMessage ()

optional_ptr< CatalogEntry >	GetCatalogEntry (const string &catalog, const string &schema, const EntryLookupInfo &lookup_info, OnEntryNotFound on_entry_not_found)

BindResult	TryBindLambdaOrJson (FunctionExpression &function, idx_t depth, CatalogEntry &func, const LambdaSyntaxType syntax_type)

unique_ptr< ParsedExpression >	QualifyColumnNameWithManyDotsInternal (ColumnRefExpression &col_ref, ErrorData &error, idx_t &struct_extract_start)

virtual void	ThrowIfUnnestInLambda (const ColumnBinding &column_binding)

Protected Attributes
Binder &	binder

ClientContext &	context

optional_ptr< ExpressionBinder >	stored_binder

vector< BoundColumnReferenceInfo >	bound_columns

Private Member Functions
void	InitializeStackCheck ()

StackChecker< ExpressionBinder >	StackCheck (const ParsedExpression &expr, idx_t extra_stack=1)

Private Attributes
idx_t	stack_depth = DConstants::INVALID_INDEX
	Current stack depth.

Friends
class	StackChecker< ExpressionBinder >

Member Function Documentation

◆ TryResolveAliasReference()

virtual bool duckdb::ExpressionBinder::TryResolveAliasReference	(	ColumnRefExpression &	colref,
		idx_t	depth,
		bool	root_expression,
		BindResult &	result,
		unique_ptr< ParsedExpression > &	expr_ptr
	)

inlinevirtual

                                                                                                      {
        return false;
    }

◆ DoesColumnAliasExist()

virtual bool duckdb::ExpressionBinder::DoesColumnAliasExist ( const ColumnRefExpression & colref )

inlinevirtual

                                                                         {
        return false;
    }

◆ HasBoundColumns()

bool duckdb::ExpressionBinder::HasBoundColumns ( )

inline

Returns whether or not any columns have been bound by the expression binder.

                           {
        return !bound_columns.empty();
    }

◆ GetBoundColumns()

const vector< BoundColumnReferenceInfo > & duckdb::ExpressionBinder::GetBoundColumns ( )

inline

                                                              {
        return bound_columns;
    }

◆ QualifyColumnNames()

void duckdb::ExpressionBinder::QualifyColumnNames	(	unique_ptr< ParsedExpression > &	expr,
		vector< unordered_set< string > > &	lambda_params,
		const bool	within_function_expression = `false`
	)

Recursively qualifies the column references in the (children) of the expression. Passes on the within_function_expression state from outer expressions, or sets it

◆ BindExpression()

virtual BindResult duckdb::ExpressionBinder::BindExpression	(	unique_ptr< ParsedExpression > &	expr_ptr,
		idx_t	depth,
		bool	root_expression = `false`
	)

virtual

Bind the given expression. Unlike Bind(), this does not mute the given ParsedExpression. Exposed to be used from sub-binders that aren't subclasses of ExpressionBinder.

Reimplemented in duckdb::IndexBinder, and duckdb::AlterBinder.

◆ ReplaceMacroParameters()

void duckdb::ExpressionBinder::ReplaceMacroParameters	(	unique_ptr< ParsedExpression > &	expr,
		vector< unordered_set< string > > &	lambda_params
	)

FIXME: Generalise this for extensibility. Recursively replaces macro parameters with the provided input parameters.

◆ ReplaceMacroParametersInLambda()

void duckdb::ExpressionBinder::ReplaceMacroParametersInLambda	(	FunctionExpression &	function,
		vector< unordered_set< string > > &	lambda_params
	)

Enables special-handling of lambda parameters during macro replacement by tracking them in the lambda_params vector.

Member Data Documentation

◆ target_type

LogicalType duckdb::ExpressionBinder::target_type

The target type that should result from the binder. If the result is not of this type, a cast to this type will be added. Defaults to INVALID.

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

external/duckdb/duckdb.cpp

Public Member Functions

Static Public Member Functions

Public Attributes

Protected Member Functions

Protected Attributes

Private Member Functions

Private Attributes

Friends