Change the queries of getTransactions()

joojis · joojis · commit 6dbdbfda17ae · 2019-11-20T12:14:10.000+09:00
This patch also changes the indexes of the AssetTypeLogs and AddressLogs
tables for the API performance.
diff --git a/src/migrations/20191119050057-change-address-log-index.js b/src/migrations/20191119050057-change-address-log-index.js
@@ -0,0 +1,24 @@
+"use strict";
+
+const tableName = "AddressLogs";
+module.exports = {
+    up: async (queryInterface, Sequelize) => {
+        await queryInterface.addIndex(tableName, [
+            "address",
+            "blockNumber",
+            "transactionIndex"
+        ]);
+        await queryInterface.removeIndex(tableName, ["blockNumber"]);
+        await queryInterface.removeIndex(tableName, ["address"]);
+    },
+
+    down: async (queryInterface, Sequelize) => {
+        await queryInterface.addIndex(tableName, ["address"]);
+        await queryInterface.addIndex(tableName, ["blockNumber"]);
+        await queryInterface.removeIndex(tableName, [
+            "address",
+            "blockNumber",
+            "transactionIndex"
+        ]);
+    }
+};
diff --git a/src/migrations/20191119050110-change-asset-type-log-index.js b/src/migrations/20191119050110-change-asset-type-log-index.js
@@ -0,0 +1,22 @@
+"use strict";
+
+const tableName = "AssetTypeLogs";
+module.exports = {
+    up: async (queryInterface, Sequelize) => {
+        await queryInterface.addIndex(tableName, [
+            "assetType",
+            "blockNumber",
+            "transactionIndex"
+        ]);
+        await queryInterface.removeIndex(tableName, ["assetType"]);
+    },
+
+    down: async (queryInterface, Sequelize) => {
+        await queryInterface.addIndex(tableName, ["assetType"]);
+        await queryInterface.removeIndex(tableName, [
+            "assetType",
+            "blockNumber",
+            "transactionIndex"
+        ]);
+    }
+};
diff --git a/src/models/logic/transaction.ts b/src/models/logic/transaction.ts
@@ -1,12 +1,17 @@
 import * as assert from "assert";
 import { SDK } from "codechain-sdk";
-import { H160, H256, SignedTransaction } from "codechain-sdk/lib/core/classes";
+import {
+    AssetAddress,
+    H256,
+    PlatformAddress,
+    SignedTransaction
+} from "codechain-sdk/lib/core/classes";
 import * as _ from "lodash";
-import { Transaction } from "sequelize";
 import * as Sequelize from "sequelize";
+import { Transaction } from "sequelize";
 import * as Exception from "../../exception";
 import models from "../index";
-import { TransactionAttribute, TransactionInstance } from "../transaction";
+import { TransactionInstance } from "../transaction";
 import { createAddressLog } from "./addressLog";
 import { updateAssetScheme } from "./assetscheme";
 import { createChangeAssetScheme } from "./changeAssetScheme";
