ORDER Struct Reference

#include <table.h>

Inheritance diagram for ORDER:

Public Member Functions
bool	is_item_original () const

Public Attributes
ORDER *	next {nullptr}
Item *	item_initial {nullptr}
	The initial ordering expression. More...
Item **	item {&item_initial}
	Points at the item in the select fields. More...
Item_rollup_group_item *	rollup_item {nullptr}
enum_order	direction
bool	in_field_list {false}
bool	used_alias {false}
	Tells whether this ORDER element was referenced with an alias or with an expression, in the query: SELECT a AS foo GROUP BY foo: true. More...
Field *	field_in_tmp_table {nullptr}
	When GROUP BY is implemented with a temporary table (i.e. More...
char *	buff {nullptr}
table_map	used {0}
table_map	depend_map {0}
bool	is_explicit {false}

Member Function Documentation

is_item_original()

bool ORDER::is_item_original ( ) const

inline

Returns

true if item pointer is same as original

Member Data Documentation

buff

char* ORDER::buff {nullptr}

depend_map

table_map ORDER::depend_map {0}

direction

enum_order ORDER::direction

Initial value:

{
      ORDER_NOT_RELEVANT}

field_in_tmp_table

Field* ORDER::field_in_tmp_table {nullptr}

When GROUP BY is implemented with a temporary table (i.e.

the table takes care to store only unique group rows, table->group != nullptr), each GROUP BY expression is stored in a column of the table, which is 'field_in_tmp_table'. Such field may point into table->record[0] (if we only use it to get its value from a tmp table's row), or into 'buff' (if we use it to do index lookup into the tmp table).

in_field_list

bool ORDER::in_field_list {false}

is_explicit

bool ORDER::is_explicit {false}

item

Item** ORDER::item {&item_initial}

Points at the item in the select fields.

Note that this means that after resolving, it points into a slice (see JOIN::ref_items), even though the item is not of type Item_ref!

item_initial

Item* ORDER::item_initial {nullptr}

The initial ordering expression.

Usually substituted during resolving and must not be used during optimization and execution.

next

ORDER* ORDER::next {nullptr}

rollup_item

Item_rollup_group_item* ORDER::rollup_item {nullptr}

used

table_map ORDER::used {0}

used_alias

bool ORDER::used_alias {false}

Tells whether this ORDER element was referenced with an alias or with an expression, in the query: SELECT a AS foo GROUP BY foo: true.

SELECT a AS foo GROUP BY a: false.

---

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

• sql/table.h