duckdb::WindowExpression Class Reference

Inheritance diagram for duckdb::WindowExpression:

Collaboration diagram for duckdb::WindowExpression:

Public Member Functions
	WindowExpression (ExpressionType type, string catalog_name, string schema_name, const string &function_name)
bool	IsWindow () const override
	Returns true if the expression has a window function or not.
string	ToString () const override
	Convert the Expression to a String.
bool	HasBoundedParts ()
unique_ptr< ParsedExpression >	Copy () const override
	Create a copy of this expression.
void	Serialize (Serializer &serializer) const override
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	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
virtual void	Verify () const
template<class TARGET >
TARGET &	Cast ()
template<class TARGET >
const TARGET &	Cast () const

Static Public Member Functions
static bool	Equal (const WindowExpression &a, const WindowExpression &b)
static unique_ptr< ParsedExpression >	Deserialize (Deserializer &deserializer)
static const WindowFunctionDefinition *	WindowFunctions ()
static ExpressionType	WindowToExpressionType (string &fun_name)
static string	ToUnits (const WindowBoundary boundary, const WindowBoundary rows, const WindowBoundary range, const WindowBoundary groups)
template<class T , class BASE , class ORDER_NODE >
static string	ToString (const T &entry, const string &schema, const string &function_name)
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 aggregate function.
string	schema
	Schema of the aggregate function.
string	function_name
	Name of the aggregate function.
vector< unique_ptr< ParsedExpression > >	children
	The child expression of the main window function.
vector< unique_ptr< ParsedExpression > >	partitions
	The set of expressions to partition by.
vector< OrderByNode >	orders
	The set of ordering clauses.
unique_ptr< ParsedExpression >	filter_expr
	Expression representing a filter, only used for aggregates.
bool	ignore_nulls = false
	True to ignore NULL values.
bool	distinct = false
	Whether or not the aggregate function is distinct, only used for aggregates.
WindowBoundary	start = WindowBoundary::INVALID
	The window boundaries.
WindowBoundary	end = WindowBoundary::INVALID
WindowExcludeMode	exclude_clause = WindowExcludeMode::NO_OTHER
	The EXCLUDE clause.
unique_ptr< ParsedExpression >	start_expr
unique_ptr< ParsedExpression >	end_expr
unique_ptr< ParsedExpression >	offset_expr
	Offset and default expressions for WINDOW_LEAD and WINDOW_LAG functions.
unique_ptr< ParsedExpression >	default_expr
vector< OrderByNode >	arg_orders
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::WINDOW

Private Member Functions
	WindowExpression (ExpressionType type)

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

Detailed Description

The WindowExpression represents a window function in the query. They are a special case of aggregates which is why they inherit from them.

Member Function Documentation

IsWindow()

bool duckdb::WindowExpression::IsWindow ( ) const

inlineoverridevirtual

Returns true if the expression has a window function or not.

Reimplemented from duckdb::ParsedExpression.

                                   {
        return true;
    }

ToString() [1/2]

string duckdb::WindowExpression::ToString ( ) const

overridevirtual

Convert the Expression to a String.

Implements duckdb::BaseExpression.

Copy()

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

overridevirtual

Create a copy of this expression.

Implements duckdb::ParsedExpression.

Serialize()

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

overridevirtual

Reimplemented from duckdb::ParsedExpression.

ToUnits()

static string duckdb::WindowExpression::ToUnits ( const WindowBoundary  boundary, const WindowBoundary  rows, const WindowBoundary  range, const WindowBoundary  groups  )

inlinestatic

                                                              {
        if (boundary == rows) {
            return "ROWS";
        } else if (boundary == range) {
            return "RANGE";
        } else {
            return "GROUPS";
        }
    }

ToString() [2/2]

template<class T , class BASE , class ORDER_NODE >

static string duckdb::WindowExpression::ToString ( const T &  entry, const string &  schema, const string &  function_name  )

