import nxt.db.DbClause; //导入依赖的package包/类
@Override
public void notify(Block block) {
    if (block.getHeight() <= Constants.MONETARY_SYSTEM_BLOCK) {
        return;
    }
    try (DbIterator<Currency> issuedCurrencies = currencyTable.getManyBy(new DbClause.IntClause("issuance_height", block.getHeight()), 0, -1)) {
        for (Currency currency : issuedCurrencies) {
            if (currency.getCurrentReservePerUnitNQT() < currency.getMinReservePerUnitNQT()) {
                listeners.notify(currency, Event.BEFORE_UNDO_CROWDFUNDING);
                undoCrowdFunding(currency);
            } else {
                listeners.notify(currency, Event.BEFORE_DISTRIBUTE_CROWDFUNDING);
                distributeCurrency(currency);
            }
        }
    }
}
 

import nxt.db.DbClause; //导入依赖的package包/类
public static Map<Long,Long> getVoters(Poll poll) {
    Map<Long,Long> map = new HashMap<>();
    try (DbIterator<Vote> voteIterator = voteTable.getManyBy(new DbClause.LongClause("poll_id", poll.getId()), 0, -1)) {
        while (voteIterator.hasNext()) {
            Vote vote = voteIterator.next();
            map.put(vote.getVoterId(), vote.getId());
        }
    }
    return map;
}
 

import nxt.db.DbClause; //导入依赖的package包/类
public static DbIterator<Ask> getAskOrdersByAccountAsset(final long accountId, final long assetId, int from, int to) {
    DbClause dbClause = new DbClause(" account_id = ? AND asset_id = ? ") {
        @Override
        public int set(PreparedStatement pstmt, int index) throws SQLException {
            pstmt.setLong(index++, accountId);
            pstmt.setLong(index++, assetId);
            return index;
        }
    };
    return askOrderTable.getManyBy(dbClause, from, to);
}
 

import nxt.db.DbClause; //导入依赖的package包/类
public static DbIterator<Bid> getBidOrdersByAccountAsset(final long accountId, final long assetId, int from, int to) {
    DbClause dbClause = new DbClause(" account_id = ? AND asset_id = ? ") {
        @Override
        public int set(PreparedStatement pstmt, int index) throws SQLException {
            pstmt.setLong(index++, accountId);
            pstmt.setLong(index++, assetId);
            return index;
        }
    };
    return bidOrderTable.getManyBy(dbClause, from, to);
}
 

import nxt.db.DbClause; //导入依赖的package包/类
private static DbClause getEscrowParticipentClause(final long accountId) {
	return new DbClause(" (sender_id = ? OR recipient_id = ?) ") {
		@Override
        public int set(PreparedStatement pstmt, int index) throws SQLException {
            pstmt.setLong(index++, accountId);
            pstmt.setLong(index++, accountId);
            return index;
        }
	};
}
 

import nxt.db.DbClause; //导入依赖的package包/类
public static Collection<Escrow> getEscrowTransactionsByParticipent(Long accountId) {
	List<Escrow> filtered = new ArrayList<>();
	DbIterator<Decision> it = decisionTable.getManyBy(new DbClause.LongClause("account_id", accountId), 0, -1);
	while(it.hasNext()) {
		Decision decision = it.next();
		Escrow escrow = escrowTable.get(escrowDbKeyFactory.newKey(decision.escrowId));
		if(escrow != null) {
			filtered.add(escrow);
		}
	}
	return filtered;
}
 

import nxt.db.DbClause; //导入依赖的package包/类
private static DbClause getUpdateOnBlockClause(final int timestamp) {
	return new DbClause(" deadline < ? ") {
		@Override
		public int set(PreparedStatement pstmt, int index) throws SQLException {
			pstmt.setInt(index++, timestamp);
			return index;
		}
	};
}
 

import nxt.db.DbClause; //导入依赖的package包/类
private static DbClause getAccountsWithRewardRecipientClause(final long id, final int height) {
	return new DbClause(" recip_id = ? AND from_height <= ? ") {
		@Override
		public int set(PreparedStatement pstmt, int index) throws SQLException {
			pstmt.setLong(index++, id);
			pstmt.setInt(index++, height);
			return index;
		}
	};
}
 

import nxt.db.DbClause; //导入依赖的package包/类
public static DbIterator<Goods> getGoodsInStock(int from, int to) {
    DbClause dbClause = new DbClause(" delisted = FALSE AND quantity > 0 ") {
        @Override
        public int set(PreparedStatement pstmt, int index) throws SQLException {
            return index;
        }
    };
    return Goods.goodsTable.getManyBy(dbClause, from, to);
}
 

import nxt.db.DbClause; //导入依赖的package包/类
public static DbIterator<Goods> getSellerGoods(final long sellerId, final boolean inStockOnly, int from, int to) {
    DbClause dbClause = new DbClause(" seller_id = ? " + (inStockOnly ? "AND delisted = FALSE AND quantity > 0" : "")) {
        @Override
        public int set(PreparedStatement pstmt, int index) throws SQLException {
            pstmt.setLong(index++, sellerId);
            return index;
        }
    };
    return Goods.goodsTable.getManyBy(dbClause, from, to, " ORDER BY name ASC, timestamp DESC, id ASC ");
}
 

