diff --git a/h2/src/docsrc/html/changelog.html b/h2/src/docsrc/html/changelog.html
index 618e13df7b..3aecab1769 100644
--- a/h2/src/docsrc/html/changelog.html
+++ b/h2/src/docsrc/html/changelog.html
@@ -21,6 +21,8 @@ <h1>Change Log</h1>
 
 <h2>Next Version (unreleased)</h2>
 <ul>
+<li>Issue #701: An available index is never used for ordering, when the requested order is DESC
+</li>
 <li>Issue #4036: NULLS NOT DISTINCT constraint changed after column dropped
 </li>
 <li>Issue #4033: Wrong array produced when using ARRAY_AGG() on UNNEST(ARRAY[CAST(? AS INT)]) expression
diff --git a/h2/src/docsrc/html/performance.html b/h2/src/docsrc/html/performance.html
index 63ed7322b1..2dd4563bd5 100644
--- a/h2/src/docsrc/html/performance.html
+++ b/h2/src/docsrc/html/performance.html
@@ -732,6 +732,17 @@ <h3>Special Optimizations</h3>
 </p><p>
 For queries of the form <code>SELECT * FROM TEST ORDER BY ID</code>, the query plan includes the line
 <code>/* index sorted */</code> to indicate there is no separate sorting required.
+<code>/* index sorted: 2 of 3 columns */</code> indicates that only some columns are sorted with an index.
+An additional sorting is still required, but queries with the FETCH (TOP, LIMIT) clause
+may still stop their execution earlier.
+An index on <code>(A ASC, B ASC)</code> columns can be used for <code>ORDER BY A</code>, <code>ORDER BY A DESC</code>,
+<code>ORDER BY A, B</code> or <code>ORDER BY A DESC, B DESC</code>.
+With <code>ORDER BY A, B DESC</code> this index can only be used for ordering on the column <code>A</code>.
+If columns are nullable, order of nulls is also important. Index on <code>(A ASC NULLS FIRST)</code> cannot be used for
+<code>ORDER BY A ASC NULLS LAST</code>, but can be used for <code>ORDER BY A ASC NULLS FIRST</code> or
+<code>ORDER BY A DESC NULLS LAST</code>.
+When neither <code>NULLS FIRST</code> nor <code>NULLS LAST</code> is specified, a default is used, this default
+is controlled by <a href="commands.html#set_default_null_ordering"><code>DEFAULT_NULL_ORDERING</code></a> setting.
 </p><p>
 For queries of the form <code>SELECT * FROM TEST GROUP BY ID ORDER BY ID</code>, the query plan includes the line
 <code>/* group sorted */</code> to indicate there is no separate sorting required.
diff --git a/h2/src/main/org/h2/bnf/context/DbContextRule.java b/h2/src/main/org/h2/bnf/context/DbContextRule.java
index bf6ff48b45..1966f1a2f0 100644
--- a/h2/src/main/org/h2/bnf/context/DbContextRule.java
+++ b/h2/src/main/org/h2/bnf/context/DbContextRule.java
@@ -89,7 +89,8 @@ public boolean autoComplete(Sentence sentence) {
                         best = quotedName;
                         bestSchema = schema;
                     }
