Use an index to find rows in the next page in the BalanceHistory 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 BalanceHistory query. The BalanceHistory query will
find a row using `firstEvaluatedKey` or `lastEvaluatedKey` and returns
next `n` rows.

Author: Park Juhyung

src/models/cccChanges.ts

@@ -22,6 +22,7 @@ export const defaultAllReasons = [
 ];
 
 export interface CCCChangeAttribute {
+    id?: string;
     address: string;
     change: string;
     blockNumber: number;

src/models/logic/cccChange.ts

@@ -2,7 +2,13 @@ import { U64 } from "codechain-sdk/lib/core/classes";
 import { Transaction } from "sequelize";
 import * as Sequelize from "sequelize";
 import * as Exception from "../../exception";
-import { CCCChangeInstance, defaultAllReasons, Reason } from "../cccChanges";
+import { cccChangesPagination } from "../../routers/pagination";
+import {
+    CCCChangeAttribute,
+    CCCChangeInstance,
+    defaultAllReasons,
+    Reason
+} from "../cccChanges";
 import models from "../index";
 
 async function createCCCChange(
@@ -210,23 +216,45 @@ export async function getByAddress(
         page: number;
         itemsPerPage: number;
         reasonFilter?: string[];
+        firstEvaluatedKey?: number[] | null;
+        lastEvaluatedKey?: number[] | null;
     }
 ): Promise<CCCChangeInstance[]> {
-    const { page, itemsPerPage, reasonFilter = defaultAllReasons } = option;
+    const {
+        page,
+        itemsPerPage,
+        reasonFilter = defaultAllReasons,
+        firstEvaluatedKey,
+        lastEvaluatedKey
+    } = option;
     try {
+        const whereCond: any[] = [
+            {
+                address,
+                reason: {
+                    [Sequelize.Op.in]: reasonFilter
+                }
+            }
+        ];
+        if (firstEvaluatedKey || lastEvaluatedKey) {
+            whereCond.push(
+                cccChangesPagination.byAccount.where({
+                    firstEvaluatedKey,
+                    lastEvaluatedKey
+                })
+            );
+        }
         return await models.CCCChange.findAll({
             attributes: [
+                "id",
                 "address",
                 "change",
                 "blockNumber",
                 "reason",
                 "transactionHash"
             ],
             where: {
-                address,
-                reason: {
-                    [Sequelize.Op.in]: reasonFilter
-                }
+                [Sequelize.Op.and]: whereCond
             },
             include: [
                 {
@@ -236,15 +264,23 @@ export async function getByAddress(
                 }
             ],
             limit: itemsPerPage,
-            offset: (page - 1) * itemsPerPage,
-            order: [["blockNumber", "DESC"], ["id", "DESC"]]
+            offset:
+                firstEvaluatedKey || lastEvaluatedKey
+                    ? 0
+                    : (page - 1) * itemsPerPage,
+            order: [["blockNumber", "DESC"], ["id", "DESC"]],
+            logging: console.log
         });
     } catch (err) {
         console.error(err);
         throw Exception.DBError();
     }
 }
 
+export function createCCCChangesEvaluatedKey(cccChange: CCCChangeAttribute) {
+    return JSON.stringify([cccChange.blockNumber, cccChange.id]);
+}
+
 export async function getCountByAddress(
     address: string,
     option: {

src/routers/account.ts

@@ -2,7 +2,10 @@ import { Router } from "express";
 import { IndexerContext } from "../context";
 import * as AccountModel from "../models/logic/account";
 import * as CCCChangeModel from "../models/logic/cccChange";
+import { parseEvaluatedKey } from "../models/logic/utils/middleware";
+import { createPaginationResult } from "./pagination";
 import {
+    accountBalanceHistoryPaginationSchema,
     paginationSchema,
     platformAddressSchema,
     reasonFilterSchema,
@@ -131,6 +134,16 @@ export function handle(_C: 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: account
@@ -155,9 +168,14 @@ export function handle(_C: IndexerContext, router: Router) {
      */
     router.get(
         "/account/:address/balance-history",
+        parseEvaluatedKey,
         validate({
             params: { address: platformAddressSchema },
-            query: { ...reasonFilterSchema, ...paginationSchema }
+            query: {
+                ...reasonFilterSchema,
+                ...paginationSchema,
+                ...accountBalanceHistoryPaginationSchema
+            }
         }),
         async (req, res, next) => {
             const reasonFilter = req.query.reasonFilter;
@@ -166,16 +184,37 @@ export function handle(_C: IndexerContext, router: Router) {
             const itemsPerPage = req.query.itemsPerPage
                 ? parseInt(req.query.itemsPerPage, 10)
                 : 15;
+
+            const lastEvaluatedKey = req.query.lastEvaluatedKey;
+            const firstEvaluatedKey = req.query.firstEvaluatedKey;
+
             try {
                 const accounts = await CCCChangeModel.getByAddress(address, {
                     page,
-                    itemsPerPage,
+                    itemsPerPage: itemsPerPage + 1,
                     reasonFilter:
                         typeof reasonFilter === "string"
                             ? reasonFilter.split(",")
-                            : undefined
+                            : undefined,
+                    firstEvaluatedKey,
+                    lastEvaluatedKey
                 });
-                res.json(accounts.map(account => account.get({ plain: true })));
+
+                res.json(
+                    createPaginationResult({
+                        query: {
+                            firstEvaluatedKey,
+                            lastEvaluatedKey
+                        },
+                        rows: accounts.map(account =>
+                            account.get({ plain: true })
+                        ),
+                        getEvaluatedKey:
+                            CCCChangeModel.createCCCChangesEvaluatedKey,
+                        itemsPerPage
+                    })
+                );
+                res.json();
             } catch (e) {
                 next(e);
             }

src/routers/pagination.ts

@@ -335,6 +335,42 @@ export const addressLogPagination = {
     }
 };
 
+export const cccChangesPagination = {
+    byAccount: {
+        forwardOrder: [["blockNumber", "DESC"], ["id", "DESC"]],
+        reverseOrder: [["blockNumber", "ASC"], ["id", "ASC"]],
+        orderby: (params: {
+            firstEvaluatedKey?: number[] | null;
+            lastEvaluatedKey?: number[] | null;
+        }) => {
+            const order = queryOrder(params);
+            if (order === "forward") {
+                return cccChangesPagination.byAccount.forwardOrder;
+            } else if (order === "reverse") {
+                return cccChangesPagination.byAccount.reverseOrder;
+            }
+        },
+        where: (params: {
+            firstEvaluatedKey?: number[] | null;
+            lastEvaluatedKey?: number[] | null;
+        }) => {
+            const order = queryOrder(params);
+            const { firstEvaluatedKey, lastEvaluatedKey } = params;
+            if (order === "forward") {
+                const [blockNumber, id] = lastEvaluatedKey!;
+                return Sequelize.literal(
+                    `("CCCChange"."blockNumber", "id")<(${blockNumber}, ${id})`
+                );
+            } else if (order === "reverse") {
+                const [blockNumber, id] = firstEvaluatedKey!;
+                return Sequelize.literal(
+                    `("CCCChange"."blockNumber", "id")>(${blockNumber}, ${id})`
+                );
+            }
+        }
+    }
+};
+
 export const pendingTxPagination = {
     forwardOrder: [["pendingTimestamp", "DESC"]],
     reverseOrder: [["pendingTimestamp", "ASC"]],

src/routers/validator.ts

@@ -116,6 +116,11 @@ export const snapshotPaginationSchema = {
     )
 };
 
+export const accountBalanceHistoryPaginationSchema = {
+    firstEvaluatedKey: Joi.array().items(Joi.number(), Joi.string()),
+    lastEvaluatedKey: Joi.array().items(Joi.number(), Joi.string())
+};
+
 export const txSchema = {
     address,
     assetType: assetTypeSchema,