public:

/**

OrderingElementsGuard(LogicalOrderings *context, MEM_ROOT *mem_root)

: m_context{context} {

m_elements = context->RetrieveElements(mem_root);

}

// No copying of this class.

OrderingElementsGuard(const OrderingElementsGuard &) = delete;

OrderingElementsGuard &operator=(const OrderingElementsGuard &) = delete;

~OrderingElementsGuard() { m_context->ReturnElements(m_elements); }

Ordering::Elements &Get() { return m_elements; }

private:

/// The object containing the pool.

LogicalOrderings *m_context;

/// The instance fetched from the pool.

Ordering::Elements m_elements;

const Mem_root_array<DFSMState> *dfsm_states;

size_t operator()(int idx) const {

size_t hash = 0;

for (int nfsm_state : (*dfsm_states)[idx].nfsm_states) {

my_hash_combine<size_t>(hash, nfsm_state);

}

return hash;

}

const Mem_root_array<DFSMState> *dfsm_states;

bool operator()(int idx1, int idx2) const {

return equal((*dfsm_states)[idx1].nfsm_states.begin(),

(*dfsm_states)[idx1].nfsm_states.end(),

(*dfsm_states)[idx2].nfsm_states.begin(),

(*dfsm_states)[idx2].nfsm_states.end());

}

assert(Valid());

size_t length = 0;

for (size_t i = 0; i < m_elements.size(); ++i) {

if (!Contains(m_elements.prefix(length), m_elements[i].item)) {

m_elements[length++] = m_elements[i];

}

}

m_elements.resize(length);

switch (m_kind) {

case Kind::kEmpty:

return m_elements.empty();

case Kind::kOrder:

return !m_elements.empty() &&

std::all_of(m_elements.cbegin(), m_elements.cend(),

[](OrderElement e) {

return e.direction != ORDER_NOT_RELEVANT;

});

case Kind::kRollup:

case Kind::kGroup:

return !m_elements.empty() &&

std::all_of(m_elements.cbegin(), m_elements.cend(),

[](OrderElement e) {

return e.direction == ORDER_NOT_RELEVANT;

});

}

assert(false);

return false;

: m_items(thd->mem_root),

m_orderings(thd->mem_root),

m_fds(thd->mem_root),

m_states(thd->mem_root),

m_dfsm_states(thd->mem_root),

m_dfsm_edges(thd->mem_root),

m_elements_pool(thd->mem_root) {

GetHandle(nullptr); // Always has the zero handle.

// Add the empty ordering/grouping.

m_orderings.push_back(OrderingWithInfo{Ordering(),

OrderingWithInfo::UNINTERESTING,

/*used_at_end=*/true});

FunctionalDependency decay_fd;

decay_fd.type = FunctionalDependency::DECAY;

decay_fd.tail = 0;

decay_fd.always_active = true;

m_fds.push_back(decay_fd);

OrderingWithInfo::Type type,

bool used_at_end,

