Changeset 7913 for TI01-discovery-API


Ignore:
Timestamp:
14/04/11 11:30:51 (8 years ago)
Author:
mnagni
Message:

Improved the db transactions. Version moved to 1.2.7

Location:
TI01-discovery-API/trunk/MEDINDiscoveryService
Files:
5 edited

Legend:

Unmodified
Added
Removed
  • TI01-discovery-API/trunk/MEDINDiscoveryService/pom.xml

    r7754 r7913  
    44        <groupId>ndg.services.discovery</groupId> 
    55        <artifactId>MedinDiscoveryService</artifactId> 
    6         <version>1.2.6</version> 
     6        <version>1.2.7</version> 
    77        <packaging>aar</packaging> 
    88 
  • TI01-discovery-API/trunk/MEDINDiscoveryService/src/main/java/ndg/services/discovery/DiscoveryServiceMEDINSkeleton.java

    r7609 r7913  
    199199                PresentAgent agent = new PresentAgent(); 
    200200                List<String> documentsId = new ArrayList<String>(); 
    201                 Connection conn = null; 
    202201                try { 
    203202                        for (SimpleDocument1 doc : doPresent.getDoPresent().getDocumentsArray()) { 
     
    205204                        } 
    206205                        RetrieveCriteriaType retrieveType = doPresent.getDoPresent().getRetrieveCriteria(); 
    207                         List<OriginalDocument> result = agent.doPresent(conn, documentsId, retrieveType); 
     206                        List<OriginalDocument> result = agent.doPresent(documentsId, retrieveType); 
    208207                        String recDetail = retrieveType == null ? null : retrieveType.getRecordDetail(); 
    209208                        DiscoveryDictionary.RecordDetail detail = DiscoveryDictionary.getRecordDetails(recDetail); 
     
    219218                        responseContent.setStatus(status); 
    220219                        responseContent.setStatusMessage(statusMsg); 
    221                         if (conn != null) 
    222                                 try { 
    223                                         conn.close(); 
    224                                 } catch (SQLException e) { 
    225                                         // TODO Auto-generated catch block 
    226                                         e.printStackTrace(); 
    227                                 } 
    228220                } 
    229221                return response; 
  • TI01-discovery-API/trunk/MEDINDiscoveryService/src/main/java/ndg/services/discovery/model/CommonMethods.java

    r7754 r7913  
    153153        void commitOrRollback(Connection conn, boolean commit) { 
    154154                try { 
    155                         if (!conn.isClosed() && conn != null) { 
     155                        if (conn != null && !conn.isClosed()) { 
    156156                                if (commit) { 
    157157                                        conn.commit(); 
  • TI01-discovery-API/trunk/MEDINDiscoveryService/src/main/java/ndg/services/discovery/model/PresentAgent.java

    r7878 r7913  
    219219                        fillSpatialTemporalData(conn, searchResult);                             
    220220                } 
    221  
     221                return searchResult; 
     222        } 
     223 
     224        /** 
     225         * Executes the search and returns a SearchSummary object 
     226         *  
     227         * @return SearchSummary object containing result of search 
     228         * @throws NdgException  
     229         */ 
     230        public List<OriginalDocument> doPresent(List<String> documentsId, RetrieveCriteriaType type) 
     231                        throws NdgSQLException, AssembleQueryException, ResourceNotAvailable { 
     232                 
     233                Connection conn = DiscoveryBasic.getInstance().getDiscoveryConnection(); 
     234                List<OriginalDocument> searchResult = null; 
     235                boolean commit = false; 
     236                try { 
     237                        conn.setAutoCommit(false); 
     238                        searchResult = doPresent(conn, documentsId, type); 
     239                        commit = true; 
     240                } catch (SQLException e) { 
     241                        // NdgMessage msg = new NdgMessage("sql.resultset.parsing.error", 
     242                        // new Object[] { sqlQuery }); 
     243                } finally { 
     244                        commitOrRollback(conn, commit); 
     245                } 
    222246                if (conn != null) { 
    223247                        try { 
    224                                 conn.close(); 
    225                         } catch (Exception e) { 
    226                                 logHelper.logMessage("closeConnectionError", Level.ERROR, e); 
    227                         }        
    228                 } 
    229                 return searchResult; 
    230         } 
    231  
     248                                if (!conn.isClosed()) 
     249                                        conn.close(); 
     250                        } catch (SQLException e) { 
     251                                logHelper.logMessage(e, Level.ERROR); 
     252                        } 
     253                } 
     254                return searchResult;             
     255        } 
     256         
    232257        private boolean columnExist(ResultSet rs, String columnName) { 
    233258                boolean columnExist = false; 
  • TI01-discovery-API/trunk/MEDINDiscoveryService/src/main/java/ndg/services/discovery/model/SearchAgent.java

    r7878 r7913  
    22 
    33import java.sql.Connection; 
    4 import java.sql.PreparedStatement; 
    54import java.sql.ResultSet; 
    65import java.sql.SQLException; 
     
    109import java.util.Collections; 
    1110import java.util.Comparator; 
     11import java.util.Iterator; 
    1212import java.util.List; 
    1313 
    14 import ndg.common.NdgLogger; 
    1514import ndg.common.TermParser; 
    1615import ndg.common.exception.AssembleQueryException; 
     
    2524import ndg.services.discovery.medin.schema.RetrieveCriteriaType; 
    2625import ndg.services.discovery.medin.schema.SearchType; 
     26import ndg.services.discovery.medin.schema.SearchType.SearchCriteria; 
    2727import ndg.services.discovery.medin.schema.SpatialType; 
    2828import ndg.services.discovery.medin.schema.TemporalType; 
    2929import ndg.services.discovery.medin.schema.TermSearchType; 
    30 import ndg.services.discovery.medin.schema.SearchType.SearchCriteria; 
    3130import ndg.services.jpa.OriginalDocument; 
    3231 
    33 import org.apache.log4j.Level; 
    3432import org.apache.log4j.Logger; 
    3533 
     
    4341public class SearchAgent extends CommonMethods<String> { 
    4442 
    45         private NdgLogger logHelper = DiscoveryBasic.getInstance().getNdgInstance(SearchAgent.class.getName()); 
    46  
    47         private String updateCounterSQL = "UPDATE original_document SET resultset_count = ? WHERE original_document_filename = ?"; 
    48         private String getValue = "SELECT resultset_count as counter from original_document"; 
    49  
     43        private final static Logger logger = Logger.getLogger(SearchAgent.class.getName()); 
     44         
    5045        private enum OPERATOR { 
    5146                AND, OR, NOT, AND_NOT, OR_NOT 
     
    10095                                        conn.close(); 
    10196                        } catch (SQLException e) { 
    102                                 logHelper.logMessage("closeConnectionError", Level.ERROR, e); 
     97                                logger.error("closeConnectionError", e); 
     98                                //logHelper.logMessage("closeConnectionError", Level.ERROR, e); 
    10399                        } 
    104100                } 
     
    112108         *             if an error during the database access 
    113109         **/ 
    114         private List<OriginalDocument> searchDocuments(Connection conn, SearchCriteria criteria) throws AssembleQueryException, NdgSQLException, ResourceNotAvailable { 
     110        private List<OriginalDocument> searchDocuments(Connection conn, SearchCriteria criteria) throws AssembleQueryException, NdgSQLException, ResourceNotAvailable, SQLException { 
    115111                List<OriginalDocument> res = new ArrayList<OriginalDocument>(); 
    116112                List<String> toFilter = executeSearch(conn, assembleSearch(criteria, searchType.getRetrieveCriteria())); 
     
    130126                } 
    131127 
    132                 toFilter = toFilter.subList((int) start - 1, (int) howMany); 
    133                 PresentAgent present = new PresentAgent(); 
     128                toFilter = toFilter.subList((int) start - 1, (int) howMany);             
     129                PresentAgent present = new PresentAgent();               
    134130                res = present.doPresent(conn, toFilter, searchType.getRetrieveCriteria()); 
     131                doUpdateVal(conn, toFilter); 
     132                return res; 
     133        } 
     134 
     135        private void doUpdateVal(Connection conn, List<String> documentIDs) throws SQLException { 
    135136                 
    136                 //Create an independent thread to let Axis return the results faster 
    137                 new Thread(new UpdateCountVal(toFilter)).start(); 
     137                if (documentIDs == null || documentIDs.size() == 0) { 
     138                        if (logger.isInfoEnabled()) { 
     139                                logger.info("Updated 0 resultset_counter"); 
     140                                return; 
     141                        }                                
     142                } 
    138143                 
    139                 return res; 
    140         } 
    141  
     144                StringBuffer sb = new StringBuffer(); 
     145                sb.append("UPDATE original_document SET resultset_count = resultset_count + 1 WHERE original_document_filename ");                                       
     146                sb.append(" IN ("); 
     147 
     148                Iterator<String> iter = documentIDs.iterator(); 
     149                while (iter.hasNext()) { 
     150                        sb.append("'"); 
     151                        sb.append(iter.next()); 
     152                        sb.append("'"); 
     153                        if (iter.hasNext()) 
     154                                sb.append(", "); 
     155                } 
     156                sb.append(") "); 
     157                 
     158                Statement statement = conn.createStatement(); 
     159                int ret = statement.executeUpdate(sb.toString()); 
     160                if (logger.isInfoEnabled()) 
     161                                logger.info("Updated " + ret + " resultset_counter");    
     162        }        
     163         
    142164        @Override 
    143165        List<String> loadResultSet(ResultSet rs) throws SQLException { 
     
    192214 
    193215                        DiscoveryDictionary.TermTarget termTarget = DiscoveryDictionary.getTermType(termType.getTermTarget()); 
    194                         logHelper.logMessage("Search term - TermTarget: " + term + " - " + termTarget, Level.DEBUG); 
     216                        //logHelper.logMessage("Search term - TermTarget: " + term + " - " + termTarget, Level.DEBUG); 
    195217 
    196218                        /* -- appends the terms (FROM part) -- */ 
     
    340362                for (String scopeLabel : scopes) { 
    341363                        DiscoveryDictionary.Scope scope = DiscoveryDictionary.getScope(scopeLabel); 
    342                         logHelper.logMessage("Scope: " + scope, Level.DEBUG); 
     364                        //logHelper.logMessage("Scope: " + scope, Level.DEBUG); 
    343365                        if (scope == null) 
    344366                                continue; 
     
    409431                return ret; 
    410432        } 
    411  
    412  
    413          
    414         private class UpdateCountVal implements Runnable{ 
    415                 private Logger logger = Logger.getLogger(UpdateCountVal.class.getName()); 
    416                  
    417                 private final List<String> documentIDs; 
    418  
    419                 public void run() { 
    420                         try { 
    421                                 updateCountVal(); 
    422                         } catch (NdgSQLException e) { 
    423                                 if (logger.isInfoEnabled()) 
    424                                         logger.info(e.getMessage(), e); 
    425                         } catch (ResourceNotAvailable e) { 
    426                                 if (logger.isInfoEnabled()) 
    427                                         logger.info(e.getMessage(), e); 
    428                         } 
    429                 }        
    430                  
    431                 public UpdateCountVal(List<String> documentIDs) { 
    432                         super(); 
    433                         this.documentIDs = documentIDs; 
    434                 } 
    435  
    436                 private void updateCountVal() throws NdgSQLException, ResourceNotAvailable { 
    437                         Connection conn = DiscoveryBasic.getInstance().getDiscoveryConnection(); 
    438                         boolean commit = false; 
    439                         try { 
    440                                 conn.setAutoCommit(false); 
    441                                 for (String docId : documentIDs) { 
    442                                         executeUpdateCountVal(conn, docId); 
    443                                 } 
    444                                 commit = true; 
    445                         } catch (SQLException e) { 
    446                                 // NdgMessage msg = new NdgMessage("sql.resultset.parsing.error", 
    447                                 // new Object[] { sqlQuery }); 
    448                                 throw new NdgSQLException(e); 
    449                         } finally { 
    450                                 commitOrRollback(conn, commit); 
    451                         } 
    452                 } 
    453  
    454                 private void executeUpdateCountVal(Connection conn, String docId) throws NdgSQLException { 
    455                         int monitorIndex = 0; 
    456                         while(true) { 
    457                                 try { 
    458                                         doCountVal(conn, docId); 
    459                                         break; 
    460                                 } catch (SQLException e) { 
    461                                         monitorIndex++; 
    462                                         if (monitorIndex > 15) 
    463                                                 break; 
    464                                                 //throw new NdgSQLException(e); 
    465                                 }                        
    466                         } 
    467                 } 
    468                  
    469                 private void doCountVal(Connection conn, String docId) throws SQLException { 
    470                         Statement statement = conn.createStatement(); 
    471                         ResultSet rs = statement.executeQuery(getValue); 
    472                         if (!rs.next()) 
    473                                 return; 
    474                         Integer counter = rs.getInt("counter"); 
    475                         PreparedStatement updateCounter = conn.prepareStatement(updateCounterSQL); 
    476                         updateCounter.setInt(1, counter + 1); 
    477                         updateCounter.setString(2, docId); 
    478                         updateCounter.executeUpdate();           
    479                 } 
    480         } 
    481433} 
Note: See TracChangeset for help on using the changeset viewer.