inlinestatic

                                                                                              {
        // Start with function call
        string result = schema.empty() ? function_name : schema + "." + function_name;
        result += "(";
        if (entry.children.size()) {
            //  Only one DISTINCT is allowed (on the first argument)
            int distincts = entry.distinct ? 0 : 1;
            result += StringUtil::Join(entry.children, entry.children.size(), ", ", [&](const unique_ptr<BASE> &child) {
                return (distincts++ ? "" : "DISTINCT ") + child->ToString();
            });
        }
        // Lead/Lag extra arguments
        if (entry.offset_expr.get()) {
            result += ", ";
            result += entry.offset_expr->ToString();
        }
        if (entry.default_expr.get()) {
            result += ", ";
            result += entry.default_expr->ToString();
        }
        // ORDER BY arguments
        if (!entry.arg_orders.empty()) {
            result += " ORDER BY ";
            result += StringUtil::Join(entry.arg_orders, entry.arg_orders.size(), ", ",
                                       [](const ORDER_NODE &order) { return order.ToString(); });
        }
 
        // IGNORE NULLS
        if (entry.ignore_nulls) {
            result += " IGNORE NULLS";
        }
        // FILTER
        if (entry.filter_expr) {
            result += ") FILTER (WHERE " + entry.filter_expr->ToString();
        }
 
        // Over clause
        result += ") OVER (";
        string sep;
 
        // Partitions
        if (!entry.partitions.empty()) {
            result += "PARTITION BY ";
            result += StringUtil::Join(entry.partitions, entry.partitions.size(), ", ",
                                       [](const unique_ptr<BASE> &partition) { return partition->ToString(); });
            sep = " ";
        }
 
        // Orders
        if (!entry.orders.empty()) {
            result += sep;
            result += "ORDER BY ";
            result += StringUtil::Join(entry.orders, entry.orders.size(), ", ",
                                       [](const ORDER_NODE &order) { return order.ToString(); });
            sep = " ";
        }
 
        // Rows/Range
        string units = "ROWS";
        string from;
        switch (entry.start) {
        case WindowBoundary::CURRENT_ROW_RANGE:
        case WindowBoundary::CURRENT_ROW_ROWS:
        case WindowBoundary::CURRENT_ROW_GROUPS:
            from = "CURRENT ROW";
            units = ToUnits(entry.start, WindowBoundary::CURRENT_ROW_ROWS, WindowBoundary::CURRENT_ROW_RANGE,
                            WindowBoundary::CURRENT_ROW_GROUPS);
            break;
        case WindowBoundary::UNBOUNDED_PRECEDING:
            if (entry.end != WindowBoundary::CURRENT_ROW_RANGE) {
                from = "UNBOUNDED PRECEDING";
            }
            break;
        case WindowBoundary::EXPR_PRECEDING_ROWS:
        case WindowBoundary::EXPR_PRECEDING_RANGE:
        case WindowBoundary::EXPR_PRECEDING_GROUPS:
            from = entry.start_expr->ToString() + " PRECEDING";
            units = ToUnits(entry.start, WindowBoundary::EXPR_PRECEDING_ROWS, WindowBoundary::EXPR_PRECEDING_RANGE,
                            WindowBoundary::EXPR_PRECEDING_GROUPS);
            break;
        case WindowBoundary::EXPR_FOLLOWING_ROWS:
        case WindowBoundary::EXPR_FOLLOWING_RANGE:
        case WindowBoundary::EXPR_FOLLOWING_GROUPS:
            from = entry.start_expr->ToString() + " FOLLOWING";
            units = ToUnits(entry.start, WindowBoundary::EXPR_FOLLOWING_ROWS, WindowBoundary::EXPR_FOLLOWING_RANGE,
                            WindowBoundary::EXPR_FOLLOWING_GROUPS);
            break;
        case WindowBoundary::UNBOUNDED_FOLLOWING:
        case WindowBoundary::INVALID:
            throw InternalException("Unrecognized FROM in WindowExpression");
        }
 
        string to;
        switch (entry.end) {
        case WindowBoundary::CURRENT_ROW_RANGE:
            if (entry.start != WindowBoundary::UNBOUNDED_PRECEDING) {
                to = "CURRENT ROW";
                units = "RANGE";
            }
            break;
        case WindowBoundary::CURRENT_ROW_ROWS:
        case WindowBoundary::CURRENT_ROW_GROUPS:
            to = "CURRENT ROW";
            units = ToUnits(entry.end, WindowBoundary::CURRENT_ROW_ROWS, WindowBoundary::CURRENT_ROW_RANGE,
                            WindowBoundary::CURRENT_ROW_GROUPS);
            break;
        case WindowBoundary::UNBOUNDED_PRECEDING:
            to = "UNBOUNDED PRECEDING";
            break;
        case WindowBoundary::UNBOUNDED_FOLLOWING:
            to = "UNBOUNDED FOLLOWING";
            break;
        case WindowBoundary::EXPR_PRECEDING_ROWS:
        case WindowBoundary::EXPR_PRECEDING_RANGE:
        case WindowBoundary::EXPR_PRECEDING_GROUPS:
            to = entry.end_expr->ToString() + " PRECEDING";
            units = ToUnits(entry.end, WindowBoundary::EXPR_PRECEDING_ROWS, WindowBoundary::EXPR_PRECEDING_RANGE,
                            WindowBoundary::EXPR_PRECEDING_GROUPS);
            break;
        case WindowBoundary::EXPR_FOLLOWING_ROWS:
        case WindowBoundary::EXPR_FOLLOWING_RANGE:
        case WindowBoundary::EXPR_FOLLOWING_GROUPS:
            to = entry.end_expr->ToString() + " FOLLOWING";
            units = ToUnits(entry.end, WindowBoundary::EXPR_FOLLOWING_ROWS, WindowBoundary::EXPR_FOLLOWING_RANGE,
                            WindowBoundary::EXPR_FOLLOWING_GROUPS);
            break;
        case WindowBoundary::INVALID:
            throw InternalException("Unrecognized TO in WindowExpression");
        }
        if (entry.exclude_clause != WindowExcludeMode::NO_OTHER) {
            // if we have an explicit EXCLUDE we always need to fill in from/to
            if (from.empty()) {
                from = "UNBOUNDED PRECEDING";
            }
            if (to.empty()) {
                to = "CURRENT ROW";
                units = "RANGE";
            }
        }
 
        if (!from.empty() || !to.empty()) {
            result += sep + units;
        }
        if (!from.empty() && !to.empty()) {
            result += " BETWEEN ";
            result += from;
            result += " AND ";
            result += to;
        } else if (!from.empty()) {
            result += " ";
            result += from;
        } else if (!to.empty()) {
            result += " ";
            result += to;
        }
 
        if (entry.exclude_clause != WindowExcludeMode::NO_OTHER) {
            result += " EXCLUDE ";
        }
        switch (entry.exclude_clause) {
        case WindowExcludeMode::CURRENT_ROW:
            result += "CURRENT ROW";
            break;
        case WindowExcludeMode::GROUP:
            result += "GROUP";
            break;
        case WindowExcludeMode::TIES:
            result += "TIES";
            break;
        default:
            break;
        }
 
        result += ")";
 
        return result;
    }

Member Data Documentation

arg_orders

vector<OrderByNode> duckdb::WindowExpression::arg_orders

The set of argument ordering clauses These are distinct from the frame ordering clauses e.g., the "x" in FIRST_VALUE(a ORDER BY x) OVER (PARTITION BY p ORDER BY s)

---

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

• external/duckdb/duckdb.cpp