这种Hibernate方法效率很低吗？

Question

This function is a piece of a Hibernate program I am writing to do some back-end bulk processing for a university financial system. It gets called several hundred thousand times when the program executes, and these calls are the single biggest time-sink in the program. For the moment I cannot think of a plausible way to call it less often.

This function takes a fiscal year pay period ("fypper") and a week in that period as arguments, and returns a construct ("AidYearTerm") that stores the year, semester, and term that the pay period week falls in.

public  AidYearTerm FypperTermInfo (String fypper, String week) {

    sfa_fws_calendar aidYear = new sfa_fws_calendar();      

    TypedQuery<sfa_fws_calendar> query = manager.createQuery("FROM sfa_fws_calendar cal "
            + "WHERE cal.id.fypper = ?1 AND cal.id.week_num = ?2",sfa_fws_calendar.class);
    query.setParameter(1, fypper);
    query.setParameter(2, week);

    List<sfa_fws_calendar> aidYearList = query.getResultList();

    if(!aidYearList.isEmpty()) {
        aidYear = query.getSingleResult();
    }
    else {
        aidYear.setFWS_AID_YR("9999");
        aidYear.setSEM("NOTSET");
        aidYear.setTERM("NOTSET");
        ErrorOut("Could not find term info for "+fypper);
    }
    DebugOut("found aid year "+aidYear.getFWS_AID_YR()+", term "+aidYear.getTERM());

    AidYearTerm aidYearTerm = new AidYearTerm(aidYear.getFWS_AID_YR(),aidYear.getTERM(),aidYear.getSEM()); 
    return aidYearTerm;

}

Is there something I can do to make this simpler/faster?

Answer 1

The simplest and most obvious optimisation would be something like:

static final TypedQuery<sfa_fws_calendar> query = manager.createQuery("FROM sfa_fws_calendar cal "
        + "WHERE cal.id.fypper = ?1 AND cal.id.week_num = ?2", sfa_fws_calendar.class);

public AidYearTerm FypperTermInfo(String fypper, String week) {

    //...
    query.setParameter(1, fypper);
    query.setParameter(2, week);

    List<sfa_fws_calendar> aidYearList = query.getResultList();

Not sure of the overhead of calling createQuery but this would certainly only get that to happen once.

After that - if everything still runs at a crawl (and this is likely) you could consider some form of cacheing (perhaps ehcache ) but that would only be effective if there were a comparatively small number of fypper|week combinations.

Answer 2

At a first glance:

List<sfa_fws_calendar> aidYearList = query.getResultList();

if(!aidYearList.isEmpty()) {
    aidYear = query.getSingleResult(); // <========= DON'T!!!!!
}

Query.getSingleResult() runs the same query again!

Use:

List<sfa_fws_calendar> aidYearList = query.getResultList();

if(!aidYearList.isEmpty()) {
    aidYear = aidYearList.get(0);
}

Edit:

Assuming you don't have millions of records keyed by year and week, it seems feasible to read all required data from sfa_fws_calendar into memory only once, for example into a Map , to subsequently avoid thousands of round trips to the DB.

Note that, because fypper and week actually form a (string) composite key, you could build a single Map<String, AidYearTerm> , where the keys could be, for example, year + "_" + week . Then your FypperTermInfo (String fypper, String week) would just return aidYearCacheMap.get(fypper + "_" + week); and voilà :)

Answer 3

That looks like a pretty straightforward select, so I think this may be more of an issue around making sure Oracle runs it efficiently (especially since it's run many thousands of times per day). What kind of explain plan do you see for this query? Are there any full table scans? You may need to index sfa_fws_calendar table, or if there are already indices in place, alter the appropriate index and recompute the index statistics.

For example, something like this might help update an existing index called index_name:

ALTER INDEX index_name REBUILD COMPUTE STATISTICS;