How to use

SortOrder

in

org.h2.result

/**
 * @param sortOrder Sort order.
 * @param qry Query.
 */
private void processSortOrder(SortOrder sortOrder, GridSqlQuery qry) {
  if (sortOrder == null)
    return;
  int[] indexes = sortOrder.getQueryColumnIndexes();
  int[] sortTypes = sortOrder.getSortTypes();
  for (int i = 0; i < indexes.length; i++) {
    int colIdx = indexes[i];
    int type = sortTypes[i];
    qry.addSort(new GridSqlSortColumn(colIdx,
      (type & SortOrder.DESCENDING) == 0,
      (type & SortOrder.NULLS_FIRST) != 0,
      (type & SortOrder.NULLS_LAST) != 0));
  }
}

private SortOrder initOrder(ArrayList<SelectOrderBy> orderList, Session session) {
  int size = orderList.size();
  int[] index = new int[size];
  int[] sortType = new int[size];
  for (int i = 0; i < size; i++) {
    SelectOrderBy o = orderList.get(i);
    index[i] = i + 1;
    int order = o.descending ? SortOrder.DESCENDING : SortOrder.ASCENDING;
    sortType[i] = order;
  }
  return new SortOrder(session.getDatabase(), index, sortType, null);
}

  @Override
  public int compare(Value v1, Value v2) {
    Value[] a1 = ((ValueArray) v1).getList();
    Value[] a2 = ((ValueArray) v2).getList();
    return sortOrder.compare(a1, a2);
  }
});