table_map homogenize_tables) {

assert(!m_built);

#ifndef NDEBUG

if (order.GetKind() == Ordering::Kind::kGroup) {

Ordering::Elements elements = order.GetElements();

// Verify that the grouping is sorted and deduplicated.

for (size_t i = 1; i < elements.size(); ++i) {

assert(elements[i].item > elements[i - 1].item);

assert(elements[i].direction == ORDER_NOT_RELEVANT);

}

// Verify that none of the items are of ROW_RESULT,

// as RemoveDuplicatesIterator cannot handle them.

// (They would theoretically be fine for orderings.)

for (size_t i = 0; i < elements.size(); ++i) {

assert(m_items[elements[i].item].item->result_type() != ROW_RESULT);

}

}

#endif

if (type != OrderingWithInfo::UNINTERESTING) {

for (OrderElement element : order.GetElements()) {

if (element.direction == ORDER_ASC) {

m_items[element.item].used_asc = true;

}

if (element.direction == ORDER_DESC) {

m_items[element.item].used_desc = true;

}

if (element.direction == ORDER_NOT_RELEVANT) {

m_items[element.item].used_in_grouping = true;

}

}

}

// Deduplicate against all the existing ones.

for (size_t i = 0; i < m_orderings.size(); ++i) {

if (m_orderings[i].ordering == order) {

// Potentially promote the existing one.

m_orderings[i].type = std::max(m_orderings[i].type, type);

m_orderings[i].homogenize_tables |= homogenize_tables;

return i;

}

}

m_orderings.push_back(OrderingWithInfo{order.Clone(thd->mem_root), type,

used_at_end, homogenize_tables});

m_longest_ordering = std::max<int>(m_longest_ordering, order.size());

return m_orderings.size() - 1;

FunctionalDependency fd) {

assert(!m_built);

// Deduplicate against all the existing ones.

for (size_t i = 0; i < m_fds.size(); ++i) {

if (m_fds[i].type != fd.type) {

continue;

}

if (fd.type == FunctionalDependency::EQUIVALENCE) {

// Equivalences are symmetric.

if (m_fds[i].head[0] == fd.head[0] && m_fds[i].tail == fd.tail) {

return i;

}

if (m_fds[i].tail == fd.head[0] && m_fds[i].head[0] == fd.tail) {

return i;

}

} else {

if (m_fds[i].tail == fd.tail &&

equal(m_fds[i].head.begin(), m_fds[i].head.end(), fd.head.begin(),

fd.head.end())) {

return i;

}

}

}

fd.head = fd.head.Clone(thd->mem_root);

m_fds.push_back(fd);

return m_fds.size() - 1;

// If we have no interesting orderings or groupings, just create a DFSM

// directly with a single state for the empty ordering.

if (m_orderings.size() == 1) {

m_dfsm_states.reserve(1);

m_dfsm_states.emplace_back();

DFSMState &initial = m_dfsm_states.back();

initial.nfsm_states.init(thd->mem_root);

initial.nfsm_states.reserve(1);

initial.nfsm_states.push_back(0);

initial.next_state =

Bounds_checked_array<int>::Alloc(thd->mem_root, m_fds.size());

m_optimized_ordering_mapping =

Bounds_checked_array<int>::Alloc(thd->mem_root, 1);

m_built = true;

return;

}

BuildEquivalenceClasses();

RecanonicalizeGroupings();

AddFDsFromComputedItems(thd);

AddFDsFromConstItems(thd);

AddFDsFromAggregateItems(thd);

PreReduceOrderings(thd);

CreateOrderingsFromGroupings(thd);

CreateHomogenizedOrderings(thd);

PruneFDs(thd);

if (trace != nullptr) {

PrintFunctionalDependencies(trace);

}

FindElementsThatCanBeAddedByFDs();

PruneUninterestingOrders(thd);

if (trace != nullptr) {

PrintInterestingOrders(trace);

}

BuildNFSM(thd);

if (trace != nullptr) {

*trace += "NFSM for interesting orders, before pruning:\n";

PrintNFSMDottyGraph(trace);

if (m_states.size() >= kMaxNFSMStates) {

*trace += "NOTE: NFSM is incomplete, because it became too big.\n";

}

}

PruneNFSM(thd);

if (trace != nullptr) {

*trace += "\nNFSM for interesting orders, after pruning:\n";

PrintNFSMDottyGraph(trace);

}

ConvertNFSMToDFSM(thd);

if (trace != nullptr) {

*trace += "\nDFSM for interesting orders:\n";

PrintDFSMDottyGraph(trace);

if (m_dfsm_states.size() >= kMaxDFSMStates) {

*trace +=

"NOTE: DFSM does not contain all NFSM states, because it became too "

"big.\n";

}

}

FindInitialStatesForOrdering();

m_built = true;

LogicalOrderings::StateIndex state_idx, FunctionalDependencySet fds) const {

for (;;) { // Termination condition within loop.

FunctionalDependencySet relevant_fds =

m_dfsm_states[state_idx].can_use_fd & fds;

if (relevant_fds.none()) {

return state_idx;

}

// Pick an arbitrary one and follow it. Note that this part assumes

// kMaxSupportedFDs <= 64.

static_assert(kMaxSupportedFDs <= sizeof(unsigned long long) * CHAR_BIT);

int fd_idx = FindLowestBitSet(relevant_fds.to_ullong()) + 1;

state_idx = m_dfsm_states[state_idx].next_state[fd_idx];

// Now continue for as long as we have anything to follow;

// we'll converge on the right answer eventually. Typically,

// there will be one or two edges to follow, but in extreme cases,

// there could be O(k²) in the number of FDs.

}

m_optimized_ordering_mapping =

Bounds_checked_array<int>::Alloc(thd->mem_root, m_orderings.size());

int new_length = 0;

for (size_t ordering_idx = 0; ordering_idx < m_orderings.size();

++ordering_idx) {

if (m_orderings[ordering_idx].type == OrderingWithInfo::UNINTERESTING) {

Ordering &ordering = m_orderings[ordering_idx].ordering;

// We are not prepared for uninteresting groupings yet.

assert(ordering.GetKind() != Ordering::Kind::kGroup);

// Find the longest prefix that contains only elements that are used in

// interesting groupings. We will never shorten the uninteresting ordering

// below this; it is overconservative in some cases, but it makes sure

// we never miss a path to an interesting grouping.

size_t minimum_prefix_len = 0;

const Ordering::Elements &elements = ordering.GetElements();

while (elements.size() > minimum_prefix_len &&

m_items[m_items[elements[minimum_prefix_len].item].canonical_item]

.used_in_grouping) {

++minimum_prefix_len;

}

// Shorten this ordering one by one element, until it can (heuristically)

// become an interesting ordering with the FDs we have. Note that it might

// become the empty ordering, and if so, it will be deleted entirely

// in the step below.

while (elements.size() > minimum_prefix_len &&

!CouldBecomeInterestingOrdering(ordering)) {

if (elements.size() > 1) {

ordering = Ordering(elements.without_back(), ordering.GetKind());

} else {

ordering = Ordering();

}

}

}

// Since some orderings may have changed, we need to re-deduplicate.

// Note that at this point, we no longer care about used_at_end;

// it was only used for reducing orderings in homogenization.

m_optimized_ordering_mapping[ordering_idx] = new_length;

for (int i = 0; i < new_length; ++i) {

if (m_orderings[i].ordering == m_orderings[ordering_idx].ordering) {

m_optimized_ordering_mapping[ordering_idx] = i;

m_orderings[i].type =

std::max(m_orderings[i].type, m_orderings[ordering_idx].type);

break;

}

}

if (m_optimized_ordering_mapping[ordering_idx] == new_length) {

// Not a duplicate of anything earlier, so keep it.

m_orderings[new_length++] = m_orderings[ordering_idx];

}

}

m_orderings.resize(new_length);

// The definition of prunable FDs in the papers seems to be very abstract

// and not practically realizable, so we use a simple heuristic instead:

// A FD is useful iff it produces an item that is part of some ordering.

// Discard all useless FDs. (Items not part of some ordering will cause

// the new proposed ordering to immediately be pruned away, so this is

// safe. See also the comment in the .h file about transitive dependencies.)

//

// Note that this will sometimes leave useless FDs; if we have e.g. a → b

// and b is useful, we will mark the FD as useful even if nothing can

// produce a. However, such FDs don't induce more NFSM states (which is

// the main point of the pruning), it just slows the NFSM down slightly,

// and by far the dominant FDs to prune in our cases are the ones

// induced by keys, e.g. S → k where S is always the same and k

// is useless. These are caught by this heuristic.

m_optimized_fd_mapping =

Bounds_checked_array<int>::Alloc(thd->mem_root, m_fds.size());

size_t old_length = m_fds.size();

// We always need to keep the decay FD, so start at 1.

m_optimized_fd_mapping[0] = 0;

int new_length = 1;

for (size_t fd_idx = 1; fd_idx < old_length; ++fd_idx) {

const FunctionalDependency &fd = m_fds[fd_idx];

// See if we this FDs is useful, ie., can produce an item used in an

// ordering.

bool used_fd = false;

ItemHandle tail = m_items[fd.tail].canonical_item;

if (m_items[tail].used_asc || m_items[tail].used_desc ||

m_items[tail].used_in_grouping) {

used_fd = true;

} else if (fd.type == FunctionalDependency::EQUIVALENCE) {

ItemHandle head = m_items[fd.head[0]].canonical_item;

if (m_items[head].used_asc || m_items[head].used_desc ||

m_items[head].used_in_grouping) {

used_fd = true;

}

}

if (!used_fd) {

m_optimized_fd_mapping[fd_idx] = -1;

continue;

}

if (m_fds[fd_idx].always_active) {

// Defer these for now, by moving them to the end. We will need to keep

// them in the array so that we can apply them under FSM construction,

// but they should not get a FD bitmap, and thus also not priority for

// the lowest index. We could have used a separate array, but the m_fds

// array probably already has the memory.

m_optimized_fd_mapping[fd_idx] = -1;

m_fds.push_back(m_fds[fd_idx]);

} else {

m_optimized_fd_mapping[fd_idx] = new_length;

m_fds[new_length++] = m_fds[fd_idx];

}

}

// Now include the always-on FDs we deferred earlier.

for (size_t fd_idx = old_length; fd_idx < m_fds.size(); ++fd_idx) {

m_fds[new_length++] = m_fds[fd_idx];

}

m_fds.resize(new_length);

for (size_t i = 0; i < m_items.size(); ++i) {

m_items[i].canonical_item = i;

}

// In the worst case, for n items, all equal, m FDs ordered optimally bad,

// this algorithm is O(nm) (all items shifted one step down each loop).

// In practice, it should be much better.

bool done_anything;

do {

done_anything = false;

for (const FunctionalDependency &fd : m_fds) {

if (fd.type != FunctionalDependency::EQUIVALENCE) {

continue;

}

ItemHandle left_item = fd.head[0];

ItemHandle right_item = fd.tail;

if (m_items[left_item].canonical_item ==

m_items[right_item].canonical_item) {

// Already fully applied.

continue;

}

// Merge the classes so that the lowest index always is the canonical one

// of its equivalence class.

ItemHandle canonical_item, duplicate_item;

if (m_items[right_item].canonical_item <

m_items[left_item].canonical_item) {

canonical_item = m_items[right_item].canonical_item;

duplicate_item = left_item;

} else {

canonical_item = m_items[left_item].canonical_item;

duplicate_item = right_item;

}

m_items[duplicate_item].canonical_item = canonical_item;

m_items[canonical_item].used_asc |= m_items[duplicate_item].used_asc;

m_items[canonical_item].used_desc |= m_items[duplicate_item].used_desc;

m_items[canonical_item].used_in_grouping |=

m_items[duplicate_item].used_in_grouping;

done_anything = true;

}

} while (done_anything);

for (OrderingWithInfo &ordering : m_orderings) {

if (ordering.ordering.GetKind() == Ordering::Kind::kGroup) {

SortElements(ordering.ordering.GetElements());

}

}

ItemHandle argument_item,

Window *window) {

const PT_order_list *partition_by = window->effective_partition_by();

int partition_len = 0;

if (partition_by != nullptr) {

for (ORDER *order = partition_by->value.first; order != nullptr;

order = order->next) {

++partition_len;

}

}

auto head =

Bounds_checked_array<ItemHandle>::Alloc(thd->mem_root, partition_len + 1);

if (partition_by != nullptr) {

for (ORDER *order = partition_by->value.first; order != nullptr;

order = order->next) {

head[partition_len--] = GetHandle(*order->item);

}

}

head[0] = argument_item;

return head;

int num_original_items = m_items.size();

int num_original_fds = m_fds.size();

for (int item_idx = 0; item_idx < num_original_items; ++item_idx) {

// We only care about items that are used in some ordering,

// not any used as base in FDs or the likes.

const ItemHandle canonical_idx = m_items[item_idx].canonical_item;

if (!m_items[canonical_idx].used_asc && !m_items[canonical_idx].used_desc &&

!m_items[canonical_idx].used_in_grouping) {

continue;

}

// We only want to look at items that are not already Item_field

// or aggregate functions (the latter are handled in

// AddFDsFromAggregateItems()), and that are generated from a single field.

// Some quick heuristics will eliminate most of these for us.

Item *item = m_items[item_idx].item;

const table_map used_tables = item->used_tables();

if (item->type() == Item::FIELD_ITEM || item->has_aggregation() ||

Overlaps(used_tables, PSEUDO_TABLE_BITS) ||

!IsSingleBitSet(used_tables)) {

continue;

}

// Window functions have much more state than just the parameter,

// so we cannot say that e.g. {a} → SUM(a) OVER (...), unless we

// know that the function is over the entire frame (unbounded).

//

// TODO(sgunders): We could also add FDs for window functions

// where could guarantee that the partition is only one row.

bool is_static_wf = false;

if (item->has_wf()) {

if (item->m_is_window_function &&

down_cast<Item_sum *>(item)->framing() &&

down_cast<Item_sum *>(item)->window()->static_aggregates()) {

is_static_wf = true;

} else {

continue;

}

}

Item_field *base_field = nullptr;

bool error =

WalkItem(item, enum_walk::POSTFIX, [&base_field](Item *sub_item) {

if (sub_item->type() == Item::FUNC_ITEM &&

down_cast<Item_func *>(sub_item)->functype() ==

Item_func::ROLLUP_GROUP_ITEM_FUNC) {

// Rollup items are nondeterministic, yet don't always set

// RAND_TABLE_BIT.

return true;

}

if (sub_item->type() == Item::FIELD_ITEM) {

if (base_field != nullptr &&

!base_field->eq(sub_item, /*binary_cmp=*/true)) {

// More than one field in use.

return true;

}

base_field = down_cast<Item_field *>(sub_item);

}

return false;

});

if (error || base_field == nullptr) {

// More than one field in use, or no fields in use

// (can happen even when used_tables is set, e.g. for

// an Item_view_ref to a constant).

continue;

}

if (!base_field->field->binary()) {

// Fields with collations can have equality (with no tiebreaker)

// even with fields that contain differing binary data.

// Thus, functions do not always preserve equality; a == b

// does not mean f(a) == f(b), and thus, the FD does not

// hold either.

continue;

}

ItemHandle head_item = GetHandle(base_field);

FunctionalDependency fd;

fd.type = FunctionalDependency::FD;

if (is_static_wf) {

fd.head = CollectHeadForStaticWindowFunction(

thd, head_item, down_cast<Item_sum *>(item)->window());

} else {

fd.head = Bounds_checked_array<ItemHandle>(&head_item, 1);

}

fd.tail = item_idx;

fd.always_active = true;

AddFunctionalDependency(thd, fd);

if (fd.head.size() == 1) {

// Extend existing FDs transitively (see function comment).

// E.g. if we have S → base, also add S → item.

for (int fd_idx = 0; fd_idx < num_original_fds; ++fd_idx) {

if (m_fds[fd_idx].type == FunctionalDependency::FD &&

m_fds[fd_idx].tail == head_item && m_fds[fd_idx].always_active) {

fd = m_fds[fd_idx];

fd.tail = item_idx;

AddFunctionalDependency(thd, fd);

}

}

}

}

int num_original_items = m_items.size();

for (int item_idx = 0; item_idx < num_original_items; ++item_idx) {

// We only care about items that are used in some ordering,

// not any used as base in FDs or the likes.

const ItemHandle canonical_idx = m_items[item_idx].canonical_item;

if (!m_items[canonical_idx].used_asc && !m_items[canonical_idx].used_desc &&

!m_items[canonical_idx].used_in_grouping) {

continue;

}

if (m_items[item_idx].item->const_for_execution()) {

// Add {} → item.

FunctionalDependency fd;

fd.type = FunctionalDependency::FD;

fd.head = Bounds_checked_array<ItemHandle>();

fd.tail = item_idx;

fd.always_active = true;

AddFunctionalDependency(thd, fd);

}

}

// If ROLLUP is active, and we have nullable GROUP BY expressions, we could

// get two different NULL groups with different aggregates; one for the actual

// NULL value, and one for the rollup group. If so, these FDs no longer hold,

// and we cannot add them.

if (m_rollup) {

for (ItemHandle item : m_aggregate_head) {

if (m_items[item].item->is_nullable()) {

return;

}

}

}

int num_original_items = m_items.size();

for (int item_idx = 0; item_idx < num_original_items; ++item_idx) {

// We only care about items that are used in some ordering,

// not any used as base in FDs or the likes.

const ItemHandle canonical_idx = m_items[item_idx].canonical_item;

if (!m_items[canonical_idx].used_asc && !m_items[canonical_idx].used_desc &&

!m_items[canonical_idx].used_in_grouping) {

continue;

}

if (m_items[item_idx].item->has_aggregation() &&

!m_items[item_idx].item->has_wf()) {

// Add {all GROUP BY items} → item.

// Note that the head might be empty, for implicit grouping,

// which means all aggregate items are constant (there is only one row).

FunctionalDependency fd;

fd.type = FunctionalDependency::FD;

fd.head = m_aggregate_head;

fd.tail = item_idx;

fd.always_active = true;

AddFunctionalDependency(thd, fd);

}

}

for (const FunctionalDependency &fd : m_fds) {

m_items[m_items[fd.tail].canonical_item].can_be_added_by_fd = true;

if (fd.type == FunctionalDependency::EQUIVALENCE) {

m_items[m_items[fd.head[0]].canonical_item].can_be_added_by_fd = true;

}

}

Ordering::Elements prefix,

bool all_fds) const {

// First, search for straight-up duplicates (ignoring ASC/DESC).

if (Contains(prefix, item)) {

return true;

}

// Check if this item is implied by any of the functional dependencies.

for (size_t fd_idx = 1; fd_idx < m_fds.size(); ++fd_idx) {

const FunctionalDependency &fd = m_fds[fd_idx];

if (!all_fds && !fd.always_active) {

continue;

}

if (fd.type == FunctionalDependency::FD) {

if (fd.tail != item) {

continue;

}

// Check if we have all the required head items.

bool all_found = true;

for (ItemHandle other_item : fd.head) {

if (!Contains(prefix, other_item)) {

all_found = false;

break;

}

}

if (all_found) {

return true;

}

} else {

// a = b implies that a → b and b → a, so we check for both of those.

assert(fd.type == FunctionalDependency::EQUIVALENCE);

assert(fd.head.size() == 1);

if (fd.tail == item && Contains(prefix, fd.head[0])) {

return true;

}

if (fd.head[0] == item && Contains(prefix, fd.tail)) {

return true;

}

}

}

return false;

for (OrderingWithInfo &ordering : m_orderings) {

OrderingElementsGuard tmp_guard(this, thd->mem_root);

Ordering reduced_ordering =

ReduceOrdering(ordering.ordering,

/*all_fds=*/false, tmp_guard.Get());

if (reduced_ordering.size() < ordering.ordering.size()) {

ordering.ordering = reduced_ordering.Clone(thd->mem_root);

}

}

OrderingElementsGuard tmp_guard(this, thd->mem_root);

Ordering::Elements &tmp = tmp_guard.Get();

int num_original_orderings = m_orderings.size();

for (int grouping_idx = 1; grouping_idx < num_original_orderings;

++grouping_idx) {

const Ordering &grouping = m_orderings[grouping_idx].ordering;

if (grouping.GetKind() != Ordering::Kind::kGroup ||

m_orderings[grouping_idx].type != OrderingWithInfo::INTERESTING) {

continue;

}

bool has_cover = false;

for (int ordering_idx = 1; ordering_idx < num_original_orderings;

++ordering_idx) {

const Ordering &ordering = m_orderings[ordering_idx].ordering;

if (ordering.GetKind() != Ordering::Kind::kOrder ||

m_orderings[ordering_idx].type != OrderingWithInfo::INTERESTING ||

ordering.size() > grouping.size()) {

continue;

}

bool can_cover =

all_of(ordering.GetElements().begin(), ordering.GetElements().end(),

[&grouping](const OrderElement &element) {

return Contains(grouping.GetElements(), element.item);

});

if (!can_cover) {

continue;

}

has_cover = true;

// On a full match, just note that we have a cover, don't make a new

// ordering. We assume both are free of duplicates.

if (ordering.size() == grouping.size()) {

continue;

}

for (size_t i = 0; i < ordering.size(); ++i) {

tmp[i] = ordering.GetElements()[i];

}

int len = ordering.size();

for (const OrderElement &element : grouping.GetElements()) {

if (!Contains(ordering.GetElements(), element.item)) {

tmp[len].item = element.item;

tmp[len].direction = ORDER_ASC; // Arbitrary.

++len;

}

}

assert(len == static_cast<int>(grouping.size()));

AddOrderingInternal(

thd, Ordering(tmp.prefix(len), Ordering::Kind::kOrder),

OrderingWithInfo::HOMOGENIZED, m_orderings[grouping_idx].used_at_end,

/*homogenize_tables=*/0);

}

// Make a fallback ordering if no cover was found.

if (!has_cover) {

for (size_t i = 0; i < grouping.size(); ++i) {

tmp[i].item = grouping.GetElements()[i].item;

tmp[i].direction = ORDER_ASC; // Arbitrary.

}

AddOrderingInternal(

thd, Ordering(tmp.prefix(grouping.size()), Ordering::Kind::kOrder),

OrderingWithInfo::HOMOGENIZED, m_orderings[grouping_idx].used_at_end,

/*homogenize_tables=*/0);

}