org.h2.result.SortOrder Maven / Gradle / Ivy
/*
* Copyright 2004-2022 H2 Group. Multiple-Licensed under the MPL 2.0,
* and the EPL 1.0 (https://h2database.com/html/license.html).
* Initial Developer: H2 Group
*/
package org.h2.result;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import org.h2.command.query.QueryOrderBy;
import org.h2.engine.Database;
import org.h2.engine.SessionLocal;
import org.h2.expression.Expression;
import org.h2.expression.ExpressionColumn;
import org.h2.mode.DefaultNullOrdering;
import org.h2.table.Column;
import org.h2.table.TableFilter;
import org.h2.util.Utils;
import org.h2.value.Value;
import org.h2.value.ValueNull;
import org.h2.value.ValueRow;
/**
* A sort order represents an ORDER BY clause in a query.
*/
public final class SortOrder implements Comparator {
/**
* This bit mask means the values should be sorted in ascending order.
*/
public static final int ASCENDING = 0;
/**
* This bit mask means the values should be sorted in descending order.
*/
public static final int DESCENDING = 1;
/**
* This bit mask means NULLs should be sorted before other data, no matter
* if ascending or descending order is used.
*/
public static final int NULLS_FIRST = 2;
/**
* This bit mask means NULLs should be sorted after other data, no matter
* if ascending or descending order is used.
*/
public static final int NULLS_LAST = 4;
private final SessionLocal session;
/**
* The column indexes of the order by expressions within the query.
*/
private final int[] queryColumnIndexes;
/**
* The sort type bit mask (DESCENDING, NULLS_FIRST, NULLS_LAST).
*/
private final int[] sortTypes;
/**
* The order list.
*/
private final ArrayList orderList;
/**
* Construct a new sort order object with default sort directions.
*
* @param session the session
* @param queryColumnIndexes the column index list
*/
public SortOrder(SessionLocal session, int[] queryColumnIndexes) {
this (session, queryColumnIndexes, new int[queryColumnIndexes.length], null);
}
/**
* Construct a new sort order object.
*
* @param session the session
* @param queryColumnIndexes the column index list
* @param sortType the sort order bit masks
* @param orderList the original query order list (if this is a query)
*/
public SortOrder(SessionLocal session, int[] queryColumnIndexes, int[] sortType,
ArrayList orderList) {
this.session = session;
this.queryColumnIndexes = queryColumnIndexes;
this.sortTypes = sortType;
this.orderList = orderList;
}
/**
* Create the SQL snippet that describes this sort order.
* This is the SQL snippet that usually appears after the ORDER BY clause.
*
* @param builder string builder to append to
* @param list the expression list
* @param visible the number of columns in the select list
* @param sqlFlags formatting flags
* @return the specified string builder
*/
public StringBuilder getSQL(StringBuilder builder, Expression[] list, int visible, int sqlFlags) {
int i = 0;
for (int idx : queryColumnIndexes) {
if (i > 0) {
builder.append(", ");
}
if (idx < visible) {
builder.append(idx + 1);
} else {
list[idx].getUnenclosedSQL(builder, sqlFlags);
}
typeToString(builder, sortTypes[i++]);
}
return builder;
}
/**
* Appends type information (DESC, NULLS FIRST, NULLS LAST) to the specified statement builder.
* @param builder string builder
* @param type sort type
*/
public static void typeToString(StringBuilder builder, int type) {
if ((type & DESCENDING) != 0) {
builder.append(" DESC");
}
if ((type & NULLS_FIRST) != 0) {
builder.append(" NULLS FIRST");
} else if ((type & NULLS_LAST) != 0) {
builder.append(" NULLS LAST");
}
}
/**
* Compare two expression lists.
*
* @param a the first expression list
* @param b the second expression list
* @return the result of the comparison
*/
@Override
public int compare(Value[] a, Value[] b) {
for (int i = 0, len = queryColumnIndexes.length; i < len; i++) {
int idx = queryColumnIndexes[i];
int type = sortTypes[i];
Value ao = a[idx];
Value bo = b[idx];
boolean aNull = ao == ValueNull.INSTANCE, bNull = bo == ValueNull.INSTANCE;
if (aNull || bNull) {
if (aNull == bNull) {
continue;
}
return session.getDatabase().getDefaultNullOrdering().compareNull(aNull, type);
}
int comp = session.compare(ao, bo);
if (comp != 0) {
return (type & DESCENDING) == 0 ? comp : -comp;
}
}
return 0;
}
/**
* Sort a list of rows.
*
* @param rows the list of rows
*/
public void sort(ArrayList rows) {
rows.sort(this);
}
/**
* Sort a list of rows using offset and limit.
*
* @param rows the list of rows
* @param fromInclusive the start index, inclusive
* @param toExclusive the end index, exclusive
*/
public void sort(ArrayList rows, int fromInclusive, int toExclusive) {
if (toExclusive == 1 && fromInclusive == 0) {
rows.set(0, Collections.min(rows, this));
return;
}
Value[][] arr = rows.toArray(new Value[0][]);
Utils.sortTopN(arr, fromInclusive, toExclusive, this);
for (int i = fromInclusive; i < toExclusive; i++) {
rows.set(i, arr[i]);
}
}
/**
* Get the column index list. This is the column indexes of the order by
* expressions within the query.
*
* For the query "select name, id from test order by id, name" this is {1,
* 0} as the first order by expression (the column "id") is the second
* column of the query, and the second order by expression ("name") is the
* first column of the query.
*
* @return the list
*/
public int[] getQueryColumnIndexes() {
return queryColumnIndexes;
}
/**
* Get the column for the given table filter, if the sort column is for this
* filter.
*
* @param index the column index (0, 1,..)
* @param filter the table filter
* @return the column, or null
*/
public Column getColumn(int index, TableFilter filter) {
if (orderList == null) {
return null;
}
QueryOrderBy order = orderList.get(index);
Expression expr = order.expression;
if (expr == null) {
return null;
}
expr = expr.getNonAliasExpression();
if (expr.isConstant()) {
return null;
}
if (!(expr instanceof ExpressionColumn)) {
return null;
}
ExpressionColumn exprCol = (ExpressionColumn) expr;
if (exprCol.getTableFilter() != filter) {
return null;
}
return exprCol.getColumn();
}
/**
* Get the sort order bit masks.
*
* @return the list
*/
public int[] getSortTypes() {
return sortTypes;
}
/**
* Returns the original query order list.
*
* @return the original query order list
*/
public ArrayList getOrderList() {
return orderList;
}
/**
* Returns sort order bit masks with {@link SortOrder#NULLS_FIRST} or
* {@link SortOrder#NULLS_LAST} explicitly set.
*
* @return bit masks with either {@link SortOrder#NULLS_FIRST} or {@link SortOrder#NULLS_LAST}
* explicitly set.
*/
public int[] getSortTypesWithNullOrdering() {
return addNullOrdering(session.getDatabase(), sortTypes.clone());
}
/**
* Add explicit {@link SortOrder#NULLS_FIRST} or {@link SortOrder#NULLS_LAST} where they
* aren't already specified.
*
* @param database
* the database
* @param sortTypes
* bit masks
* @return the specified array with possibly modified bit masks
*/
public static int[] addNullOrdering(Database database, int[] sortTypes) {
DefaultNullOrdering defaultNullOrdering = database.getDefaultNullOrdering();
for (int i = 0, length = sortTypes.length; i < length; i++) {
sortTypes[i] = defaultNullOrdering.addExplicitNullOrdering(sortTypes[i]);
}
return sortTypes;
}
/**
* Returns comparator for row values.
*
* @return comparator for row values.
*/
public Comparator getRowValueComparator() {
return (o1, o2) -> compare(((ValueRow) o1).getList(), ((ValueRow) o2).getList());
}
}