boolean sortOrderMatches = true;
int coveringCount = 0;
int[] sortTypes = sortOrder.getSortTypes();
TableFilter tableFilter = filters == null ? null : filters[filter];
for (int i = 0, len = sortTypes.length; i < len; i++) {
  Column col = sortOrder.getColumn(i, tableFilter);
  if (col == null) {
    sortOrderMatches = false;

for (int idx : sort.getQueryColumnIndexes()) {
  if (idx < 0 || idx >= expressions.size()) {
    throw DbException.getInvalidValueException("ORDER BY", idx + 1);
  int[] sortTypes = sort.getSortTypesWithNullPosition();
  for (Index index : list) {
    if (index.getCreateSQL() == null) {
        break;
      if (SortOrder.addExplicitNullPosition(idxCol.sortType) != sortTypes[j]) {
        ok = false;
        break;

@Override
public int addRows(ArrayList<Value[]> rows) {
  // speeds up inserting, but not really needed:
  if (sort != null) {
    sort.sort(rows);
  }
  for (Value[] values : rows) {
    addRow(values);
  }
  return rowCount;
}

private int compareValues(Value a, Value b, int sortType) {
  if (a == b) {
    return 0;
  }
  // null is never stored;
  // comparison with null is used to retrieve all entries
  // in which case null is always lower than all entries
  // (even for descending ordered indexes)
  if (a == null) {
    return -1;
  } else if (b == null) {
    return 1;
  }
  boolean aNull = a == ValueNull.INSTANCE;
  boolean bNull = b == ValueNull.INSTANCE;
  if (aNull || bNull) {
    return SortOrder.compareNull(aNull, sortType);
  }
  int comp = a.compareTypeSafe(b, compareMode);
  if ((sortType & SortOrder.DESCENDING) != 0) {
    comp = -comp;
  }
  return comp;
}

Expression[] exprList = expressions.toArray(new Expression[0]);
if (sort != null) {
  buff.append("\nORDER BY ").append(sort.getSQL(exprList, exprList.length));

if (compare((Value[]) rows.get(l), (Value[]) rows.get(r)) > 0) {
  swap(rows, l, r);
if (compare((Value[]) rows.get(i), (Value[]) rows.get(l)) < 0) {
  swap(rows, l, i);
} else if (compare((Value[]) rows.get(i), (Value[]) rows.get(r)) > 0) {
  swap(rows, i, r);
swap(rows, i, j);
Value[] p = (Value[]) rows.get(j);
i = l;
  do {
    ++i;
  } while (compare((Value[]) rows.get(i), p) < 0);
  do {
    --j;
  } while (compare((Value[]) rows.get(j), p) > 0);
  if (i >= j) {
    break;
  swap(rows, i, j);
swap(rows, i, r - 1);
sort(rows, l, i - 1);
l = i + 1;
for (j = i - 1; j >= l && (compare((Value[]) rows.get(j), t) > 0); j--) {
  rows.set(j + 1, rows.get(j));

  return null;
int[] indexes = sort.getIndexes();
ObjectArray sortColumns = new ObjectArray();
for (int i = 0; i < indexes.length; i++) {
int[] sortTypes = sort.getSortTypes();
if (sortCols.length == 0) {

boolean sortOrderMatches = true;
int coveringCount = 0;
int[] sortTypes = sortOrder.getSortTypes();
TableFilter tableFilter = filters == null ? null : filters[filter];
for (int i = 0, len = sortTypes.length; i < len; i++) {
  Column col = sortOrder.getColumn(i, tableFilter);
  if (col == null) {
    sortOrderMatches = false;

if (sort != null) {
  if (offset > 0 || limit > 0) {
    sort.sort(rows, offset, limit < 0 ? rows.size() : limit);
  } else {
    sort.sort(rows);

/**
 * 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 compareNull(aNull, type);
    }
    int comp = database.compare(ao, bo);
    if (comp != 0) {
      return (type & DESCENDING) == 0 ? comp : -comp;
    }
  }
  return 0;
}

sort.getSQL(exprList, visibleColumnCount));

private void createIndex() {
  IndexColumn[] indexCols = null;
  // If we need to do distinct, the distinct columns may not match the
  // sort columns. So we need to disregard the sort. Not ideal.
  if (sort != null && !distinct) {
    int[] colIndex = sort.getQueryColumnIndexes();
    indexCols = new IndexColumn[colIndex.length];
    for (int i = 0; i < colIndex.length; i++) {
      IndexColumn indexColumn = new IndexColumn();
      indexColumn.column = table.getColumn(colIndex[i]);
      indexColumn.sortType = sort.getSortTypes()[i];
      indexColumn.columnName = COLUMN_NAME + i;
      indexCols[i] = indexColumn;
    }
  } else {
    indexCols = new IndexColumn[columnCount];
    for (int i = 0; i < columnCount; i++) {
      IndexColumn indexColumn = new IndexColumn();
      indexColumn.column = table.getColumn(i);
      indexColumn.columnName = COLUMN_NAME + i;
      indexCols[i] = indexColumn;
    }
  }
  String indexName = table.getSchema().getUniqueIndexName(session,
      table, Constants.PREFIX_INDEX);
  int indexId = session.getDatabase().allocateObjectId();
  IndexType indexType = IndexType.createNonUnique(true);
  index = table.addIndex(session, indexName, indexId, indexCols,
      indexType, true, null);
}

boolean sortOrderMatches = true;
int coveringCount = 0;
int[] sortTypes = sortOrder.getSortTypes();
TableFilter tableFilter = filters == null ? null : filters[filter];
for (int i = 0, len = sortTypes.length; i < len; i++) {
  Column col = sortOrder.getColumn(i, tableFilter);
  if (col == null) {
    sortOrderMatches = false;

@Override
public int addRows(ArrayList<Value[]> rows) {
  // speeds up inserting, but not really needed:
  if (sort != null) {
    sort.sort(rows);
  }
  for (Value[] values : rows) {
    addRow(values);
  }
  return rowCount;
}

return new SortOrder(session.getDatabase(), index, sortType, orderList);

private int compareValues(Value a, Value b, int sortType) throws SQLException {
  boolean aNull = a == null, bNull = b == null;
  if (aNull || bNull) {
    if (aNull == bNull) {
      return 0;
    }
    return SortOrder.compareNull(aNull, bNull, sortType);
  }
  int comp = database.compareTypeSave(a, b);
  if ((sortType & SortOrder.DESCENDING) != 0) {
    comp = -comp;
  }
  return comp;
}

Expression[] exprList = expressions.toArray(new Expression[expressions.size()]);
if (sort != null) {
  buff.append("\nORDER BY ").append(sort.getSQL(exprList, exprList.length));