duckdb::FunctionExpression Class Reference

Represents a function call. More...

Inheritance diagram for duckdb::FunctionExpression:

Collaboration diagram for duckdb::FunctionExpression:

Public Member Functions
DUCKDB_API	FunctionExpression (string catalog_name, string schema_name, const string &function_name, vector< unique_ptr< ParsedExpression > > children, unique_ptr< ParsedExpression > filter=nullptr, unique_ptr< OrderModifier > order_bys=nullptr, bool distinct=false, bool is_operator=false, bool export_state=false)
DUCKDB_API	FunctionExpression (const string &function_name, vector< unique_ptr< ParsedExpression > > children, unique_ptr< ParsedExpression > filter=nullptr, unique_ptr< OrderModifier > order_bys=nullptr, bool distinct=false, bool is_operator=false, bool export_state=false)
string	ToString () const override
	Convert the Expression to a String.
unique_ptr< ParsedExpression >	Copy () const override
	Create a copy of this expression.
hash_t	Hash () const override
void	Serialize (Serializer &serializer) const override
void	Verify () const override
optional_ptr< ParsedExpression >	IsLambdaFunction () const
	Returns a pointer to the lambda expression, if the function has a lambda expression as a child, else nullptr.
Public Member Functions inherited from duckdb::ParsedExpression
	ParsedExpression (ExpressionType type, ExpressionClass expression_class)
	Create an Expression.
bool	IsAggregate () const override
	Returns true if this expression is an aggregate or not.
bool	IsWindow () const override
	Returns true if the expression has a window function or not.
bool	HasSubquery () const override
	Returns true if the query contains a subquery.
bool	IsScalar () const override
	Returns true if expression does not contain a group ref or col ref or parameter.
bool	HasParameter () const override
	Returns true if the expression has a parameter.
bool	Equals (const BaseExpression &other) const override
	Returns true if this expression is equal to another expression.
hash_t	Hash () const override
Public Member Functions inherited from duckdb::BaseExpression
	BaseExpression (ExpressionType type, ExpressionClass expression_class)
	Create an Expression.
ExpressionClass	GetExpressionClass () const
	Returns the class of the expression.
ExpressionType	GetExpressionType () const
	Returns the type of the expression.
void	SetExpressionTypeUnsafe (ExpressionType new_type)
optional_idx	GetQueryLocation () const
	Returns the location in the query (if any)
void	SetQueryLocation (optional_idx location)
	Sets the location in the query.
bool	HasAlias () const
	Returns true if the expression has a non-empty alias.
const string &	GetAlias () const
	Returns the alias of the expression.
void	SetAlias (const string &alias_p)
	Sets the alias of the expression.
void	SetAlias (string &&alias_p)
	Sets the alias of the expression.
void	ClearAlias ()
	Clears the alias of the expression.
virtual string	GetName () const
	Get the name of the expression.
void	Print () const
	Print the expression to stdout.
bool	operator== (const BaseExpression &rhs) const
template<class TARGET >
TARGET &	Cast ()
template<class TARGET >
const TARGET &	Cast () const

Static Public Member Functions
static bool	Equal (const FunctionExpression &a, const FunctionExpression &b)
static unique_ptr< ParsedExpression >	Deserialize (Deserializer &deserializer)
template<class T , class BASE , class ORDER_MODIFIER = OrderModifier>
static string	ToString (const T &entry, const string &catalog, const string &schema, const string &function_name, bool is_operator=false, bool distinct=false, BASE *filter=nullptr, ORDER_MODIFIER *order_bys=nullptr, bool export_state=false, bool add_alias=false)
Static Public Member Functions inherited from duckdb::ParsedExpression
static unique_ptr< ParsedExpression >	Deserialize (Deserializer &deserializer)
static bool	Equals (const unique_ptr< ParsedExpression > &left, const unique_ptr< ParsedExpression > &right)
static bool	ListEquals (const vector< unique_ptr< ParsedExpression > > &left, const vector< unique_ptr< ParsedExpression > > &right)
Static Public Member Functions inherited from duckdb::BaseExpression
static bool	Equals (const BaseExpression &left, const BaseExpression &right)

Public Attributes
string	catalog
	Catalog of the function.
string	schema
	Schema of the function.
string	function_name
	Function name.
bool	is_operator
	Whether or not the function is an operator, only used for rendering.
