Use an index to find rows in the next page in the BlockTxs query

The indexer was using SQL's `skip` for the pagination. The DB should
scan the number of skipped rows, to get the page result. For the
performance enhancement, we concluded that change the pagination
method. Finding a particular row using an index and get the following
`n` rows is much faster than using `skip`.

This commit uses `firstEvaluatedKey` and `lastEvaluatedKey` for the
pagination in the BlockTxs query. The BlockTxs query will
find a row using `firstEvaluatedKey` or `lastEvaluatedKey` and returns
next `n` rows.

Author: majecty

src/models/logic/transaction.ts

@@ -15,6 +15,7 @@ import {
     pendingTxPagination,
     txPagination
 } from "../../routers/pagination";
+import { blockTxPagination } from "../../routers/pagination";
 import { AddressLogType } from "../addressLog";
 import models from "../index";
 import { TransactionAttribute, TransactionInstance } from "../transaction";
@@ -811,15 +812,41 @@ export async function getTransactionsOfBlock(params: {
     page: number;
     itemsPerPage: number;
     blockNumber: number;
+    firstEvaluatedKey?: number[] | null;
+    lastEvaluatedKey?: number[] | null;
 }) {
     try {
-        const { page, itemsPerPage, blockNumber } = params;
+        const {
+            page,
+            itemsPerPage,
+            blockNumber,
+            firstEvaluatedKey,
+            lastEvaluatedKey
+        } = params;
+
+        const whereCond: any[] = [{ blockNumber }];
+        if (firstEvaluatedKey || lastEvaluatedKey) {
+            whereCond.push(
+                blockTxPagination.where({
+                    firstEvaluatedKey,
+                    lastEvaluatedKey
+                })
+            );
+        }
 
         return models.Transaction.findAll({
-            where: { blockNumber },
-            order: [["transactionIndex", "DESC"]],
+            where: {
+                [Sequelize.Op.and]: whereCond
+            },
+            order: blockTxPagination.orderby({
+                firstEvaluatedKey,
+                lastEvaluatedKey
+            }),
             limit: itemsPerPage,
-            offset: (page - 1) * itemsPerPage,
+            offset:
+                firstEvaluatedKey || lastEvaluatedKey
+                    ? 0
+                    : (page - 1) * itemsPerPage,
             include: [...fullIncludeArray]
         });
     } catch (err) {
@@ -828,6 +855,10 @@ export async function getTransactionsOfBlock(params: {
     }
 }
 
+export function createBlockTxEvaluatedKey(tx: TransactionAttribute) {
+    return JSON.stringify([tx.transactionIndex]);
+}
+
 export async function getNumberOfEachTransactionType(
     params: {
         blockNumber: number;

src/routers/block.ts

@@ -12,6 +12,7 @@ import { createPaginationResult } from "./pagination";
 import {
     blockPaginationSchema,
     blockSchema,
+    blockTxPaginationSchema,
     paginationSchema,
     syncSchema,
     validate
@@ -209,6 +210,16 @@ export function handle(context: IndexerContext, router: Router) {
      *         in: query
      *         required: false
      *         type: number
+     *       - name: firstEvaluatedKey
+     *         description: the evaulated key of the first item in the previous page. It will be used for the pagination
+     *         in: query
+     *         required: false
+     *         type: string
+     *       - name: lastEvaluatedKey
+     *         description: the evaulated key of the last item in the previous page. It will be used for the pagination
+     *         in: query
+     *         required: false
+     *         type: string
      *     responses:
      *       200:
      *         description: Transactions
@@ -219,10 +230,12 @@ export function handle(context: IndexerContext, router: Router) {
      */
     router.get(
         "/block/:hashOrNumber/tx",
+        parseEvaluatedKey,
         validate({
             // FIXME: Throw an error if hashOrNumber is not hash or number
             query: {
-                ...paginationSchema
+                ...paginationSchema,
+                ...blockTxPaginationSchema
             }
         }),
         async (req, res, next) => {
@@ -232,17 +245,32 @@ export function handle(context: IndexerContext, router: Router) {
                 (req.query.itemsPerPage &&
                     parseInt(req.query.itemsPerPage, 10)) ||
                 15;
+            const firstEvaluatedKey = req.query.firstEvaluatedKey;
+            const lastEvaluatedKey = req.query.lastEvaluatedKey;
 
             try {
                 const block =
                     H256.check(hashOrNumber) &&
                     (await BlockModel.getByHash(new H256(hashOrNumber)));
                 const txs = await TransactionModel.getTransactionsOfBlock({
                     page,
-                    itemsPerPage,
-                    blockNumber: block ? block.get().number : hashOrNumber
+                    itemsPerPage: itemsPerPage + 1,
+                    blockNumber: block ? block.get().number : hashOrNumber,
+                    firstEvaluatedKey,
+                    lastEvaluatedKey
                 });
-                res.json(txs.map(tx => tx.get({ plain: true })));
+                res.json(
+                    createPaginationResult({
+                        query: {
+                            firstEvaluatedKey,
+                            lastEvaluatedKey
+                        },
+                        rows: txs.map(tx => tx.get({ plain: true })),
+                        getEvaluatedKey:
+                            TransactionModel.createBlockTxEvaluatedKey,
+                        itemsPerPage
+                    })
+                );
             } catch (e) {
                 next(e);
             }

src/routers/pagination.ts

@@ -144,6 +144,44 @@ export const blockPagination = {
     }
 };
 
+export const blockTxPagination = {
+    forwardOrder: [["transactionIndex", "DESC"]],
+    reverseOrder: [["transactionIndex", "ASC"]],
+    orderby: (params: {
+        firstEvaluatedKey?: number[] | null;
+        lastEvaluatedKey?: number[] | null;
+    }) => {
+        const order = queryOrder(params);
+        if (order === "forward") {
+            return blockTxPagination.forwardOrder;
+        } else if (order === "reverse") {
+            return blockTxPagination.reverseOrder;
+        }
+    },
+    where: (params: {
+        firstEvaluatedKey?: number[] | null;
+        lastEvaluatedKey?: number[] | null;
+    }) => {
+        const order = queryOrder(params);
+        const { firstEvaluatedKey, lastEvaluatedKey } = params;
+        if (order === "forward") {
+            const transactionIndex = lastEvaluatedKey![0];
+            return {
+                transactionIndex: {
+                    [Sequelize.Op.lt]: transactionIndex
+                }
+            };
+        } else if (order === "reverse") {
+            const transactionIndex = firstEvaluatedKey![0];
+            return {
+                transactionIndex: {
+                    [Sequelize.Op.gt]: transactionIndex
+                }
+            };
+        }
+    }
+};
+
 export const aggsUTXOPagination = {
     byAssetType: {
         forwardOrder: [["assetType", "DESC"]],

src/routers/validator.ts

@@ -88,6 +88,11 @@ export const blockPaginationSchema = {
     firstEvaluatedKey: blockEvaluationKey
 };
 
+export const blockTxPaginationSchema = {
+    firstEvaluatedKey: Joi.array().items(Joi.number()),
+    lastEvaluatedKey: Joi.array().items(Joi.number())
+};
+
 export const aggsUTXOPaginationSchema = {
     firstEvaluatedKey: Joi.array().items(Joi.string()),
     lastEvaluatedKey: Joi.array().items(Joi.string())