Changeset 7126 for TI01-discovery-API


Ignore:
Timestamp:
30/06/10 12:18:39 (9 years ago)
Author:
mnagni
Message:

Refactored the Term parsing procedure
Added (finally) one JUnit test (for the Term parsing)
Fixed again the trunked CDATA error
Added postgresql server message about "Feature not supported"
Medin Discovery Service version 1.2.0

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

Legend:

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

    r6465 r7126  
    88        <classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/J2SE-1.5"/> 
    99        <classpathentry kind="con" path="org.maven.ide.eclipse.MAVEN2_CLASSPATH_CONTAINER"/> 
     10        <classpathentry kind="con" path="org.eclipse.jdt.junit.JUNIT_CONTAINER/4"/> 
    1011        <classpathentry kind="output" path="target"/> 
    1112</classpath> 
  • TI01-discovery-API/trunk/MEDINDiscoveryService/pom.xml

    r7089 r7126  
    44        <groupId>ndg.services.discovery</groupId> 
    55        <artifactId>MedinDiscoveryService</artifactId> 
    6         <version>1.1.16</version> 
     6        <version>1.2.0</version> 
    77        <packaging>aar</packaging> 
    88 
     
    4444                        <groupId>junit</groupId> 
    4545                        <artifactId>junit</artifactId> 
    46                         <version>3.8.1</version> 
     46                        <version>4.8.1</version> 
    4747                        <scope>test</scope> 
    4848                </dependency> 
  • TI01-discovery-API/trunk/MEDINDiscoveryService/src/main/java/ndg/services/discovery/DiscoveryServiceMEDINSkeleton.java

    r7092 r7126  
    112112                        if (doSearch.getDoSearch() != null && doSearch.getDoSearch().getTicketId() != null) { 
    113113                                responseContent.setTicketId(doSearch.getDoSearch().getTicketId());       
    114                         }        
     114                        } else { 
     115                                responseContent.setTicketId("0"); 
     116                        } 
    115117                         
    116118                         
     
    137139                                        processResult(result, responseContent.addNewDocuments(), type, orderBy); 
    138140                                        status = true; 
    139                                 } catch (NdgSQLException e) { 
    140                                         statusMsg = logHelper.getBundleMessageAndDoLog(e, Level.ERROR); 
    141                                 } catch (ResourceNotAvailable e) { 
     141                                } catch (NdgException e) { 
    142142                                        statusMsg = logHelper.getBundleMessageAndDoLog(e, Level.ERROR); 
    143143                                } finally { 
     
    186186                if (doPresent.getDoPresent() != null && doPresent.getDoPresent().getTicketId() != null) { 
    187187                        responseContent.setTicketId(doPresent.getDoPresent().getTicketId());     
    188                 }                
     188                } else { 
     189                        responseContent.setTicketId("0"); 
     190                } 
    189191 
    190192                boolean status = false; 
     
    203205                        processResult(result, responseContent.addNewDocuments(), detail, null); 
    204206                        status = true; 
    205                 } catch (NdgSQLException e) { 
    206                         statusMsg = logHelper.getBundleMessageAndDoLog(e, Level.ERROR); 
    207                 } catch (ResourceNotAvailable e) { 
     207                } catch (NdgException e) { 
    208208                        statusMsg = logHelper.getBundleMessageAndDoLog(e, Level.ERROR); 
    209209                } finally { 
  • TI01-discovery-API/trunk/MEDINDiscoveryService/src/main/java/ndg/services/discovery/model/CommonMethods.java

    r6799 r7126  
    1010import ndg.common.NdgLogger; 
    1111import ndg.common.NdgMessage; 
     12import ndg.common.exception.AssembleQueryException; 
     13import ndg.common.exception.NdgException; 
    1214import ndg.common.exception.NdgSQLException; 
    1315import ndg.common.exception.ResourceNotAvailable; 
     
    118120        } 
    119121         
    120         String assembleSearch(SearchCriteria criteria, RetrieveCriteriaType retrieveType) { 
     122        String assembleSearch(SearchCriteria criteria, RetrieveCriteriaType retrieveType)  
     123                        throws NdgException{ 
    121124 
    122125                // NB, we use the postgres text search function to do term searches 
     
    202205                } catch (SQLException e) { 
    203206                        closeStatement(stat, rs); 
    204                         NdgMessage msg = new NdgMessage("sql.execution.error", 
    205                         new Object[] { sqlQuery }); 
     207                        NdgMessage msg = null; 
     208                        if (e.getSQLState().equals("0A000")) { 
     209                                msg = new NdgMessage("sql.feature.not.supported", 
     210                                                new Object[] { }); 
     211                        } else { 
     212                                msg = new NdgMessage("sql.execution.error", 
     213                                                new Object[] { sqlQuery });      
     214                        }                        
    206215                        throw new NdgSQLException(msg,e); 
    207216                } 
     
    220229         
    221230        abstract void assembleSearchQuery(StringBuffer sqlCmd, StringBuffer fromSQL, StringBuffer whereSQL, 
    222                         SearchCriteria criteria, RetrieveCriteriaType retrieveType); 
     231                        SearchCriteria criteria, RetrieveCriteriaType retrieveType) throws AssembleQueryException; 
    223232} 
  • TI01-discovery-API/trunk/MEDINDiscoveryService/src/main/java/ndg/services/discovery/model/PresentAgent.java

    r6874 r7126  
    200200         *  
    201201         * @return SearchSummary object containing result of search 
    202          * @throws NdgSQLException 
    203          *             database error 
    204          * @throws ResourceNotAvailable 
    205          *             if cannot access to the database 
     202         * @throws NdgException  
    206203         */ 
    207204        public List<OriginalDocument> doPresent(Connection conn, List<String> documentsId, RetrieveCriteriaType type) 
    208                         throws NdgSQLException, ResourceNotAvailable { 
     205                        throws NdgException { 
    209206                if (documentsId == null || documentsId.size() == 0) 
    210207                        return new ArrayList<OriginalDocument>(); 
  • TI01-discovery-API/trunk/MEDINDiscoveryService/src/main/java/ndg/services/discovery/model/SearchAgent.java

    r7089 r7126  
    1111import java.util.Comparator; 
    1212import java.util.List; 
    13 import java.util.regex.Pattern; 
    1413 
    1514import ndg.common.NdgLogger; 
     15import ndg.common.TermParser; 
     16import ndg.common.exception.AssembleQueryException; 
     17import ndg.common.exception.NdgException; 
    1618import ndg.common.exception.NdgSQLException; 
    1719import ndg.common.exception.ResourceNotAvailable; 
     
    4042 */ 
    4143public class SearchAgent extends CommonMethods<String> { 
    42          
    43         /* Terms cannot contain ONLY these single character (do a match) */ 
    44         private final static String regexIllegalCharacters = "[\\'&\\|!\\(\\)-\\+\\\\]";         
    45         private final Pattern illegalCharacters = Pattern.compile(regexIllegalCharacters); 
    46          
    47         /* Terms cannot start using these characters (do a match) */ 
    48         private final static String regexIllegalStart1 = "^([\\'&\\|\\)\\\\\\+])."; 
    49         private final Pattern illegalStart1 = Pattern.compile(regexIllegalStart1); 
    50          
    51         /* Terms cannot start using these characters (do a match) */ 
    52         private final static String regexIllegalStart2 = "^[\\!-][\\'\\&\\|\\\\\\+\\)\\(]"; 
    53         private final Pattern illegalStart2 = Pattern.compile(regexIllegalStart2); 
    54  
    55         /* Terms cannot contain this pattern these characters ['!&|\+-]['&|\+)] */ 
    56         private final static String regexIllegalSequence1 = "[\\'\\!\\&\\|\\\\\\+-][\\'\\&\\|\\\\\\+\\)]";       
    57         private final Pattern illegalSequence1 = Pattern.compile(regexIllegalSequence1); 
    58          
    59         /* Terms cannot contain this pattern these characters ['!\-]['&|\+)] */ 
    60         private final static String regexIllegalSequence2 = "[\\'\\!\\\\\\(][\\'&\\|\\\\\\+\\)]";        
    61         private final Pattern illegalSequence2 = Pattern.compile(regexIllegalSequence2); 
    62          
     44 
    6345        private NdgLogger logHelper = DiscoveryBasic.getInstance().getNdgInstance(SearchAgent.class.getName()); 
    6446 
     
    9678         *             if cannot access to the database 
    9779         */ 
    98         public List<OriginalDocument> doSearch() throws NdgSQLException, ResourceNotAvailable { 
     80        public List<OriginalDocument> doSearch() throws NdgException, ResourceNotAvailable { 
    9981                SearchCriteria criteria = searchType.getSearchCriteria(); 
    10082                Connection conn = DiscoveryBasic.getInstance().getDiscoveryConnection(); 
     
    10890                        // NdgMessage msg = new NdgMessage("sql.resultset.parsing.error", 
    10991                        // new Object[] { sqlQuery }); 
    110                         throw new NdgSQLException(e); 
     92                } catch (NdgException e) { 
     93                        logHelper.logMessage(e, Level.ERROR); 
     94                        throw new NdgException(e.getBundlMessage()); 
    11195                } finally { 
    11296                        commitOrRollback(conn, commit); 
     
    124108 
    125109        /** 
     110         * @throws NdgException 
    126111         * @throws SQLException 
    127112         *             if an error during the database access 
    128          * @exception ResourceNotAvailable 
    129          *                the <code>Connection</code> to the database is not 
    130          *                available 
    131113         **/ 
    132         private List<OriginalDocument> searchDocuments(Connection conn, SearchCriteria criteria) throws NdgSQLException, 
    133                         ResourceNotAvailable { 
     114        private List<OriginalDocument> searchDocuments(Connection conn, SearchCriteria criteria) throws NdgException { 
    134115                List<OriginalDocument> res = new ArrayList<OriginalDocument>(); 
    135116                List<String> toFilter = executeSearch(conn, assembleSearch(criteria, searchType.getRetrieveCriteria())); 
     
    167148        @Override 
    168149        void assembleSearchQuery(StringBuffer sqlCmd, StringBuffer fromSQL, StringBuffer whereSQL, SearchCriteria criteria, 
    169                         RetrieveCriteriaType retrieveType) { 
     150                        RetrieveCriteriaType retrieveType) throws AssembleQueryException { 
    170151                /* -- is a TermSearch? -- */ 
    171152                preapareTermSearch(fromSQL, whereSQL, criteria.getTermSearchArray()); 
     
    184165        } 
    185166 
    186  
    187         /** 
    188          * Do a simple check of the input search string to check for unix wildcards 
    189          *  
    190          * @return true if wildcards found, false otherwise 
    191          */ 
    192         private boolean isPOSIXWildcardSeach(String term) { 
    193                 // logger.info("Checking for wildcards in search term"); 
    194                 for (int i = 0, is = term.length(); i < is; i++) { 
    195                         char c = term.charAt(i); 
    196                         switch (c) { 
    197                         case '*': 
    198                         case '?': 
    199                                 // case '(': 
    200                                 // case ')': 
    201                         case '[': 
    202                         case ']': 
    203                         case '$': 
    204                         case '^': 
    205                         case '.': 
    206                         case '{': 
    207                         case '}': 
    208                                 // case '|': 
    209                         case '\\': 
    210                                 // logger.info("- found wildcards - treat as a regexp search"); 
    211                                 return true; 
    212                         default: 
    213                                 break; 
    214                         } 
    215                 } 
    216                 // logger.info("- no wildcards found - treat at text search"); 
    217                 return false; 
    218         } 
    219  
    220         private void preapareTermSearch(StringBuffer fromSQL, StringBuffer whereSQL, TermSearchType[] termsType) { 
     167        private void preapareTermSearch(StringBuffer fromSQL, StringBuffer whereSQL, TermSearchType[] termsType) 
     168                        throws AssembleQueryException { 
    221169                if (termsType == null || termsType.length == 0) 
    222170                        return; 
     
    227175                int queryIndex = 0; 
    228176                for (TermSearchType termType : terms) { 
    229                         String term = termType.getTerm();                                        
    230                          
     177                        String term = termType.getTerm(); 
     178 
     179                        // if some termType is empty just skip it 
     180                        if (term == null || term.length() == 0) 
     181                                continue; 
     182                        term = new TermParser().parseTerm(term); 
     183 
    231184                        DiscoveryDictionary.TermTarget termTarget = DiscoveryDictionary.getTermType(termType.getTermTarget()); 
    232                         /* 
    233                          * -- if some termType is incomplete returns what ready up to this 
    234                          * moment -- 
    235                          */ 
    236                         if (term == null || term.length() == 0) 
    237                                 break; 
    238  
    239185                        logHelper.logMessage("Search term - TermTarget: " + term + " - " + termTarget, Level.DEBUG); 
    240186 
    241                         /* -- Converts the query string in a postgresql proper format -- */ 
    242                         term = term.replaceAll("(\\bAND\\b)|(\\band\\b)|\\+", "&"); 
    243                         term = term.replaceAll("(\\bOR\\b)|(\\bor\\b)|\\|", "|"); 
    244                         term = term.replaceAll("(\\bNOT\\b)|(\\bnot\\b)|\\-", "!"); 
    245                         term = term.replaceAll("(\\B\\\\&\\B\\s+)|(\\s+\\B\\\\!\\B)|(\\b\\s+\\b)", "|"); 
    246                         term = term.replaceAll(":", "\\\\\\\\:"); 
    247                          
    248                         if (illegalStart1.matcher(term).matches() || illegalStart2.matcher(term).matches() 
    249                                         || illegalCharacters.matcher(term).matches()  
    250                                         || illegalSequence1.matcher(term).find() 
    251                                         || illegalSequence2.matcher(term).find()) 
    252                                 continue; 
    253187                        /* -- appends the terms (FROM part) -- */ 
    254188                        checkFROMComma(fromSQL, false); 
     
    273207                } 
    274208        } 
    275          
    276         private String composeVector(DiscoveryDictionary.TermTarget termTarget){ 
     209 
     210        private String composeVector(DiscoveryDictionary.TermTarget termTarget) { 
    277211                StringBuffer bf = new StringBuffer(); 
    278                 bf.append(termTarget.isVector() ? "" : "to_tsvector");  
     212                bf.append(termTarget.isVector() ? "" : "to_tsvector"); 
    279213                bf.append("("); 
    280214                bf.append(termTarget.fieldName()); 
     
    282216                return bf.toString(); 
    283217        } 
    284          
     218 
    285219        private void preapareTemporalSearch(StringBuffer fromSQL, StringBuffer whereSQL, TemporalType temporalType) { 
    286220                if (temporalType == null || temporalType.getDateRange() == null 
     
    438372                OPERATOR op = OPERATOR.AND; 
    439373                String ret = op.name(); 
    440                  
     374 
    441375                if (operator == null) 
    442                         return ret;              
    443                  
     376                        return ret; 
     377 
    444378                for (OPERATOR item : OPERATOR.values()) { 
    445379                        if (item.name().equals(operator)) { 
    446380                                ret = item.name(); 
    447                                 if (item.equals(OPERATOR.AND_NOT))  
     381                                if (item.equals(OPERATOR.AND_NOT)) 
    448382                                        ret = " AND NOT "; 
    449                                 if (item.equals(OPERATOR.OR_NOT))  
    450                                         ret = " OR NOT ";                
     383                                if (item.equals(OPERATOR.OR_NOT)) 
     384                                        ret = " OR NOT "; 
    451385                                break; 
    452386                        } 
    453387                } 
    454                  
     388 
    455389                return ret; 
    456390        } 
  • TI01-discovery-API/trunk/MEDINDiscoveryService/src/main/resources/ndg/common/messages.properties

    r7005 r7126  
    33datasource.not.available = The datasource {0} is not available 
    44sql.execution.error = Error occurred during the execution of the following SQL\: \n {0} 
     5sql.feature.not.supported=Feature not supported 
    56sql.resultset.parsing.error = Error occurred parsing the result from the following SQL\: \n {0} 
    67sql.command = Executing \n {0} 
     
    1415invalid.list.name = "Invalid list name: please use getListNames to get the valid list names"; 
    1516empty.searchcriteria = "SearchCriteria cannot be empty"; 
     17term.target.syntax.error = "The Term {0} has wrong syntax"; 
Note: See TracChangeset for help on using the changeset viewer.