vector< unique_ptr< ParsedExpression > >	children
	List of arguments to the function.
bool	distinct
	Whether or not the aggregate function is distinct, only used for aggregates.
unique_ptr< ParsedExpression >	filter
	Expression representing a filter, only used for aggregates.
unique_ptr< OrderModifier >	order_bys
	Modifier representing an ORDER BY, only used for aggregates.
bool	export_state
	whether this function should export its state or not
Public Attributes inherited from duckdb::BaseExpression
ExpressionType	type
	Type of the expression.
ExpressionClass	expression_class
	The expression class of the node.
string	alias
	The alias of the expression,.
optional_idx	query_location
	The location in the query (if any)

Static Public Attributes
static constexpr const ExpressionClass	TYPE = ExpressionClass::FUNCTION

Additional Inherited Members
Protected Member Functions inherited from duckdb::ParsedExpression
void	CopyProperties (const ParsedExpression &other)

Detailed Description

Represents a function call.

Member Function Documentation

ToString() [1/2]

string duckdb::FunctionExpression::ToString ( ) const

overridevirtual

Convert the Expression to a String.

Implements duckdb::BaseExpression.

Copy()

unique_ptr< ParsedExpression > duckdb::FunctionExpression::Copy ( ) const

overridevirtual

Create a copy of this expression.

Implements duckdb::ParsedExpression.

Hash()

hash_t duckdb::FunctionExpression::Hash ( ) const

overridevirtual

Creates a hash value of this expression. It is important that if two expressions are identical (i.e. Expression::Equals() returns true), that their hash value is identical as well.

Implements duckdb::BaseExpression.

Serialize()

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

overridevirtual

Reimplemented from duckdb::ParsedExpression.

Verify()

void duckdb::FunctionExpression::Verify ( ) const

overridevirtual

Reimplemented from duckdb::BaseExpression.

ToString() [2/2]

template<class T , class BASE , class ORDER_MODIFIER = OrderModifier>

static string duckdb::FunctionExpression::ToString ( const T &  entry, const string &  catalog, const string &  schema, const string &  function_name, bool  is_operator = false, bool  distinct = false, BASE *  filter = nullptr, ORDER_MODIFIER *  order_bys = nullptr, bool  export_state = false, bool  add_alias = false  )

inlinestatic

                                                                                                                   {
        if (is_operator) {
            // built-in operator
            D_ASSERT(!distinct);
            if (entry.children.size() == 1) {
                if (StringUtil::Contains(function_name, "__postfix")) {
                    return "((" + entry.children[0]->ToString() + ")" +
                           StringUtil::Replace(function_name, "__postfix", "") + ")";
                } else {
                    return function_name + "(" + entry.children[0]->ToString() + ")";
                }
            } else if (entry.children.size() == 2) {
                return StringUtil::Format("(%s %s %s)", entry.children[0]->ToString(), function_name,
                                          entry.children[1]->ToString());
            }
        }
        // standard function call
        string result;
        if (!catalog.empty()) {
            result += KeywordHelper::WriteOptionallyQuoted(catalog) + ".";
        }
        if (!schema.empty()) {
            result += KeywordHelper::WriteOptionallyQuoted(schema) + ".";
        }
        result += KeywordHelper::WriteOptionallyQuoted(function_name);
        result += "(";
        if (distinct) {
            result += "DISTINCT ";
        }
        result += StringUtil::Join(entry.children, entry.children.size(), ", ", [&](const unique_ptr<BASE> &child) {
            return child->GetAlias().empty() || !add_alias
                       ? child->ToString()
                       : StringUtil::Format("%s := %s", SQLIdentifier(child->GetAlias()), child->ToString());
        });
        // ordered aggregate
        if (order_bys && !order_bys->orders.empty()) {
            if (entry.children.empty()) {
                result += ") WITHIN GROUP (";
            }
            result += " ORDER BY ";
            for (idx_t i = 0; i < order_bys->orders.size(); i++) {
                if (i > 0) {
                    result += ", ";
                }
                result += order_bys->orders[i].ToString();
            }
        }
        result += ")";
 
        // filtered aggregate
        if (filter) {
            result += " FILTER (WHERE " + filter->ToString() + ")";
        }
 
        if (export_state) {
            result += " EXPORT_STATE";
        }
 
        return result;
    }

---

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

• external/duckdb/duckdb.cpp