import nxt.db.DbClause; //导入依赖的package包/类
public static DbIterator<Purchase> getSellerBuyerPurchases(final long sellerId, final long buyerId, int from, int to) {
    DbClause dbClause = new DbClause(" seller_id = ? AND buyer_id = ? ") {
        @Override
        public int set(PreparedStatement pstmt, int index) throws SQLException {
            pstmt.setLong(index++, sellerId);
            pstmt.setLong(index++, buyerId);
            return index;
        }
    };
    return Purchase.purchaseTable.getManyBy(dbClause, from, to);
}
 

import nxt.db.DbClause; //导入依赖的package包/类
public static DbIterator<Purchase> getPendingSellerPurchases(final long sellerId, int from, int to) {
    DbClause dbClause = new DbClause(" seller_id = ? AND pending = TRUE ") {
        @Override
        public int set(PreparedStatement pstmt, int index) throws SQLException {
            pstmt.setLong(index++, sellerId);
            return index;
        }
    };
    return Purchase.purchaseTable.getManyBy(dbClause, from, to);
}
 

import nxt.db.DbClause; //导入依赖的package包/类
private static DbIterator<Purchase> getExpiredPendingPurchases(final int timestamp) {
       DbClause dbClause = new DbClause(" deadline < ? AND pending = TRUE ") {
           @Override
           public int set(PreparedStatement pstmt, int index) throws SQLException {
               pstmt.setLong(index++, timestamp);
               return index;
           }
       };
       return Purchase.purchaseTable.getManyBy(dbClause, 0, -1);
}
 

import nxt.db.DbClause; //导入依赖的package包/类
private static DbClause getByParticipantClause(final long id) {
	return new DbClause(" (sender_id = ? OR recipient_id = ?) ") {
		@Override
		public int set(PreparedStatement pstmt, int index) throws SQLException {
			pstmt.setLong(index++, id);
			pstmt.setLong(index++, id);
			return index;
		}
	};
}
 

import nxt.db.DbClause; //导入依赖的package包/类
private static DbClause getUpdateOnBlockClause(final int timestamp) {
	return new DbClause(" time_next <= ? ") {
		@Override
		public int set(PreparedStatement pstmt, int index) throws SQLException {
			pstmt.setInt(index++, timestamp);
			return index;
		}
	};
}
 

import nxt.db.DbClause; //导入依赖的package包/类
public static DbIterator<Poll> getPollsByAccount(long accountId, boolean includeFinished, int from, int to) {
    DbClause dbClause = new DbClause.LongClause("account_id", accountId);
    if (!includeFinished) {
        dbClause = dbClause.and(new DbClause.IntClause("finish_height", DbClause.Op.GT, Nxt.getBlockchain().getHeight()));
    }
    return pollTable.getManyBy(dbClause, from, to);
}
 

import nxt.db.DbClause; //导入依赖的package包/类
static void deleteCurrency(Currency currency) {
    List<CurrencyMint> currencyMints = new ArrayList<>();
    try (DbIterator<CurrencyMint> mints = currencyMintTable.getManyBy(new DbClause.LongClause("currency_id", currency.getId()), 0, -1)) {
        while (mints.hasNext()) {
            currencyMints.add(mints.next());
        }
    }
    for (CurrencyMint mint : currencyMints) {
        currencyMintTable.delete(mint);
    }
}
 

import nxt.db.DbClause; //导入依赖的package包/类
public static DbIterator<CurrencyBuyOffer> getOffers(Currency currency, boolean availableOnly, int from, int to) {
    DbClause dbClause = new DbClause.LongClause("currency_id", currency.getId());
    if (availableOnly) {
        dbClause = dbClause.and(availableOnlyDbClause);
    }
    return buyOfferTable.getManyBy(dbClause, from, to, " ORDER BY rate DESC, creation_height ASC, transaction_index ASC ");
}
 

import nxt.db.DbClause; //导入依赖的package包/类
public static DbIterator<Purchase> getGoodsPurchases(long goodsId, long buyerId, boolean withPublicFeedbacksOnly, boolean completedOnly, int from, int to) {
    DbClause clause = new LongPurchasesClause("goods_id", goodsId, withPublicFeedbacksOnly, completedOnly);
    if (buyerId != 0) {
        clause = clause.and(new DbClause.LongClause("buyer_id", buyerId));
    }
    return purchaseTable.getManyBy(clause, from, to);
}
 

import nxt.db.DbClause; //导入依赖的package包/类
private DbClause getLessorsClause(final int height) {
    return new DbClause(" current_lessee_id = ? AND current_leasing_height_from <= ? AND current_leasing_height_to > ? ") {
        @Override
        public int set(PreparedStatement pstmt, int index) throws SQLException {
            pstmt.setLong(index++, getId());
            pstmt.setInt(index++, height);
            pstmt.setInt(index++, height);
            return index;
        }
    };
}