-                } else if (s.isEmpty() || StringUtils.startsWithIgnoringCase(name, query) ||  StringUtils.startsWithIgnoringCase(quotedName, query)) {
+                } else if (s.isEmpty() || StringUtils.startsWithIgnoringCase(name, query)
+                        || StringUtils.startsWithIgnoringCase(quotedName, query)) {
                     if (s.length() < name.length()) {
                         sentence.add(name, name.substring(s.length()), type);
                         sentence.add(schema.quotedName + ".",
@@ -116,12 +117,14 @@ public boolean autoComplete(Sentence sentence) {
                 String name = table.getName();
                 String quotedName = StringUtils.quoteIdentifier(name);
 
-                if (StringUtils.startsWithIgnoringCase(query, name) || StringUtils.startsWithIgnoringCase("\"" + query, quotedName)) {
+                if (StringUtils.startsWithIgnoringCase(query, name)
+                        || StringUtils.startsWithIgnoringCase("\"" + query, quotedName)) {
                     if (best == null || name.length() > best.length()) {
                         best = name;
                         bestTable = table;
                     }
-                } else if (s.isEmpty() || StringUtils.startsWithIgnoringCase(name, query) ||  StringUtils.startsWithIgnoringCase(quotedName, query)) {
+                } else if (s.isEmpty() || StringUtils.startsWithIgnoringCase(name, query)
+                        || StringUtils.startsWithIgnoringCase(quotedName, query)) {
                     if (s.length() < name.length()) {
                         sentence.add(table.getQuotedName(),
                                 table.getQuotedName().substring(s.length()),
diff --git a/h2/src/main/org/h2/command/CommandRemote.java b/h2/src/main/org/h2/command/CommandRemote.java
index 5ec8c73a14..55c2835a81 100644
--- a/h2/src/main/org/h2/command/CommandRemote.java
+++ b/h2/src/main/org/h2/command/CommandRemote.java
@@ -286,7 +286,8 @@ public BatchResult executeBatchUpdate(ArrayList<Value[]> batchParameters, Object
                         }
                         if (readGeneratedKeys) {
                             int columnCount = transfer.readInt();
-                            ResultRemote remoteGeneratedKeys = new ResultRemote(session, transfer, objectId, columnCount, Integer.MAX_VALUE);
+                            ResultRemote remoteGeneratedKeys = new ResultRemote(session, transfer, objectId,
+                                    columnCount, Integer.MAX_VALUE);
                             generatedKeys.add(remoteGeneratedKeys);
                             remoteGeneratedKeys.close();
                         }
@@ -310,7 +311,8 @@ public BatchResult executeBatchUpdate(ArrayList<Value[]> batchParameters, Object
                                 autoCommit = transfer.readBoolean();
                                 if (readGeneratedKeys) {
                                     int columnCount = transfer.readInt();
-                                    ResultRemote remoteGeneratedKeys = new ResultRemote(session, transfer, objectId, columnCount, Integer.MAX_VALUE);
+                                    ResultRemote remoteGeneratedKeys = new ResultRemote(session, transfer, objectId,
+                                            columnCount, Integer.MAX_VALUE);
                                     generatedKeys.add(remoteGeneratedKeys);
                                     remoteGeneratedKeys.close();
                                 }
diff --git a/h2/src/main/org/h2/command/ddl/Analyze.java b/h2/src/main/org/h2/command/ddl/Analyze.java
index 8ce62d1e23..d6c6312332 100644
--- a/h2/src/main/org/h2/command/ddl/Analyze.java
+++ b/h2/src/main/org/h2/command/ddl/Analyze.java
@@ -187,7 +187,7 @@ public static void analyzeTable(SessionLocal session, Table table, int sample, b
         if (columnCount == 0) {
             return;
         }
-        Cursor cursor = table.getScanIndex(session).find(session, null, null);
+        Cursor cursor = table.getScanIndex(session).find(session, null, null, false);
         if (cursor.next()) {
             SelectivityData[] array = new SelectivityData[columnCount];
             for (int i = 0; i < columnCount; i++) {
diff --git a/h2/src/main/org/h2/command/dml/ScriptCommand.java b/h2/src/main/org/h2/command/dml/ScriptCommand.java
index d296425964..62e835ea4f 100644
--- a/h2/src/main/org/h2/command/dml/ScriptCommand.java
+++ b/h2/src/main/org/h2/command/dml/ScriptCommand.java
@@ -474,7 +474,7 @@ private static <T extends DbObject> T[] sorted(Collection<T> collection, Class<T
     private int generateInsertValues(int count, Table table) throws IOException {
         PlanItem plan = table.getBestPlanItem(session, null, null, -1, null, null);
         Index index = plan.getIndex();
-        Cursor cursor = index.find(session, null, null);
+        Cursor cursor = index.find(session, null, null, false);
         Column[] columns = table.getColumns();
         boolean withGenerated = false, withGeneratedAlwaysAsIdentity = false;
         for (Column c : columns) {
diff --git a/h2/src/main/org/h2/command/query/Select.java b/h2/src/main/org/h2/command/query/Select.java
index cb7680f29b..d48cb377b0 100644
--- a/h2/src/main/org/h2/command/query/Select.java
+++ b/h2/src/main/org/h2/command/query/Select.java
@@ -15,6 +15,7 @@
 import java.util.HashMap;
 import java.util.HashSet;
 import java.util.LinkedHashMap;
+import java.util.List;
 import java.util.Map.Entry;
 
 import org.h2.api.ErrorCode;
@@ -38,6 +39,7 @@
 import org.h2.expression.function.CoalesceFunction;
 import org.h2.index.Cursor;
 import org.h2.index.Index;
+import org.h2.index.IndexSort;
 import org.h2.index.QueryExpressionIndex;
 import org.h2.message.DbException;
 import org.h2.mode.DefaultNullOrdering;
@@ -75,6 +77,8 @@
  */
 public class Select extends Query {
 
+    private enum QuickOffset { NO, YES, PARTIAL }
+
     /**
      * The main (top) table filter.
      */
@@ -149,7 +153,7 @@ public class Select extends Query {
     private ForUpdate forUpdate;
     private double cost;
     private boolean isQuickAggregateQuery, isDistinctQuery;
-    private boolean sortUsingIndex;
+    private int indexSortedColumns;
 
     private boolean isGroupWindowStage2;
 
@@ -582,14 +586,11 @@ private Value[] constructGroupResultRow(Value[] keyValues, int columnCount) {
     }
 
     /**
-     * Get the index that matches the ORDER BY list, if one exists. This is to
-     * avoid running a separate ORDER BY if an index can be used. This is
-     * specially important for large result sets, if only the first few rows are
-     * important (LIMIT is used)
+     * Returns possible index-sorting operations (better first) if they exist.
      *
-     * @return the index if one is found
+     * @return possible index-sorting operations, or {@code null} if unavailable
      */
-    private Index getSortIndex() {
+    private List<IndexSort> getIndexSorts() {
         if (sort == null) {
             return null;
         }
@@ -597,7 +598,9 @@ private Index getSortIndex() {
         int[] queryColumnIndexes = sort.getQueryColumnIndexes();
         int queryIndexesLength = queryColumnIndexes.length;
         int[] sortIndex = new int[queryIndexesLength];
-        for (int i = 0, j = 0; i < queryIndexesLength; i++) {
+        int sortedColumns = 0;
+        boolean needMore = false;
+        for (int i = 0; i < queryIndexesLength; i++) {
             int idx = queryColumnIndexes[i];
             if (idx < 0 || idx >= expressions.size()) {
                 throw DbException.getInvalidValueException("ORDER BY", idx + 1);
@@ -608,62 +611,100 @@ private Index getSortIndex() {
                 continue;
             }
             if (!(expr instanceof ExpressionColumn)) {
-                return null;
+                needMore = true;
+                break;
             }
             ExpressionColumn exprCol = (ExpressionColumn) expr;
             if (exprCol.getTableFilter() != topTableFilter) {
-                return null;
+                needMore = true;
+                break;
             }
             sortColumns.add(exprCol.getColumn());
-            sortIndex[j++] = i;
+            sortIndex[sortedColumns++] = i;
         }
-        Column[] sortCols = sortColumns.toArray(new Column[0]);
-        if (sortCols.length == 0) {
+        if (sortedColumns == 0) {
+            if (needMore) {
+                // Can't sort using index
+                return null;
+            }
             // sort just on constants - can use scan index
-            return topTableFilter.getTable().getScanIndex(session);
+            return List.of(new IndexSort(topTableFilter.getTable().getScanIndex(session), false));
+        }
+        Column[] sortCols;
+        int[] sortTypes = sort.getSortTypesWithNullOrdering();
+        if (sortedColumns == 1) {
+            Column column = sortColumns.get(0);
+            if (column.getColumnId() == -1) {
+                // special case: order by _ROWID_
+                Index index = topTableFilter.getTable().getScanIndex(session);
+                if (index.isRowIdIndex()) {
+                    return List.of(new IndexSort(index, needMore ? sortedColumns : IndexSort.FULLY_SORTED,
+                            (sortTypes[sortIndex[0]] & SortOrder.DESCENDING) != 0));
+                }
+            }
+            sortCols = new Column[] { column };
+        } else {
+            sortCols = sortColumns.toArray(new Column[0]);
         }
         ArrayList<Index> list = topTableFilter.getTable().getIndexes();
-        if (list != null) {
-            int[] sortTypes = sort.getSortTypesWithNullOrdering();
-            DefaultNullOrdering defaultNullOrdering = getDatabase().getDefaultNullOrdering();
-            loop: for (Index index : list) {
-                if (index.getCreateSQL() == null) {
-                    // can't use the scan index
-                    continue;
-                }
-                if (index.getIndexType().isHash()) {
-                    continue;
-                }
-                IndexColumn[] indexCols = index.getIndexColumns();
-                if (indexCols.length < sortCols.length) {
-                    continue;
-                }
-                for (int j = 0; j < sortCols.length; j++) {
-                    // the index and the sort order must start
-                    // with the exact same columns
-                    IndexColumn idxCol = indexCols[j];
-                    Column sortCol = sortCols[j];
-                    if (idxCol.column != sortCol) {
-                        continue loop;
+        if (list == null) {
+            return null;
+        }
+        DefaultNullOrdering defaultNullOrdering = getDatabase().getDefaultNullOrdering();
+        ArrayList<IndexSort> indexSorts = Utils.newSmallArrayList();
+        loop: for (Index index : list) {
+            if (index.getCreateSQL() == null || index.getIndexType().isHash()) {
+                // can't use scan or hash indexes
+                continue;
+            }
+            IndexColumn[] indexCols = index.getIndexColumns();
+            int count = Math.min(indexCols.length, sortedColumns);
+            boolean reverse = false;
+            for (int j = 0; j < count; j++) {
+                // the index and the sort order must start
+                // with the exact same columns
+                IndexColumn idxCol = indexCols[j];
+                Column sortCol = sortCols[j];
+                boolean mismatch = idxCol.column != sortCol;
+                if (!mismatch) {
+                    if (sortCol.isNullable()) {
+                        int o1 = defaultNullOrdering.addExplicitNullOrdering(idxCol.sortType);
+                        int o2 = sortTypes[sortIndex[j]];
+                        if (j == 0) {
+                            if (o1 != o2) {
+                                if (o1 == SortOrder.inverse(o2)) {
+                                    reverse = true;
+                                } else {
+                                    mismatch = true;
+                                }
+                            }
+                        } else {
+                            if (o1 != (reverse ? SortOrder.inverse(o2) : o2)) {
+                                mismatch = true;
+                            }
+                        }
+                    } else {
+                        boolean different = (idxCol.sortType & SortOrder.DESCENDING) //
+                                != (sortTypes[sortIndex[j]] & SortOrder.DESCENDING);
+                        if (j == 0) {
+                            reverse = different;
+                        } else {
+                            mismatch = different != reverse;
+                        }
                     }
-                    int sortType = sortTypes[sortIndex[j]];
-                    if (sortCol.isNullable()
-                            ? defaultNullOrdering.addExplicitNullOrdering(idxCol.sortType) != sortType
-                            : (idxCol.sortType & SortOrder.DESCENDING) != (sortType & SortOrder.DESCENDING)) {
-                        continue loop;
+                }
+                if (mismatch) {
+                    if (j > 0) {
+                        indexSorts.add(new IndexSort(index, j, reverse));
                     }
+                    continue loop;
                 }
-                return index;
-            }
-        }
-        if (sortCols.length == 1 && sortCols[0].getColumnId() == -1) {
-            // special case: order by _ROWID_
-            Index index = topTableFilter.getTable().getScanIndex(session);
-            if (index.isRowIdIndex()) {
-                return index;
             }
+            indexSorts.add(new IndexSort(index, needMore || count < sortedColumns ? count : IndexSort.FULLY_SORTED,
+                    reverse));
         }
-        return null;
+        indexSorts.sort(null);
+        return indexSorts;
     }
 
     private void queryDistinct(ResultTarget result, long offset, long limitRows, boolean withTies,
@@ -683,7 +724,7 @@ private void queryDistinct(ResultTarget result, long offset, long limitRows, boo
         if (!quickOffset) {
             offset = 0;
         }
-        while (true) {
+        for (;;) {
             setCurrentRowNumber(++rowNumber);
             Cursor cursor = index.findNext(session, first, null);
             if (!cursor.next()) {
@@ -700,15 +741,16 @@ private void queryDistinct(ResultTarget result, long offset, long limitRows, boo
                 continue;
             }
             result.addRow(value);
-            if ((sort == null || sortUsingIndex) && limitRows > 0 && rowNumber >= limitRows && !withTies) {
+            if ((sort == null || indexSortedColumns == IndexSort.FULLY_SORTED) && limitRows > 0
+                    && rowNumber >= limitRows && !withTies) {
                 break;
             }
         }
     }
 
     private LazyResult queryFlat(int columnCount, ResultTarget result, long offset, long limitRows, boolean withTies,
-            boolean quickOffset) {
-        if (limitRows > 0 && offset > 0 && !quickOffset) {
+            QuickOffset quickOffset) {
+        if (limitRows > 0 && offset > 0 && quickOffset != QuickOffset.YES) {
             limitRows += offset;
             if (limitRows < 0) {
                 // Overflow
@@ -716,30 +758,47 @@ private LazyResult queryFlat(int columnCount, ResultTarget result, long offset,
             }
         }
         LazyResultQueryFlat lazyResult = new LazyResultQueryFlat(expressionArray, columnCount, forUpdate != null);
-        skipOffset(lazyResult, offset, quickOffset);
+        skipOffset(lazyResult, offset, quickOffset == QuickOffset.YES);
         if (result == null) {
             return lazyResult;
         }
-        if (limitRows < 0 || sort != null && !sortUsingIndex || withTies && !quickOffset) {
-            limitRows = Long.MAX_VALUE;
+        if (limitRows == Long.MAX_VALUE || limitRows < 0 || sort != null && indexSortedColumns == 0
+                || withTies && quickOffset == QuickOffset.NO) {
+            while (lazyResult.next()) {
+                result.addRow(lazyResult.currentRow());
+            }
+        } else {
+            readWithLimit(result, limitRows, withTies, lazyResult);
         }
-        Value[] row = null;
+        return null;
+    }
+
+    private void readWithLimit(ResultTarget result, long limitRows, boolean withTies, LazyResultQueryFlat lazyResult) {
+        Value[] last = null;
         while (result.getRowCount() < limitRows && lazyResult.next()) {
-            row = lazyResult.currentRow();
-            result.addRow(row);
-        }
-        if (limitRows != Long.MAX_VALUE && withTies && sort != null && row != null) {
-            Value[] expected = row;
-            while (lazyResult.next()) {
-                row = lazyResult.currentRow();
-                if (sort.compare(expected, row) != 0) {
-                    break;
+            last = lazyResult.currentRow();
+            result.addRow(last);
+        }
+        if (sort != null && last != null) {
+            if (indexSortedColumns < IndexSort.FULLY_SORTED) {
+                while (lazyResult.next()) {
+                    Value[] row = lazyResult.currentRow();
+                    if (sort.compare(last, row, indexSortedColumns) != 0) {
+                        break;
+                    }
+                    result.addRow(row);
+                }
+            } else if (withTies) {
+                while (lazyResult.next()) {
+                    Value[] row = lazyResult.currentRow();
+                    if (sort.compare(last, row) != 0) {
+                        break;
+                    }
+                    result.addRow(row);
                 }
-                result.addRow(row);
+                result.limitsWereApplied();
             }
-            result.limitsWereApplied();
         }
-        return null;
     }
 
     private static void skipOffset(LazyResultSelect lazyResult, long offset, boolean quickOffset) {
@@ -778,22 +837,22 @@ protected ResultInterface queryWithoutCache(long maxRows, ResultTarget target) {
             result = createLocalResult(result);
         }
         // Do not add rows before OFFSET to result if possible
-        boolean quickOffset = !fetchPercent;
-        if (sort != null && (!sortUsingIndex || isAnyDistinct())) {
+        QuickOffset quickOffset = fetchPercent ? QuickOffset.NO : QuickOffset.YES;
+        if (sort != null && (indexSortedColumns != IndexSort.FULLY_SORTED || isAnyDistinct())) {
             result = createLocalResult(result);
             result.setSortOrder(sort);
-            if (!sortUsingIndex) {
-                quickOffset = false;
+            if (indexSortedColumns != IndexSort.FULLY_SORTED) {
+                quickOffset = indexSortedColumns > 0 ? QuickOffset.PARTIAL : QuickOffset.NO;
             }
         }
         if (distinct) {
             result = createLocalResult(result);
             if (!isDistinctQuery) {
-                quickOffset = false;
+                quickOffset = QuickOffset.NO;
                 result.setDistinct();
             }
         } else if (distinctExpressions != null) {
-            quickOffset = false;
+            quickOffset = QuickOffset.NO;
             result = createLocalResult(result);
             result.setDistinct(distinctIndexes);
         }
@@ -813,25 +872,25 @@ protected ResultInterface queryWithoutCache(long maxRows, ResultTarget target) {
             // Cannot apply limit now if percent is specified
             long limit = fetchPercent ? -1 : fetch;
             if (isQuickAggregateQuery) {
-                queryQuick(columnCount, to, quickOffset && offset > 0);
+                queryQuick(columnCount, to, quickOffset == QuickOffset.YES && offset > 0);
             } else if (isWindowQuery) {
                 if (isGroupQuery) {
-                    queryGroupWindow(columnCount, result, offset, quickOffset);
+                    queryGroupWindow(columnCount, result, offset, quickOffset == QuickOffset.YES);
                 } else {
-                    queryWindow(columnCount, result, offset, quickOffset);
+                    queryWindow(columnCount, result, offset, quickOffset == QuickOffset.YES);
                 }
             } else if (isGroupQuery) {
                 if (isGroupSortedQuery) {
-                    lazyResult = queryGroupSorted(columnCount, to, offset, quickOffset);
+                    lazyResult = queryGroupSorted(columnCount, to, offset, quickOffset == QuickOffset.YES);
                 } else {
-                    queryGroup(columnCount, result, offset, quickOffset);
+                    queryGroup(columnCount, result, offset, quickOffset == QuickOffset.YES);
                 }
             } else if (isDistinctQuery) {
-                queryDistinct(to, offset, limit, withTies, quickOffset);
+                queryDistinct(to, offset, limit, withTies, quickOffset == QuickOffset.YES);
             } else {
                 lazyResult = queryFlat(columnCount, to, offset, limit, withTies, quickOffset);
             }
-            if (quickOffset) {
+            if (quickOffset == QuickOffset.YES) {
                 offset = 0;
             }
         }
@@ -1199,62 +1258,63 @@ public void preparePlan() {
             }
         }
         cost = preparePlan(session.isParsingCreateView());
-        if (distinct && getDatabase().getSettings().optimizeDistinct &&
-                !isGroupQuery && filters.size() == 1 &&
-                expressions.size() == 1 && condition == null) {
+        if (distinct && getDatabase().getSettings().optimizeDistinct && !isGroupQuery && filters.size() == 1
+                && expressions.size() == 1 && condition == null) {
             Expression expr = expressions.get(0);
             expr = expr.getNonAliasExpression();
             if (expr instanceof ExpressionColumn) {
                 Column column = ((ExpressionColumn) expr).getColumn();
                 int selectivity = column.getSelectivity();
-                Index columnIndex = topTableFilter.getTable().
-                        getIndexForColumn(column, false, true);
-                if (columnIndex != null &&
-                        selectivity != Constants.SELECTIVITY_DEFAULT &&
-                        selectivity < 20) {
+                Index columnIndex = topTableFilter.getTable().getIndexForColumn(column, false, true);
+                if (columnIndex != null && selectivity != Constants.SELECTIVITY_DEFAULT && selectivity < 20) {
                     Index current = topTableFilter.getIndex();
                     // if another index is faster
                     if (current == null || current.getIndexType().isScan() || columnIndex == current) {
-                        topTableFilter.setIndex(columnIndex);
+                        topTableFilter.setIndex(columnIndex, false);
                         isDistinctQuery = true;
                     }
                 }
             }
         }
         if (sort != null && !isQuickAggregateQuery && !isGroupQuery) {
-            Index index = getSortIndex();
+            List<IndexSort> sortIndexes = getIndexSorts();
             Index current = topTableFilter.getIndex();
-            if (index != null && current != null) {
-                if (current.getIndexType().isScan() || current == index) {
-                    topTableFilter.setIndex(index);
-                    if (!topTableFilter.hasInComparisons()) {
-                        // in(select ...) and in(1,2,3) may return the key in
-                        // another order
-                        sortUsingIndex = true;
-                    }
-                } else if (index.getIndexColumns() != null
-                        && index.getIndexColumns().length >= current
-                                .getIndexColumns().length) {
-                    IndexColumn[] sortColumns = index.getIndexColumns();
-                    IndexColumn[] currentColumns = current.getIndexColumns();
-                    boolean swapIndex = false;
-                    for (int i = 0; i < currentColumns.length; i++) {
-                        if (sortColumns[i].column != currentColumns[i].column) {
-                            swapIndex = false;
+            if (sortIndexes != null && current != null) {
+                loop: for (IndexSort sortIndex : sortIndexes) {
+                    Index index = sortIndex.getIndex();
+                    boolean reverse = sortIndex.isReverse();
+                    if (current.getIndexType().isScan() || current == index) {
+                        topTableFilter.setIndex(index, reverse);
+                        if (!topTableFilter.hasInComparisons()) {
+                            // in(select ...) and in(1,2,3) may return the key in
+                            // another order
+                            indexSortedColumns = sortIndex.getSortedColumns();
                             break;
                         }
-                        if (sortColumns[i].sortType != currentColumns[i].sortType) {
-                            swapIndex = true;
+                    } else if (index.getIndexColumns() != null
+                            && index.getIndexColumns().length >= current
+                                    .getIndexColumns().length) {
+                        IndexColumn[] sortColumns = index.getIndexColumns();
+                        IndexColumn[] currentColumns = current.getIndexColumns();
+                        boolean swapIndex = false;
+                        for (int i = 0; i < currentColumns.length; i++) {
+                            if (sortColumns[i].column != currentColumns[i].column) {
+                                continue loop;
+                            }
+                            if (sortColumns[i].sortType != currentColumns[i].sortType) {
+                                swapIndex = true;
+                            }
+                        }
+                        if (swapIndex) {
+                            topTableFilter.setIndex(index, reverse);
+                            indexSortedColumns = sortIndex.getSortedColumns();
+                            break;
                         }
-                    }
-                    if (swapIndex) {
-                        topTableFilter.setIndex(index);
-                        sortUsingIndex = true;
                     }
                 }
             }
-            if (sortUsingIndex && forUpdate != null && !topTableFilter.getIndex().isRowIdIndex()) {
-                sortUsingIndex = false;
+            if (indexSortedColumns > 0 && forUpdate != null && !topTableFilter.getIndex().isRowIdIndex()) {
+                indexSortedColumns = 0;
             }
         }
         if (!isQuickAggregateQuery && isGroupQuery) {
@@ -1262,7 +1322,7 @@ public void preparePlan() {
             if (index != null) {
                 Index current = topTableFilter.getIndex();
                 if (current != null && (current.getIndexType().isScan() || current == index)) {
-                    topTableFilter.setIndex(index);
+                    topTableFilter.setIndex(index, false);
                     isGroupSortedQuery = true;
                 }
             }
@@ -1448,8 +1508,11 @@ public StringBuilder getPlanSQL(StringBuilder builder, int sqlFlags) {
             if (isDistinctQuery) {
                 builder.append("\n/* distinct */");
             }
-            if (sortUsingIndex) {
+            if (indexSortedColumns == IndexSort.FULLY_SORTED) {
                 builder.append("\n/* index sorted */");
+            } else if (indexSortedColumns > 0) {
+                builder.append("\n/* index sorted: ").append(indexSortedColumns).append(" of ") //
+                        .append(sort.getOrderList().size()).append(" columns */");
             }
             if (isGroupQuery) {
                 if (isGroupSortedQuery) {
diff --git a/h2/src/main/org/h2/constraint/ConstraintReferential.java b/h2/src/main/org/h2/constraint/ConstraintReferential.java
index b35a3458ab..01be6f85aa 100644
--- a/h2/src/main/org/h2/constraint/ConstraintReferential.java
+++ b/h2/src/main/org/h2/constraint/ConstraintReferential.java
@@ -314,7 +314,7 @@ private boolean existsRow(SessionLocal session, Index searchIndex,
             SearchRow check, Row excluding) {
         Table searchTable = searchIndex.getTable();
         searchTable.lock(session, Table.READ_LOCK);
-        Cursor cursor = searchIndex.find(session, check, check);
+        Cursor cursor = searchIndex.find(session, check, check, false);
         while (cursor.next()) {
             SearchRow found;
             found = cursor.getSearchRow();
diff --git a/h2/src/main/org/h2/engine/Database.java b/h2/src/main/org/h2/engine/Database.java
index 000fe39e8e..cbae14930b 100644
--- a/h2/src/main/org/h2/engine/Database.java
+++ b/h2/src/main/org/h2/engine/Database.java
@@ -576,7 +576,7 @@ private CreateTableData createSysTableData() {
     }
 
     private void executeMeta() {
-        Cursor cursor = metaIdIndex.find(systemSession, null, null);
+        Cursor cursor = metaIdIndex.find(systemSession, null, null, false);
         ArrayList<MetaRecord> firstRecords = new ArrayList<>(), domainRecords = new ArrayList<>(),
                 middleRecords = new ArrayList<>(), constraintRecords = new ArrayList<>(),
                 lastRecords = new ArrayList<>();
@@ -729,7 +729,7 @@ private void addMeta(SessionLocal session, DbObject obj) {
                 if (SysProperties.CHECK) {
                     verifyMetaLocked(session);
                 }
-                Cursor cursor = metaIdIndex.find(session, r, r);
+                Cursor cursor = metaIdIndex.find(session, r, r, false);
                 if (!cursor.next()) {
                     meta.addRow(session, r);
                 } else {
@@ -838,7 +838,7 @@ public void removeMeta(SessionLocal session, int id) {
             r.setValue(0, ValueInteger.get(id));
             boolean wasLocked = lockMeta(session);
             try {
-                Cursor cursor = metaIdIndex.find(session, r, r);
+                Cursor cursor = metaIdIndex.find(session, r, r, false);
                 if (cursor.next()) {
                     Row found = cursor.get();
                     meta.removeRow(session, found);
@@ -1319,7 +1319,7 @@ private synchronized void closeFiles() {
     private void checkMetaFree(SessionLocal session, int id) {
         SearchRow r = meta.getRowFactory().createRow();
         r.setValue(0, ValueInteger.get(id));
-        Cursor cursor = metaIdIndex.find(session, r, r);
+        Cursor cursor = metaIdIndex.find(session, r, r, false);
         if (cursor.next()) {
             throw DbException.getInternalError();
         }
diff --git a/h2/src/main/org/h2/expression/aggregate/Percentile.java b/h2/src/main/org/h2/expression/aggregate/Percentile.java
index 6dfc13618b..8003e76917 100644
--- a/h2/src/main/org/h2/expression/aggregate/Percentile.java
+++ b/h2/src/main/org/h2/expression/aggregate/Percentile.java
@@ -157,7 +157,7 @@ static Value getFromIndex(SessionLocal session, Expression expression, int dataT
         if (count == 0) {
             return ValueNull.INSTANCE;
         }
-        Cursor cursor = index.find(session, null, null);
+        Cursor cursor = index.find(session, null, null, false);
         cursor.next();
         int columnId = index.getColumns()[0].getColumnId();
         ExpressionColumn expr = (ExpressionColumn) expression;
@@ -188,7 +188,7 @@ static Value getFromIndex(SessionLocal session, Expression expression, int dataT
                 TableFilter tableFilter = expr.getTableFilter();
                 SearchRow check = tableFilter.getTable().getTemplateSimpleRow(true);
                 check.setValue(columnId, ValueNull.INSTANCE);
-                Cursor nullsCursor = index.find(session, check, check);
+                Cursor nullsCursor = index.find(session, check, check, false);
                 while (nullsCursor.next()) {
                     count--;
                 }
diff --git a/h2/src/main/org/h2/index/DualIndex.java b/h2/src/main/org/h2/index/DualIndex.java
index ffb90bd893..9173d6c62f 100644
--- a/h2/src/main/org/h2/index/DualIndex.java
+++ b/h2/src/main/org/h2/index/DualIndex.java
@@ -25,7 +25,7 @@ public DualIndex(DualTable table) {
     }
 
     @Override
-    public Cursor find(SessionLocal session, SearchRow first, SearchRow last) {
+    public Cursor find(SessionLocal session, SearchRow first, SearchRow last, boolean reverse) {
         return new DualCursor();
     }
 
diff --git a/h2/src/main/org/h2/index/Index.java b/h2/src/main/org/h2/index/Index.java
index b6b435a5a1..c042740ab8 100644
--- a/h2/src/main/org/h2/index/Index.java
+++ b/h2/src/main/org/h2/index/Index.java
@@ -244,9 +244,10 @@ public boolean isFindUsingFullTableScan() {
      * @param session the session
      * @param first the first row, or null for no limit
      * @param last the last row, or null for no limit
+     * @param reverse if true, iterate in reverse (descending) order
      * @return the cursor to iterate over the results
      */
-    public abstract Cursor find(SessionLocal session, SearchRow first, SearchRow last);
+    public abstract Cursor find(SessionLocal session, SearchRow first, SearchRow last, boolean reverse);
 
     /**
      * Estimate the cost to search for rows given the search mask.
diff --git a/h2/src/main/org/h2/index/IndexCursor.java b/h2/src/main/org/h2/index/IndexCursor.java
index 33f140187d..2c90d27d8e 100644
--- a/h2/src/main/org/h2/index/IndexCursor.java
+++ b/h2/src/main/org/h2/index/IndexCursor.java
@@ -34,6 +34,7 @@ public class IndexCursor implements Cursor {
 
     private SessionLocal session;
     private Index index;
+    private boolean reverse;
     private Table table;
     private IndexColumn[] indexColumns;
     private boolean alwaysFalse;
@@ -52,8 +53,9 @@ public class IndexCursor implements Cursor {
     public IndexCursor() {
     }
 
-    public void setIndex(Index index) {
+    public void setIndex(Index index, boolean reverse) {
         this.index = index;
+        this.reverse = reverse;
         this.table = index.getTable();
         Column[] columns = table.getColumns();
         indexColumns = new IndexColumn[columns.length];
@@ -180,10 +182,18 @@ public void find(SessionLocal s, ArrayList<IndexCondition> indexConditions) {
             return;
         }
         if (!alwaysFalse) {
+            SearchRow first, last;
+            if (reverse) {
+                first = end;
+                last = start;
+            } else {
+                first = start;
+                last = end;
+            }
             if (intersects != null && index instanceof SpatialIndex) {
-                cursor = ((SpatialIndex) index).findByGeometry(session, start, end, intersects);
+                cursor = ((SpatialIndex) index).findByGeometry(session, first, last, reverse, intersects);
             } else if (index != null) {
-                cursor = index.find(session, start, end);
+                cursor = index.find(session, first, last, reverse);
             }
         }
     }
@@ -384,7 +394,7 @@ private void find(Value v) {
             int id = column.getColumnId();
             start.setValue(id, v);
         }
-        cursor = index.find(session, start, start);
+        cursor = index.find(session, start, start, false);
     }
 
     @Override
diff --git a/h2/src/main/org/h2/index/IndexSort.java b/h2/src/main/org/h2/index/IndexSort.java
new file mode 100644
index 0000000000..07e3a8a3a0
--- /dev/null
+++ b/h2/src/main/org/h2/index/IndexSort.java
@@ -0,0 +1,94 @@
+/*
+ * Copyright 2004-2024 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.index;
+
+/**
+ * Index-sorting information.
+ */
+public final class IndexSort implements Comparable<IndexSort> {
+
+    /**
+     * Used instead of actual number of sorted columns when post-sorting isn't
+     * needed.
+     */
+    public static final int FULLY_SORTED = Integer.MAX_VALUE;
+
+    private final Index index;
+
+    /**
+     * A positive number of sorted columns for partial index sorts, or
+     * {@link #FULLY_SORTED} for complete index sorts.
+     */
+    private final int sortedColumns;
+
+    /**
+     * Whether index must be iterated in reverse order.
+     */
+    private final boolean reverse;
+
+    /**
+     * Creates an index sorting information for complete index sort.
+     *
+     * @param index
+     *            the index
+     * @param reverse
+     *            whether index must be iterated in reverse order
+     */
+    public IndexSort(Index index, boolean reverse) {
+        this(index, FULLY_SORTED, reverse);
+    }
+
+    /**
+     * Creates an index sorting information for index sort.
+     *
+     * @param index
+     *            the index
+     * @param sortedColumns
+     *            a positive number of sorted columns for partial index sorts,
+     *            or {@link #FULLY_SORTED} for complete index sorts
+     * @param reverse
+     *            whether index must be iterated in reverse order
+     */
+    public IndexSort(Index index, int sortedColumns, boolean reverse) {
+        this.index = index;
+        this.sortedColumns = sortedColumns;
+        this.reverse = reverse;
+    }
+
+    /**
+     * Returns the index.
+     *
+     * @return the index
+     */
+    public Index getIndex() {
+        return index;
+    }
+
+    /**
+     * Returns number of sorted columns.
+     *
+     * @return positive number of sorted columns for partial index sorts, or
+     *         {@link #FULLY_SORTED} for complete index sorts
+     */
+    public int getSortedColumns() {
+        return sortedColumns;
+    }
+
+    /**
+     * Returns whether index must be iterated in reverse order.
+     *
+     * @return {@code true} for reverse order, {@code false} for natural order
+     */
+    public boolean isReverse() {
+        return reverse;
+    }
+
+    @Override
+    public int compareTo(IndexSort o) {
+        return o.sortedColumns - sortedColumns;
+    }
+
+}
diff --git a/h2/src/main/org/h2/index/LinkedIndex.java b/h2/src/main/org/h2/index/LinkedIndex.java
index 98dbc09366..9dc67e98bd 100644
--- a/h2/src/main/org/h2/index/LinkedIndex.java
+++ b/h2/src/main/org/h2/index/LinkedIndex.java
@@ -87,7 +87,8 @@ public void add(SessionLocal session, Row row) {
     }
 
     @Override
-    public Cursor find(SessionLocal session, SearchRow first, SearchRow last) {
+    public Cursor find(SessionLocal session, SearchRow first, SearchRow last, boolean reverse) {
+        assert !reverse;
         ArrayList<Value> params = Utils.newSmallArrayList();
         StringBuilder builder = new StringBuilder("SELECT * FROM ").append(targetTableName).append(" T");
         boolean f = false;
diff --git a/h2/src/main/org/h2/index/MetaIndex.java b/h2/src/main/org/h2/index/MetaIndex.java
index ecfaac0fa8..8da7a6c36e 100644
--- a/h2/src/main/org/h2/index/MetaIndex.java
+++ b/h2/src/main/org/h2/index/MetaIndex.java
@@ -48,7 +48,8 @@ public void remove(SessionLocal session, Row row) {
     }
 
     @Override
-    public Cursor find(SessionLocal session, SearchRow first, SearchRow last) {
+    public Cursor find(SessionLocal session, SearchRow first, SearchRow last, boolean reverse) {
+        assert !reverse;
         ArrayList<Row> rows = meta.generateRows(session, first, last);
         return new MetaCursor(rows);
     }
diff --git a/h2/src/main/org/h2/index/RangeIndex.java b/h2/src/main/org/h2/index/RangeIndex.java
index 9ae8fb5d98..3eff4d7763 100644
--- a/h2/src/main/org/h2/index/RangeIndex.java
+++ b/h2/src/main/org/h2/index/RangeIndex.java
@@ -32,7 +32,8 @@ public RangeIndex(RangeTable table, IndexColumn[] columns) {
     }
 
     @Override
-    public Cursor find(SessionLocal session, SearchRow first, SearchRow last) {
+    public Cursor find(SessionLocal session, SearchRow first, SearchRow last, boolean reverse) {
+        assert !reverse;
         long min = rangeTable.getMin(session);
         long max = rangeTable.getMax(session);
         long step = rangeTable.getStep(session);
diff --git a/h2/src/main/org/h2/index/RecursiveIndex.java b/h2/src/main/org/h2/index/RecursiveIndex.java
index 6b1a10ad03..0a2821a91c 100644
--- a/h2/src/main/org/h2/index/RecursiveIndex.java
+++ b/h2/src/main/org/h2/index/RecursiveIndex.java
@@ -61,7 +61,8 @@ public double getCost(SessionLocal session, int[] masks, TableFilter[] filters,
     }
 
     @Override
-    public Cursor find(SessionLocal session, SearchRow first, SearchRow last) {
+    public Cursor find(SessionLocal session, SearchRow first, SearchRow last, boolean reverse) {
+        assert !reverse;
         CTE cte = (CTE) table;
         ResultInterface recursiveResult = cte.getRecursiveResult();
         if (recursiveResult != null) {
diff --git a/h2/src/main/org/h2/index/RegularQueryExpressionIndex.java b/h2/src/main/org/h2/index/RegularQueryExpressionIndex.java
index d0b73d4660..fc678a2e17 100644
--- a/h2/src/main/org/h2/index/RegularQueryExpressionIndex.java
+++ b/h2/src/main/org/h2/index/RegularQueryExpressionIndex.java
@@ -158,12 +158,14 @@ public double getCost(SessionLocal session, int[] masks, TableFilter[] filters,
     }
 
     @Override
-    public Cursor find(SessionLocal session, SearchRow first, SearchRow last) {
+    public Cursor find(SessionLocal session, SearchRow first, SearchRow last, boolean reverse) {
         return find(session, first, last, null);
     }
 
     @Override
-    public Cursor findByGeometry(SessionLocal session, SearchRow first, SearchRow last, SearchRow intersection) {
+    public Cursor findByGeometry(SessionLocal session, SearchRow first, SearchRow last, boolean reverse,
+            SearchRow intersection) {
+        assert !reverse;
         return find(session, first, last, intersection);
     }
 
diff --git a/h2/src/main/org/h2/index/SpatialIndex.java b/h2/src/main/org/h2/index/SpatialIndex.java
index e7c174c2c7..701cd02dc3 100644
--- a/h2/src/main/org/h2/index/SpatialIndex.java
+++ b/h2/src/main/org/h2/index/SpatialIndex.java
@@ -21,10 +21,12 @@ public interface SpatialIndex {
      * @param session the session
      * @param first the lower bound
      * @param last the upper bound
+     * @param reverse if true, iterate in reverse (descending) order
      * @param intersection the geometry which values should intersect with, or
      *            null for anything
      * @return the cursor to iterate over the results
      */
-    Cursor findByGeometry(SessionLocal session, SearchRow first, SearchRow last, SearchRow intersection);
+    Cursor findByGeometry(SessionLocal session, SearchRow first, SearchRow last, boolean reverse,
+            SearchRow intersection);
 
 }
diff --git a/h2/src/main/org/h2/index/VirtualConstructedTableIndex.java b/h2/src/main/org/h2/index/VirtualConstructedTableIndex.java
index 63244c8880..8d096f9f97 100644
--- a/h2/src/main/org/h2/index/VirtualConstructedTableIndex.java
+++ b/h2/src/main/org/h2/index/VirtualConstructedTableIndex.java
@@ -34,7 +34,8 @@ public boolean isFindUsingFullTableScan() {
     }
 
     @Override
-    public Cursor find(SessionLocal session, SearchRow first, SearchRow last) {
+    public Cursor find(SessionLocal session, SearchRow first, SearchRow last, boolean reverse) {
+        assert !reverse;
         return new VirtualTableCursor(this, first, last, table.getResult(session));
     }
 
diff --git a/h2/src/main/org/h2/mvstore/MVMap.java b/h2/src/main/org/h2/mvstore/MVMap.java
index a09a53679b..53ddf4644f 100644
--- a/h2/src/main/org/h2/mvstore/MVMap.java
+++ b/h2/src/main/org/h2/mvstore/MVMap.java
@@ -213,7 +213,7 @@ public final K getKey(long index) {
      * @return the key list
      */
     public final List<K> keyList() {
-        return new AbstractList<K>() {
+        return new AbstractList<>() {
 
             @Override
             public K get(int index) {
@@ -733,12 +733,12 @@ public Cursor<K, V> cursor(RootReference<K,V> rootReference, K from, K to, boole
     @Override
     public final Set<Map.Entry<K, V>> entrySet() {
         final RootReference<K,V> rootReference = flushAndGetRoot();
-        return new AbstractSet<Entry<K, V>>() {
+        return new AbstractSet<>() {
 
             @Override
             public Iterator<Entry<K, V>> iterator() {
                 final Cursor<K, V> cursor = cursor(rootReference, null, null, false);
-                return new Iterator<Entry<K, V>>() {
+                return new Iterator<>() {
 
                     @Override
                     public boolean hasNext() {
@@ -771,7 +771,7 @@ public boolean contains(Object o) {
     @Override
     public Set<K> keySet() {
         final RootReference<K,V> rootReference = flushAndGetRoot();
-        return new AbstractSet<K>() {
+        return new AbstractSet<>() {
 
             @Override
             public Iterator<K> iterator() {
@@ -1617,7 +1617,7 @@ public abstract static class DecisionMaker<V> {
         /**
          * Decision maker for transaction rollback.
          */
-        public static final DecisionMaker<Object> DEFAULT = new DecisionMaker<Object>() {
+        public static final DecisionMaker<Object> DEFAULT = new DecisionMaker<>() {
             @Override
             public Decision decide(Object existingValue, Object providedValue) {
                 return providedValue == null ? Decision.REMOVE : Decision.PUT;
@@ -1632,7 +1632,7 @@ public String toString() {
         /**
          * Decision maker for put().
          */
-        public static final DecisionMaker<Object> PUT = new DecisionMaker<Object>() {
+        public static final DecisionMaker<Object> PUT = new DecisionMaker<>() {
             @Override
             public Decision decide(Object existingValue, Object providedValue) {
                 return Decision.PUT;
@@ -1647,7 +1647,7 @@ public String toString() {
         /**
          * Decision maker for remove().
          */
-        public static final DecisionMaker<Object> REMOVE = new DecisionMaker<Object>() {
+        public static final DecisionMaker<Object> REMOVE = new DecisionMaker<>() {
             @Override
             public Decision decide(Object existingValue, Object providedValue) {
                 return Decision.REMOVE;
@@ -1662,7 +1662,7 @@ public String toString() {
         /**
          * Decision maker for putIfAbsent() key/value.
          */
-        static final DecisionMaker<Object> IF_ABSENT = new DecisionMaker<Object>() {
+        static final DecisionMaker<Object> IF_ABSENT = new DecisionMaker<>() {
             @Override
             public Decision decide(Object existingValue, Object providedValue) {
                 return existingValue == null ? Decision.PUT : Decision.ABORT;
@@ -1677,7 +1677,7 @@ public String toString() {
         /**
          * Decision maker for replace().
          */
-        static final DecisionMaker<Object> IF_PRESENT= new DecisionMaker<Object>() {
+        static final DecisionMaker<Object> IF_PRESENT= new DecisionMaker<>() {
             @Override
             public Decision decide(Object existingValue, Object providedValue) {
                 return existingValue != null ? Decision.PUT : Decision.ABORT;
diff --git a/h2/src/main/org/h2/mvstore/RandomAccessStore.java b/h2/src/main/org/h2/mvstore/RandomAccessStore.java
index 745e3b2af7..dbf2ee3786 100644
--- a/h2/src/main/org/h2/mvstore/RandomAccessStore.java
+++ b/h2/src/main/org/h2/mvstore/RandomAccessStore.java
@@ -741,8 +741,9 @@ protected void doHousekeeping(MVStore mvStore) throws InterruptedException {
         if (idle) {
             int currentChunksFillRate = getChunksFillRate();
             long currentTotalChunksSize = size() * getFillRate() / 100;
-            stopIdleHousekeeping = currentTotalChunksSize > chunksTotalSize || currentTotalChunksSize == chunksTotalSize && currentChunksFillRate <= chunksFillRate;
-      }
+            stopIdleHousekeeping = currentTotalChunksSize > chunksTotalSize
+                    || currentTotalChunksSize == chunksTotalSize && currentChunksFillRate <= chunksFillRate;
+        }
     }
 
     private int getTargetFillRate(boolean idle) {
diff --git a/h2/src/main/org/h2/mvstore/db/MVDelegateIndex.java b/h2/src/main/org/h2/mvstore/db/MVDelegateIndex.java
index d6d9e2adf1..28d6c93a85 100644
--- a/h2/src/main/org/h2/mvstore/db/MVDelegateIndex.java
+++ b/h2/src/main/org/h2/mvstore/db/MVDelegateIndex.java
@@ -84,8 +84,8 @@ public void close(SessionLocal session) {
     }
 
     @Override
-    public Cursor find(SessionLocal session, SearchRow first, SearchRow last) {
-        return mainIndex.find(session, first, last);
+    public Cursor find(SessionLocal session, SearchRow first, SearchRow last, boolean reverse) {
+        return mainIndex.find(session, first, last, reverse);
     }
 
     @Override
diff --git a/h2/src/main/org/h2/mvstore/db/MVPrimaryIndex.java b/h2/src/main/org/h2/mvstore/db/MVPrimaryIndex.java
index 8b59074a79..ee45e80840 100644
--- a/h2/src/main/org/h2/mvstore/db/MVPrimaryIndex.java
+++ b/h2/src/main/org/h2/mvstore/db/MVPrimaryIndex.java
@@ -230,7 +230,7 @@ private Row lockRow(TransactionMap<Long,SearchRow> map, long key, int timeoutMil
     }
 
     @Override
-    public Cursor find(SessionLocal session, SearchRow first, SearchRow last) {
+    public Cursor find(SessionLocal session, SearchRow first, SearchRow last, boolean reverse) {
         Long min, max;
         Value v;
         if (first == null) {
@@ -323,7 +323,7 @@ public Cursor find(SessionLocal session, SearchRow first, SearchRow last) {
         if (min != null && max != null && min.longValue() == max.longValue()) {
             return new SingleRowCursor(setRowKey((Row) map.getFromSnapshot(min), min));
         }
-        return new MVStoreCursor(map.entryIterator(min, max));
+        return new MVStoreCursor(map.entryIterator(min, max, reverse));
     }
 
     @Override
diff --git a/h2/src/main/org/h2/mvstore/db/MVSecondaryIndex.java b/h2/src/main/org/h2/mvstore/db/MVSecondaryIndex.java
index 3cc6466a2c..5c3039cf50 100644
--- a/h2/src/main/org/h2/mvstore/db/MVSecondaryIndex.java
+++ b/h2/src/main/org/h2/mvstore/db/MVSecondaryIndex.java
@@ -266,14 +266,14 @@ private boolean rowsAreEqual(SearchRow rowOne, SearchRow rowTwo) {
     }
 
     @Override
-    public Cursor find(SessionLocal session, SearchRow first, SearchRow last) {
-        return find(session, first, false, last);
+    public Cursor find(SessionLocal session, SearchRow first, SearchRow last, boolean reverse) {
+        return find(session, first, false, last, reverse);
     }
 
-    private Cursor find(SessionLocal session, SearchRow first, boolean bigger, SearchRow last) {
+    private Cursor find(SessionLocal session, SearchRow first, boolean bigger, SearchRow last, boolean reverse) {
         SearchRow min = convertToKey(first, bigger);
         SearchRow max = convertToKey(last, Boolean.TRUE);
-        return new MVStoreCursor(session, getMap(session).keyIterator(min, max), mvTable);
+        return new MVStoreCursor(session, getMap(session).keyIterator(min, max, reverse), mvTable);
     }
 
     private SearchRow convertToKey(SearchRow r, Boolean minMax) {
@@ -368,7 +368,7 @@ public boolean canFindNext() {
 
     @Override
     public Cursor findNext(SessionLocal session, SearchRow higherThan, SearchRow last) {
-        return find(session, higherThan, true, last);
+        return find(session, higherThan, true, last, false);
     }
 
     /**
diff --git a/h2/src/main/org/h2/mvstore/db/MVSpatialIndex.java b/h2/src/main/org/h2/mvstore/db/MVSpatialIndex.java
index 5e7dc9d416..de084f168b 100644
--- a/h2/src/main/org/h2/mvstore/db/MVSpatialIndex.java
+++ b/h2/src/main/org/h2/mvstore/db/MVSpatialIndex.java
@@ -193,17 +193,18 @@ public void remove(SessionLocal session, Row row) {
     }
 
     @Override
-    public Cursor find(SessionLocal session, SearchRow first, SearchRow last) {
-        Iterator<Spatial> cursor = spatialMap.keyIterator(null);
+    public Cursor find(SessionLocal session, SearchRow first, SearchRow last, boolean reverse) {
+        Iterator<Spatial> cursor = reverse ? spatialMap.keyIteratorReverse(null) : spatialMap.keyIterator(null);
         TransactionMap<Spatial, Value> map = getMap(session);
         Iterator<Spatial> it = new SpatialKeyIterator(map, cursor, false);
         return new MVStoreCursor(session, it, mvTable);
     }
 
     @Override
-    public Cursor findByGeometry(SessionLocal session, SearchRow first, SearchRow last, SearchRow intersection) {
+    public Cursor findByGeometry(SessionLocal session, SearchRow first, SearchRow last, boolean reverse,
+            SearchRow intersection) {
         if (intersection == null) {
-            return find(session, first, last);
+            return find(session, first, last, reverse);
         }
         Iterator<Spatial> cursor =
                 spatialMap.findIntersectingKeys(getKey(intersection));
diff --git a/h2/src/main/org/h2/mvstore/db/MVTable.java b/h2/src/main/org/h2/mvstore/db/MVTable.java
index b6244c76b7..fea9515e46 100644
--- a/h2/src/main/org/h2/mvstore/db/MVTable.java
+++ b/h2/src/main/org/h2/mvstore/db/MVTable.java
@@ -413,7 +413,7 @@ private void rebuildIndexBlockMerge(SessionLocal session, MVIndex<?,?> index) {
         Index scan = getScanIndex(session);
         long remaining = scan.getRowCount(session);
         long total = remaining;
-        Cursor cursor = scan.find(session, null, null);
+        Cursor cursor = scan.find(session, null, null, false);
         long i = 0;
         Store store = session.getDatabase().getStore();
 
@@ -453,7 +453,7 @@ private void rebuildIndexBuffered(SessionLocal session, Index index) {
         Index scan = getScanIndex(session);
         long remaining = scan.getRowCount(session);
         long total = remaining;
-        Cursor cursor = scan.find(session, null, null);
+        Cursor cursor = scan.find(session, null, null, false);
         long i = 0;
         int bufferSize = (int) Math.min(total, database.getMaxMemoryRows());
         ArrayList<Row> buffer = new ArrayList<>(bufferSize);
diff --git a/h2/src/main/org/h2/mvstore/tx/TransactionMap.java b/h2/src/main/org/h2/mvstore/tx/TransactionMap.java
index fb65742a51..91e3129406 100644
--- a/h2/src/main/org/h2/mvstore/tx/TransactionMap.java
+++ b/h2/src/main/org/h2/mvstore/tx/TransactionMap.java
@@ -640,7 +640,7 @@ public void clear() {
 
     @Override
     public Set<Entry<K, V>> entrySet() {
-        return new AbstractSet<Entry<K, V>>() {
+        return new AbstractSet<>() {
 
             @Override
             public Iterator<Entry<K, V>> iterator() {
@@ -834,6 +834,18 @@ public TMIterator<K, V, K> keyIterator(K from, K to) {
         return chooseIterator(from, to, false, false);
     }
 
+    /**
+     * Iterate over keys.
+     *
+     * @param from the first key to return
+     * @param to the last key to return or null if there is no limit
+     * @param reverse if true, iterate in reverse (descending) order
+     * @return the iterator
+     */
+    public TMIterator<K, V, K> keyIterator(K from, K to, boolean reverse) {
+        return chooseIterator(from, to, reverse, false);
+    }
+
     /**
      * Iterate over keys, including keys from uncommitted entries.
      *
@@ -856,6 +868,18 @@ public TMIterator<K, V, Map.Entry<K, V>> entryIterator(final K from, final K to)
         return chooseIterator(from, to, false, true);
     }
 
+    /**
+     * Iterate over entries.
+     *
+     * @param from the first key to return
+     * @param to the last key to return
+     * @param reverse if true, iterate in reverse (descending) order
+     * @return the iterator
+     */
+    public TMIterator<K, V, Map.Entry<K, V>> entryIterator(K from, K to, boolean reverse) {
+        return chooseIterator(from, to, reverse, true);
+    }
+
     private <X> TMIterator<K, V, X> chooseIterator(K from, K to, boolean reverse, boolean forEntries) {
         switch (transaction.isolationLevel) {
             case READ_UNCOMMITTED:
diff --git a/h2/src/main/org/h2/res/help.csv b/h2/src/main/org/h2/res/help.csv
index d19879dbf2..577c568547 100644
--- a/h2/src/main/org/h2/res/help.csv
+++ b/h2/src/main/org/h2/res/help.csv
@@ -1666,9 +1666,12 @@ With HIGH default ordering NULL values are considered as larger than other value
 With FIRST default ordering NULL values are sorted before other values,
 no matter if ascending or descending order is used.
 
-WITH LAST default ordering NULL values are sorted after other values,
+With LAST default ordering NULL values are sorted after other values,
 no matter if ascending or descending order is used.
 
+Please note that FIRST and LAST make impossible to use an index on ""(A ASC)"" for ""ORDER BY A DESC""
+if column is nullable.
+
 This setting is not persistent, but indexes are persisted with explicit NULLS FIRST or NULLS LAST ordering
 and aren't affected by changes in this setting.
 Admin rights are required to execute this command, as it affects all connections.
diff --git a/h2/src/main/org/h2/result/SortOrder.java b/h2/src/main/org/h2/result/SortOrder.java
index d61463a1f3..01eb8b20f9 100644
--- a/h2/src/main/org/h2/result/SortOrder.java
+++ b/h2/src/main/org/h2/result/SortOrder.java
@@ -143,7 +143,23 @@ public static void typeToString(StringBuilder builder, int type) {
      */
     @Override
     public int compare(Value[] a, Value[] b) {
-        for (int i = 0, len = queryColumnIndexes.length; i < len; i++) {
+        return compareImpl(a, b, queryColumnIndexes.length);
+    }
+
+    /**
+     * Compare two expression lists.
+     *
+     * @param a the first expression list
+     * @param b the second expression list
+     * @param count number of columns to compare
+     * @return the result of the comparison
+     */
+    public int compare(Value[] a, Value[] b, int count) {
+        return compareImpl(a, b, count);
+    }
+
+    private int compareImpl(Value[] a, Value[] b, int count) {
+        for (int i = 0; i < count; i++) {
             int idx = queryColumnIndexes[i];
             int type = sortTypes[i];
             Value ao = a[idx];
@@ -284,6 +300,10 @@ public static int[] addNullOrdering(Database database, int[] sortTypes) {
         return sortTypes;
     }
 
+    public static int inverse(int sortTypeWithNull) {
+        return sortTypeWithNull ^ (DESCENDING | NULLS_FIRST | NULLS_LAST);
+    }
+
     /**
      * Returns comparator for row values.
      *
diff --git a/h2/src/main/org/h2/table/TableFilter.java b/h2/src/main/org/h2/table/TableFilter.java
index 765c0df036..d01f18c0e5 100644
--- a/h2/src/main/org/h2/table/TableFilter.java
+++ b/h2/src/main/org/h2/table/TableFilter.java
@@ -292,7 +292,7 @@ public void setPlanItem(PlanItem item) {
             // this will result in an exception later on
             return;
         }
-        setIndex(item.getIndex());
+        setIndex(item.getIndex(), false);
         masks = item.getMasks();
         if (nestedJoin != null) {
             if (item.getNestedJoinPlan() != null) {
@@ -315,7 +315,7 @@ public void setPlanItem(PlanItem item) {
      */
     private void setScanIndexes() {
         if (index == null) {
-            setIndex(table.getScanIndex(session));
+            setIndex(table.getScanIndex(session), false);
         }
         if (join != null) {
             join.setScanIndexes();
@@ -869,9 +869,9 @@ public Index getIndex() {
         return index;
     }
 
-    public void setIndex(Index index) {
+    public void setIndex(Index index, boolean reverse) {
         this.index = index;
-        cursor.setIndex(index);
+        cursor.setIndex(index, reverse);
     }
 
     public void setUsed(boolean used) {
diff --git a/h2/src/test/org/h2/samples/optimizations.sql b/h2/src/test/org/h2/samples/optimizations.sql
index 028034ab3c..be36fe14e3 100644
--- a/h2/src/test/org/h2/samples/optimizations.sql
+++ b/h2/src/test/org/h2/samples/optimizations.sql
@@ -196,9 +196,6 @@ EXPLAIN SELECT "VALUE" FROM TEST ORDER BY "VALUE" LIMIT 10;
 -->    /* index sorted */
 ;
 
--- To optimize getting the largest values, a new descending index is required
-CREATE INDEX IDX_TEST_VALUE_D ON TEST("VALUE" DESC);
-
 -- Query the largest 10 values
 SELECT "VALUE" FROM TEST ORDER BY "VALUE" DESC LIMIT 3;
 --> 99.89
@@ -211,7 +208,7 @@ EXPLAIN SELECT "VALUE" FROM TEST ORDER BY "VALUE" DESC LIMIT 10;
 --> SELECT
 -->        "VALUE"
 -->    FROM "PUBLIC"."TEST"
--->        /* PUBLIC.IDX_TEST_VALUE_D */
+-->        /* PUBLIC.IDX_TEST_VALUE */
 -->    ORDER BY 1 DESC
 -->    FETCH FIRST 10 ROWS ONLY
 -->    /* index sorted */
diff --git a/h2/src/test/org/h2/test/db/TestOptimizations.java b/h2/src/test/org/h2/test/db/TestOptimizations.java
index 87b2641f98..09c92b7f2e 100644
--- a/h2/src/test/org/h2/test/db/TestOptimizations.java
+++ b/h2/src/test/org/h2/test/db/TestOptimizations.java
@@ -339,7 +339,6 @@ private void testSortIndex() throws SQLException {
         Statement stat = conn.createStatement();
         stat.execute("drop table test if exists");
         stat.execute("create table test(id int)");
-        stat.execute("create index idx_id_desc on test(id desc)");
         stat.execute("create index idx_id_asc on test(id)");
         ResultSet rs;
 
@@ -351,7 +350,7 @@ private void testSortIndex() throws SQLException {
         rs = stat.executeQuery("explain select * from test " +
                 "where id < 10 order by id desc");
         rs.next();
-        assertContains(rs.getString(1), "IDX_ID_DESC");
+        assertContains(rs.getString(1), "IDX_ID_ASC");
 
         rs.next();
         stat.execute("drop table test");
diff --git a/h2/src/test/org/h2/test/db/TestTableEngines.java b/h2/src/test/org/h2/test/db/TestTableEngines.java
index ee29bf11c0..14feb37398 100644
--- a/h2/src/test/org/h2/test/db/TestTableEngines.java
+++ b/h2/src/test/org/h2/test/db/TestTableEngines.java
@@ -16,7 +16,7 @@
 import java.util.Comparator;
 import java.util.Iterator;
 import java.util.List;
-import java.util.Set;
+import java.util.NavigableSet;
 import java.util.TreeSet;
 
 import org.h2.api.ErrorCode;
@@ -238,7 +238,7 @@ private void testMultiColumnTreeSetIndex() throws SQLException {
         checkPlan(stat, "select * from t order by c, b", "IDX_C_B_A");
         checkPlan(stat, "select * from t order by b", "IDX_B_A");
         checkPlan(stat, "select * from t order by b, a", "IDX_B_A");
-        checkPlan(stat, "select * from t order by b, c", "scan");
+        checkPlan(stat, "select * from t order by b, c", "IDX_B_A");
         checkPlan(stat, "select * from t order by a, b", "scan");
         checkPlan(stat, "select * from t order by a, c, b", "scan");
 
@@ -586,7 +586,7 @@ public Cursor findFirstOrLast(SessionLocal session, boolean first) {
                 }
 
                 @Override
-                public Cursor find(SessionLocal session, SearchRow first, SearchRow last) {
+                public Cursor find(SessionLocal session, SearchRow first, SearchRow last, boolean reverse) {
                     return new SingleRowCursor(row);
                 }
 
@@ -736,7 +736,7 @@ public class Auto extends OneRowTableEngine.OneRowTable.Scan {
                 }
 
                 @Override
-                public Cursor find(SessionLocal session, SearchRow first, SearchRow last) {
+                public Cursor find(SessionLocal session, SearchRow first, SearchRow last, boolean reverse) {
                     return new SingleRowCursor(row);
                 }
 
@@ -954,10 +954,15 @@ private static SearchRow mark(SearchRow row, boolean first) {
         }
 
         @Override
-        public Cursor find(SessionLocal session, SearchRow first, SearchRow last) {
-            Set<SearchRow> subSet;
+        public Cursor find(SessionLocal session, SearchRow first, SearchRow last, boolean reverse) {
+            if (reverse) {
+                SearchRow temp = first;
+                first = last;
+                last = temp;
+            }
+            NavigableSet<SearchRow> subSet;
             if (first != null && last != null && compareRows(last, first) < 0) {
-                subSet = Collections.emptySet();
+                subSet = Collections.emptyNavigableSet();
             } else {
                 if (first != null) {
                     first = set.floor(mark(first, true));
@@ -978,6 +983,9 @@ public Cursor find(SessionLocal session, SearchRow first, SearchRow last) {
                 } else {
                     throw new IllegalStateException();
                 }
+                if (reverse) {
+                    subSet = subSet.descendingSet();
+                }
             }
             return new IteratorCursor(subSet.iterator());
         }
diff --git a/h2/src/test/org/h2/test/scripts/indexes.sql b/h2/src/test/org/h2/test/scripts/indexes.sql
index f25de2ee60..c431fbb1e2 100644
--- a/h2/src/test/org/h2/test/scripts/indexes.sql
+++ b/h2/src/test/org/h2/test/scripts/indexes.sql
@@ -208,12 +208,6 @@ CREATE INDEX A_IDX_ASC ON TEST(A ASC);
 CREATE INDEX A_IDX_ASC_NL ON TEST(A ASC NULLS LAST);
 > ok
 
-CREATE INDEX A_IDX_DESC ON TEST(A DESC);
-> ok
-
-CREATE INDEX A_IDX_DESC_NF ON TEST(A DESC NULLS FIRST);
-> ok
-
 EXPLAIN SELECT A FROM TEST ORDER BY A;
 >> SELECT "A" FROM "PUBLIC"."TEST" /* PUBLIC.A_IDX_ASC */ ORDER BY 1 /* index sorted */
 
@@ -227,46 +221,46 @@ EXPLAIN SELECT A FROM TEST ORDER BY A NULLS LAST;
 >> SELECT "A" FROM "PUBLIC"."TEST" /* PUBLIC.A_IDX_ASC_NL */ ORDER BY 1 NULLS LAST /* index sorted */
 
 EXPLAIN SELECT A FROM TEST ORDER BY A DESC;
->> SELECT "A" FROM "PUBLIC"."TEST" /* PUBLIC.A_IDX_DESC */ ORDER BY 1 DESC /* index sorted */
+>> SELECT "A" FROM "PUBLIC"."TEST" /* PUBLIC.A_IDX_ASC */ ORDER BY 1 DESC /* index sorted */
 
 EXPLAIN SELECT A FROM TEST ORDER BY A DESC NULLS FIRST;
->> SELECT "A" FROM "PUBLIC"."TEST" /* PUBLIC.A_IDX_DESC_NF */ ORDER BY 1 DESC NULLS FIRST /* index sorted */
+>> SELECT "A" FROM "PUBLIC"."TEST" /* PUBLIC.A_IDX_ASC_NL */ ORDER BY 1 DESC NULLS FIRST /* index sorted */
 
 EXPLAIN SELECT A FROM TEST ORDER BY A DESC NULLS LAST;
->> SELECT "A" FROM "PUBLIC"."TEST" /* PUBLIC.A_IDX_DESC */ ORDER BY 1 DESC NULLS LAST /* index sorted */
+>> SELECT "A" FROM "PUBLIC"."TEST" /* PUBLIC.A_IDX_ASC */ ORDER BY 1 DESC NULLS LAST /* index sorted */
 
 DROP INDEX A_IDX_ASC;
 > ok
 
-DROP INDEX A_IDX_DESC;
+DROP INDEX A_IDX_ASC_NL;
 > ok
 
-CREATE INDEX A_IDX_ASC_NF ON TEST(A ASC NULLS FIRST);
+CREATE INDEX A_IDX_DESC ON TEST(A DESC);
 > ok
 
-CREATE INDEX A_IDX_DESC_NL ON TEST(A DESC NULLS LAST);
+CREATE INDEX A_IDX_DESC_NF ON TEST(A DESC NULLS FIRST);
 > ok
 
 EXPLAIN SELECT A FROM TEST ORDER BY A;
->> SELECT "A" FROM "PUBLIC"."TEST" /* PUBLIC.A_IDX_ASC_NF */ ORDER BY 1 /* index sorted */
+>> SELECT "A" FROM "PUBLIC"."TEST" /* PUBLIC.A_IDX_DESC */ ORDER BY 1 /* index sorted */
 
 EXPLAIN SELECT A FROM TEST ORDER BY A ASC;
->> SELECT "A" FROM "PUBLIC"."TEST" /* PUBLIC.A_IDX_ASC_NF */ ORDER BY 1 /* index sorted */
+>> SELECT "A" FROM "PUBLIC"."TEST" /* PUBLIC.A_IDX_DESC */ ORDER BY 1 /* index sorted */
 
 EXPLAIN SELECT A FROM TEST ORDER BY A NULLS FIRST;
->> SELECT "A" FROM "PUBLIC"."TEST" /* PUBLIC.A_IDX_ASC_NF */ ORDER BY 1 NULLS FIRST /* index sorted */
+>> SELECT "A" FROM "PUBLIC"."TEST" /* PUBLIC.A_IDX_DESC */ ORDER BY 1 NULLS FIRST /* index sorted */
 
 EXPLAIN SELECT A FROM TEST ORDER BY A NULLS LAST;
->> SELECT "A" FROM "PUBLIC"."TEST" /* PUBLIC.A_IDX_ASC_NL */ ORDER BY 1 NULLS LAST /* index sorted */
+>> SELECT "A" FROM "PUBLIC"."TEST" /* PUBLIC.A_IDX_DESC_NF */ ORDER BY 1 NULLS LAST /* index sorted */
 
 EXPLAIN SELECT A FROM TEST ORDER BY A DESC;
->> SELECT "A" FROM "PUBLIC"."TEST" /* PUBLIC.A_IDX_DESC_NL */ ORDER BY 1 DESC /* index sorted */
+>> SELECT "A" FROM "PUBLIC"."TEST" /* PUBLIC.A_IDX_DESC */ ORDER BY 1 DESC /* index sorted */
 
 EXPLAIN SELECT A FROM TEST ORDER BY A DESC NULLS FIRST;
 >> SELECT "A" FROM "PUBLIC"."TEST" /* PUBLIC.A_IDX_DESC_NF */ ORDER BY 1 DESC NULLS FIRST /* index sorted */
 
 EXPLAIN SELECT A FROM TEST ORDER BY A DESC NULLS LAST;
->> SELECT "A" FROM "PUBLIC"."TEST" /* PUBLIC.A_IDX_DESC_NL */ ORDER BY 1 DESC NULLS LAST /* index sorted */
+>> SELECT "A" FROM "PUBLIC"."TEST" /* PUBLIC.A_IDX_DESC */ ORDER BY 1 DESC NULLS LAST /* index sorted */
 
 DROP TABLE TEST;
 > ok
@@ -1183,3 +1177,65 @@ SELECT * FROM TEST WHERE B < -1E19::DOUBLE PRECISION;
 DROP TABLE TEST;
 > ok
 
+CREATE TABLE TEST(G GEOMETRY) AS VALUES GEOMETRY 'POINT(3 0)', GEOMETRY 'POINT(1 1)', GEOMETRY 'POINT(2 2)';
+> ok
+
+SELECT * FROM TEST ORDER BY G;
+> G
+> -----------
+> POINT (1 1)
+> POINT (2 2)
+> POINT (3 0)
+> rows (ordered): 3
+
+SELECT * FROM TEST ORDER BY G DESC;
+> G
+> -----------
+> POINT (3 0)
+> POINT (2 2)
+> POINT (1 1)
+> rows (ordered): 3
+
+CREATE SPATIAL INDEX ON TEST(G);
+> ok
+
+EXPLAIN SELECT * FROM TEST ORDER BY G;
+>> SELECT "PUBLIC"."TEST"."G" FROM "PUBLIC"."TEST" /* PUBLIC.INDEX_2 */ ORDER BY 1 /* index sorted */
+
+EXPLAIN SELECT * FROM TEST ORDER BY G DESC;
+>> SELECT "PUBLIC"."TEST"."G" FROM "PUBLIC"."TEST" /* PUBLIC.INDEX_2 */ ORDER BY 1 DESC /* index sorted */
+
+SELECT * FROM TEST ORDER BY G;
+> G
+> -----------
+> POINT (1 1)
+> POINT (2 2)
+> POINT (3 0)
+> rows (ordered): 3
+
+SELECT * FROM TEST ORDER BY G DESC;
+> G
+> -----------
+> POINT (3 0)
+> POINT (2 2)
+> POINT (1 1)
+> rows (ordered): 3
+
+DROP TABLE TEST;
+> ok
+
+CREATE TABLE TEST(ID INT);
+> ok
+
+INSERT INTO TEST VALUES 1, 2;
+> update count: 2
+
+SELECT _ROWID_, * FROM TEST ORDER BY _ROWID_ DESC;
+> _ROWID_ ID
+> ------- --
+> 2       2
+> 1       1
+> rows (ordered): 2
+
+DROP TABLE TEST;
+> ok
diff --git a/h2/src/test/org/h2/test/scripts/queries/joins.sql b/h2/src/test/org/h2/test/scripts/queries/joins.sql
index 73ad936453..955dcdcd19 100644
--- a/h2/src/test/org/h2/test/scripts/queries/joins.sql
+++ b/h2/src/test/org/h2/test/scripts/queries/joins.sql
@@ -122,7 +122,7 @@ CREATE TABLE TESTB(ID IDENTITY);
 > ok
 
 explain SELECT TESTA.ID A, TESTB.ID B FROM TESTA, TESTB ORDER BY TESTA.ID, TESTB.ID;
->> SELECT "TESTA"."ID" AS "A", "TESTB"."ID" AS "B" FROM "PUBLIC"."TESTA" /* PUBLIC.TESTA.tableScan */ INNER JOIN "PUBLIC"."TESTB" /* PUBLIC.TESTB.tableScan */ ON 1=1 ORDER BY 1, 2
+>> SELECT "TESTA"."ID" AS "A", "TESTB"."ID" AS "B" FROM "PUBLIC"."TESTA" /* PUBLIC.PRIMARY_KEY_4 */ INNER JOIN "PUBLIC"."TESTB" /* PUBLIC.TESTB.tableScan */ ON 1=1 ORDER BY 1, 2 /* index sorted: 1 of 2 columns */
 
 DROP TABLE IF EXISTS TESTA, TESTB;
 > ok
diff --git a/h2/src/test/org/h2/test/scripts/queries/select.sql b/h2/src/test/org/h2/test/scripts/queries/select.sql
index ab189dbfe7..e41af76749 100644
--- a/h2/src/test/org/h2/test/scripts/queries/select.sql
+++ b/h2/src/test/org/h2/test/scripts/queries/select.sql
@@ -1167,7 +1167,7 @@ SELECT A, 1 AS X, B FROM TEST ORDER BY A, X, B DESC;
 > rows (ordered): 4
 
 EXPLAIN SELECT A, 1 AS X, B FROM TEST ORDER BY A, X, B DESC;
->> SELECT "A", 1 AS "X", "B" FROM "PUBLIC"."TEST" /* PUBLIC.TEST.tableScan */ ORDER BY 1, 2, 3 DESC
+>> SELECT "A", 1 AS "X", "B" FROM "PUBLIC"."TEST" /* PUBLIC.TEST_IDX */ ORDER BY 1, 2, 3 DESC /* index sorted: 1 of 3 columns */
 
 DROP TABLE TEST;
 > ok
@@ -1214,3 +1214,49 @@ drop table test;
 
 SELECT X, FROM (VALUES 1) T(X);
 > exception SYNTAX_ERROR_2
+
+CREATE TABLE TEST(A INT, B INT, C INT);
+> ok
+
+INSERT INTO TEST SELECT 1, X, X FROM SYSTEM_RANGE(1, 10);
+> update count: 10
+
+CREATE INDEX I1 ON TEST(A, B);
+> ok
+
+CREATE INDEX I2 ON TEST(A, C);
+> ok
+
+EXPLAIN SELECT * FROM TEST WHERE A = 1 AND B = 1 ORDER BY A, B, C;
+>> SELECT "PUBLIC"."TEST"."A", "PUBLIC"."TEST"."B", "PUBLIC"."TEST"."C" FROM "PUBLIC"."TEST" /* PUBLIC.I1: A = 1 AND B = 1 */ WHERE ("A" = 1) AND ("B" = 1) ORDER BY 1, 2, 3 /* index sorted: 2 of 3 columns */
+
+DROP TABLE TEST;
+> ok
+
+CREATE TABLE TEST(A INT, B INT);
+> ok
+
+CREATE INDEX IA ON TEST(A);
+> ok
+
+INSERT INTO TEST VALUES (1, 2), (1, 1), (2, 3), (2, 3);
+> update count: 4
+
+EXPLAIN SELECT * FROM TEST ORDER BY A, B OFFSET 1 ROW FETCH NEXT 1 ROW WITH TIES;
+>> SELECT "PUBLIC"."TEST"."A", "PUBLIC"."TEST"."B" FROM "PUBLIC"."TEST" /* PUBLIC.IA */ ORDER BY 1, 2 OFFSET 1 ROW FETCH NEXT ROW WITH TIES /* index sorted: 1 of 2 columns */
+
+SELECT * FROM TEST ORDER BY A, B OFFSET 1 ROW FETCH NEXT 1 ROW WITH TIES;
+> A B
+> - -
+> 1 2
+> rows (ordered): 1
+
+SELECT * FROM TEST ORDER BY A, B OFFSET 2 ROWS FETCH NEXT 1 ROW WITH TIES;
+> A B
+> - -
+> 2 3
+> 2 3
+> rows (ordered): 2
+
+DROP TABLE TEST;
+> ok
diff --git a/h2/src/test/org/h2/test/scripts/testScript.sql b/h2/src/test/org/h2/test/scripts/testScript.sql
index 208507f15d..f4031f0ade 100644
--- a/h2/src/test/org/h2/test/scripts/testScript.sql
+++ b/h2/src/test/org/h2/test/scripts/testScript.sql
@@ -2542,7 +2542,7 @@ INSERT INTO TEST VALUES(1, 'Hello');
 > update count: 1
 
 explain select t0.id, t1.id from test t0, test t1 order by t0.id, t1.id;
->> SELECT "T0"."ID", "T1"."ID" FROM "PUBLIC"."TEST" "T0" /* PUBLIC.TEST.tableScan */ INNER JOIN "PUBLIC"."TEST" "T1" /* PUBLIC.TEST.tableScan */ ON 1=1 ORDER BY 1, 2
+>> SELECT "T0"."ID", "T1"."ID" FROM "PUBLIC"."TEST" "T0" /* PUBLIC.PRIMARY_KEY_2 */ INNER JOIN "PUBLIC"."TEST" "T1" /* PUBLIC.TEST.tableScan */ ON 1=1 ORDER BY 1, 2 /* index sorted: 1 of 2 columns */
 
 INSERT INTO TEST VALUES(2, 'World');
 > update count: 1
diff --git a/h2/src/test/org/h2/test/server/TestWeb.java b/h2/src/test/org/h2/test/server/TestWeb.java
index de2890b880..5eb569c88a 100644
--- a/h2/src/test/org/h2/test/server/TestWeb.java
+++ b/h2/src/test/org/h2/test/server/TestWeb.java
@@ -566,8 +566,7 @@ private void testWebApp() throws Exception {
     private void testSpecialAutoComplete() throws Exception {
         Server server = new Server();
         server.setOut(new PrintStream(new ByteArrayOutputStream()));
-        server.runTool("-ifNotExists", "-web", "-webPort", "8182",
-                       "-properties", "null", "-tcp", "-tcpPort", "9101");
+        server.runTool("-ifNotExists", "-web", "-webPort", "8182", "-properties", "null", "-tcp", "-tcpPort", "9101");
         try {
             String url = "http://localhost:8182";
             WebClient client;
@@ -578,19 +577,19 @@ private void testSpecialAutoComplete() throws Exception {
             client.get(url, "login.jsp");
 
             result = client.get(url, "login.do?driver=org.h2.Driver" +
-                                     "&url=jdbc:h2:mem:" + getTestName() +
-                                     "&user=sa&password=sa&name=_test_");
+                    "&url=jdbc:h2:mem:" + getTestName() +
+                    "&user=sa&password=sa&name=_test_");
             result = client.get(url, "header.jsp");
 
             result = client.get(url, "query.do?sql=" +
-                                     "create schema test_schema;" +
-                                     "create schema \"quoted schema\";" +
-                                     "create table test_schema.test_table(id int primary key, name varchar);" +
-                                     "insert into test_schema.test_table values(1, 'Hello');" +
-                                     "create table \"quoted schema\".\"quoted tablename\"(id int primary key, name varchar);");
+                    "create schema test_schema;" +
+                    "create schema \"quoted schema\";" +
+                    "create table test_schema.test_table(id int primary key, name varchar);" +
+                    "insert into test_schema.test_table values(1, 'Hello');" +
+                    "create table \"quoted schema\".\"quoted tablename\"(id int primary key, name varchar);");
             result = client.get(url, "query.do?sql=create sequence test_schema.test_sequence");
             result = client.get(url, "query.do?sql=" +
-                                     "create view test_schema.test_view as select * from test");
+                    "create view test_schema.test_view as select * from test");
             result = client.get(url, "tables.do");
 
             result = client.get(url, "query.jsp");
diff --git a/h2/src/tools/org/h2/build/doc/dictionary.txt b/h2/src/tools/org/h2/build/doc/dictionary.txt
index 6b80fcadab..c529020d86 100644
--- a/h2/src/tools/org/h2/build/doc/dictionary.txt
+++ b/h2/src/tools/org/h2/build/doc/dictionary.txt
@@ -856,4 +856,4 @@ bck clo cur hwm materializedview udca vol connectionpooldatasource xadatasource
 ampm sssssff sstzh tzs yyyysssss newsequentialid solidus openjdk furthermore ssff secons nashorn fractions
 btrim underscores ffl decomposed decomposition subfield infinities retryable salted establish
 hatchet fis loom birthdate penrosed eve graalvm roberto polyglot truffle scriptengine unstarted conversation
-recompilations
+recompilations normalizer tablename tablenames