@@ -239,7 +244,7 @@ export async function applyTransaction(
 
 export async function getPendingTransactions(params: {
     address?: string | null;
-    assetType?: H160 | null;
+    assetType?: string | null;
     type?: string[] | null;
     page: number;
     itemsPerPage: number;
@@ -386,65 +391,129 @@ export async function removeOutdatedPendings(
     }
 }
 
-async function getTransactionHashes(params: {
-    address?: string | null;
-    assetType?: H160 | null;
+async function getHashesByPlatformAddress(params: {
+    address: string;
     page: number;
     itemsPerPage: number;
-    type?: string[] | null;
-    includePending?: boolean | null;
 }): Promise<string[]> {
-    const where: Sequelize.WhereOptions<TransactionAttribute> = {};
-    if (params.type != null) {
-        where.type = { [Sequelize.Op.in]: params.type };
+    const { address, page, itemsPerPage } = params;
+    try {
+        return models.AddressLog.findAll({
+            attributes: ["transactionHash"],
+            where: {
+                address
+            },
+            order: [["blockNumber", "DESC"], ["transactionIndex", "DESC"]],
+            limit: itemsPerPage,
+            offset: (page - 1) * itemsPerPage
+        }).map(r => r.get("transactionHash"));
+    } catch (err) {
+        console.error(err);
+        throw Exception.DBError();
     }
-    if (params.includePending !== true) {
-        where.isPending = false;
+}
+
+async function getHashesByAssetAddress(params: {
+    address: string;
+    assetType?: string | null;
+    page: number;
+    itemsPerPage: number;
+}): Promise<string[]> {
+    const { address, assetType, page, itemsPerPage } = params;
+    try {
+        return models.AssetAddressLog.findAll({
+            attributes: ["transactionHash"],
+            where: {
+                address,
+                ...(assetType && { assetType })
+            },
+            order: [["blockNumber", "DESC"], ["transactionIndex", "DESC"]],
+            limit: itemsPerPage,
+            offset: (page - 1) * itemsPerPage
+        }).map(r => r.get("transactionHash"));
+    } catch (err) {
+        console.error(err);
+        throw Exception.DBError();
     }
-    const { page, itemsPerPage, address, assetType } = params;
+}
+
+async function getHashesByAssetType(params: {
+    assetType: string;
+    page: number;
+    itemsPerPage: number;
+}): Promise<string[]> {
+    const { assetType, page, itemsPerPage } = params;
     try {
-        return await models.Transaction.findAll({
-            subQuery: false,
-            attributes: ["hash"],
-            where,
+        return models.AssetTypeLog.findAll({
+            attributes: ["transactionHash"],
+            where: {
+                assetType
+            },
             order: [["blockNumber", "DESC"], ["transactionIndex", "DESC"]],
             limit: itemsPerPage,
-            offset: (page - 1) * itemsPerPage,
-            ...(address || assetType
-                ? {
-                      group: [
-                          "Transaction.hash",
-                          "Transaction.blockNumber",
-                          "Transaction.transactionIndex"
-                      ],
-                      include: buildIncludeArray({
-                          address,
-                          assetType
-                      })
-                  }
-                : {})
-        }).map(result => result.get("hash"));
+            offset: (page - 1) * itemsPerPage
+        }).map(r => r.get("transactionHash"));
     } catch (err) {
         console.error(err);
-        return [];
+        throw Exception.DBError();
+    }
+}
+
+async function getHashes(params: {
+    address?: string | null;
+    assetType?: string | null;
+    page: number;
+    itemsPerPage: number;
+    type?: string[] | null;
+    includePending?: boolean | null;
+}): Promise<string[]> {
+    const { address, assetType, page, itemsPerPage } = params;
+    if (address != null && assetType != null) {
+        return getHashesByAssetAddress({
+            address,
+            assetType,
+            page,
+            itemsPerPage
+        });
+    } else if (address != null) {
+        if (AssetAddress.check(address)) {
+            return getHashesByAssetAddress({ address, page, itemsPerPage });
+        } else if (PlatformAddress.check(address)) {
+            return getHashesByPlatformAddress({ address, page, itemsPerPage });
+        }
+        throw Error(`Invalid address: ${address}`);
+    } else if (assetType != null) {
+        return getHashesByAssetType({ assetType, page, itemsPerPage });
     }
+    return models.Transaction.findAll({
+        attributes: ["hash"],
+        where: {
+            ...(params.type != null
+                ? { type: { [Sequelize.Op.in]: params.type } }
+                : {}),
+            ...(params.includePending !== true ? { isPending: false } : {})
+        },
+        order: [["blockNumber", "DESC"], ["transactionIndex", "DESC"]],
+        limit: itemsPerPage,
+        offset: (page - 1) * itemsPerPage
+    }).map(result => result.get("hash"));
 }
 
 export async function getTransactions(params: {
     address?: string | null;
-    assetType?: H160 | null;
+    assetType?: string | null;
     type?: string[] | null;
     page: number;
     itemsPerPage: number;
     includePending?: boolean | null;
     onlyConfirmed?: boolean | null;
     confirmThreshold?: number | null;
 }) {
-    const { address, assetType, itemsPerPage } = params;
+    const { itemsPerPage } = params;
     try {
         // TODO: Querying twice will waste IO bandwidth and take longer time as long as the response time
         //       Find a way to merge these queries.
-        const hashes = await getTransactionHashes(params);
+        const hashes = await getHashes(params);
         assert(
             hashes.length <= itemsPerPage,
             `The number of hashes(${
@@ -453,14 +522,10 @@ export async function getTransactions(params: {
         );
         return models.Transaction.findAll({
             where: {
-                hash: hashes,
-                ...buildQueryForTransactions(params)
+                hash: hashes
             },
             order: [["blockNumber", "DESC"], ["transactionIndex", "DESC"]],
-            include: [
-                ...fullIncludeArray,
-                ...buildIncludeArray({ address, assetType })
-            ]
+            include: [...fullIncludeArray]
         });
     } catch (err) {
         console.error(err);
@@ -511,17 +576,6 @@ export async function getNumberOfEachTransactionType(
     }
 }
 
-function buildQueryForTransactions(params: {
-    type?: string[] | null;
-    includePending?: boolean | null;
-}) {
-    return {
-        ...(params.type ? { type: { [Sequelize.Op.in]: params.type } } : {}),
-        ...(params.includePending !== true ? { isPending: false } : {})
-        /* FIXME: onlyConfirmed, confirmThreshold */
-    };
-}
-
 // @ts-ignore
 export async function deleteByHash(hash: H256) {
     try {
@@ -556,7 +610,7 @@ export async function getSuccessfulByTracker(
 
 function buildIncludeArray(params: {
     address?: string | null;
-    assetType?: H160 | null;
+    assetType?: string | null;
 }): Sequelize.IncludeOptions[] {
     const { address, assetType } = params;
     return [
@@ -578,9 +632,7 @@ function buildIncludeArray(params: {
                       model: models.AssetTypeLog,
                       as: "assetTypeLogs",
                       attributes: [],
-                      where: {
-                          assetType: assetType.value
-                      },
+                      where: { assetType },
                       required: true
                   }
               ])
diff --git a/src/routers/transaction.ts b/src/routers/transaction.ts
@@ -113,14 +113,11 @@ export function handle(context: IndexerContext, router: Router) {
             const confirmThreshold =
                 req.query.confirmThreshold &&
                 parseInt(req.query.confirmThreshold, 10);
-            let assetType;
             try {
-                if (assetTypeString) {
-                    assetType = new H160(assetTypeString);
-                }
                 const txInsts = await TxModel.getTransactions({
                     address,
-                    assetType,
+                    assetType:
+                        assetTypeString && H160.ensure(assetTypeString).value,
                     type:
                         typeof type === "string" ? type.split(",") : undefined,
                     page,
@@ -280,13 +277,10 @@ export function handle(context: IndexerContext, router: Router) {
             const page = req.query.page || 1;
             const itemsPerPage = req.query.itemsPerPage || 15;
             try {
-                let assetType;
-                if (assetTypeString) {
-                    assetType = new H160(assetTypeString);
-                }
                 const pendingTxInsts = await TxModel.getPendingTransactions({
                     address,
-                    assetType,
+                    assetType:
+                        assetTypeString && H160.ensure(assetTypeString).value,
                     type:
                         typeof type === "string" ? type.split(",") : undefined,
                     page,
diff --git a/test/api/transaction.spec.ts b/test/api/transaction.spec.ts
@@ -139,13 +139,32 @@ describe("transaction-api", function() {
         getBestBlockNumberStub.restore();
     });
 
-    it("api /tx with args", async function() {
+    it("api /tx with assetType filter", async function() {
         const assetType = mintRubyTx.getMintedAsset().assetType;
         await request(app)
-            .get(`/api/tx?assetType=${assetType}&type=mintAsset`)
+            .get(`/api/tx?assetType=${assetType}`)
             .expect(200)
             .expect(res =>
-                expect(Object.keys(JSON.parse(res.text)).length).equal(1)
+                expect(Object.keys(JSON.parse(res.text)).length).gte(1)
+            );
+    });
+
+    it("api /tx with address filter", async function() {
+        await request(app)
+            .get(`/api/tx?address=${aliceAddress.value}`)
+            .expect(200)
+            .expect(res =>
+                expect(Object.keys(JSON.parse(res.text)).length).gte(1)
+            );
+    });
+
+    it("api /tx with both assetType and address filters", async function() {
+        const assetType = mintRubyTx.getMintedAsset().assetType;
+        await request(app)
+            .get(`/api/tx?address=${aliceAddress.value}&assetType=${assetType}`)
+            .expect(200)
+            .expect(res =>
+                expect(Object.keys(JSON.parse(res.text)).length).gte(1)
             );
     });
 
