Changeset 7918


Ignore:
Timestamp:
30/06/11 12:18:12 (8 years ago)
Author:
mnagni
Message:

Fixed an "Exact phrase" mismatch
Implemented a method to group together TermSearch? with the same TermTarget?

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

Legend:

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

    r7915 r7918  
    44        <groupId>ndg.services.discovery</groupId> 
    55        <artifactId>MedinDiscoveryService</artifactId> 
    6         <version>1.2.8</version> 
     6        <version>1.2.10</version> 
    77        <packaging>aar</packaging> 
    88 
     
    2424                        <groupId>org.slf4j</groupId> 
    2525                        <artifactId>log4j-over-slf4j</artifactId> 
    26                         <version>1.5.10</version> 
     26                        <version>1.6.1</version> 
    2727                </dependency> 
    2828 
     
    4747                        <scope>test</scope> 
    4848                </dependency> 
     49                 
     50                <dependency> 
     51                        <groupId>org.slf4j</groupId> 
     52                        <artifactId>slf4j-simple</artifactId> 
     53                        <version>1.6.1</version> 
     54                        <scope>test</scope>                      
     55                </dependency>            
    4956        </dependencies> 
    5057 
  • TI01-discovery-API/trunk/MEDINDiscoveryService/src/main/java/ndg/common/TermParser.java

    r7915 r7918  
    197197                                if (stop == -1) 
    198198                                        throw new AssembleQueryException(new NdgMessage("term.target.syntax.error", new Object[] { term })); 
    199                                 ret.add("''" + term.substring(start+2, stop) + "''");    
     199                                ret.add("'" + term.substring(start+2, stop) + "'");      
    200200                                start = stop + 2; 
    201201                                continue; 
  • TI01-discovery-API/trunk/MEDINDiscoveryService/src/main/java/ndg/services/discovery/model/CommonMethods.java

    r7913 r7918  
    119119        } 
    120120         
    121         String assembleSearch(SearchCriteria criteria, RetrieveCriteriaType retrieveType)  
     121        public String assembleSearch(SearchCriteria criteria, RetrieveCriteriaType retrieveType)  
    122122                        throws AssembleQueryException{ 
    123123 
  • TI01-discovery-API/trunk/MEDINDiscoveryService/src/main/java/ndg/services/discovery/model/SearchAgent.java

    r7913 r7918  
    1919import ndg.services.discovery.medin.DiscoveryDictionary; 
    2020import ndg.services.discovery.medin.DiscoveryDictionary.TemporalOperator; 
     21import ndg.services.discovery.medin.DiscoveryDictionary.TermTarget; 
    2122import ndg.services.discovery.medin.schema.BoundingBoxType; 
    2223import ndg.services.discovery.medin.schema.DateRangeType; 
     
    190191        } 
    191192 
     193        /** 
     194         * Has been verified that  
     195         *              <ns0:TermSearch id="1"> 
     196                                <ns0:Term>acoustic OR seagrass</ns0:Term> 
     197                                <ns0:TermTarget>FullText</ns0:TermTarget> 
     198                        </ns0:TermSearch> 
     199         
     200                and  
     201                        <ns0:TermSearch id="1"> 
     202                                <ns0:Term>acoustic</ns0:Term> 
     203                                <ns0:TermTarget>FullText</ns0:TermTarget> 
     204                        </ns0:TermSearch> 
     205                        <ns0:TermSearch id="2" operator="OR"> 
     206                                <ns0:Term>seagrass</ns0:Term> 
     207                                <ns0:TermTarget>FullText</ns0:TermTarget> 
     208                        </ns0:TermSearch> 
     209         
     210        produce two different but equivalent queries. The problems with such queries  
     211        is that the second is deadly slow.  To avoid this this method groups different TermTarget 
     212        in one single TermSearch 
     213         **/ 
     214        private List<TermSearchType> aggregateTermTarget(TermSearchType[] termsType) { 
     215                List<TermSearchType> retList = new ArrayList<TermSearchType>(); 
     216                TermSearchType newTS = null; 
     217                for (TermTarget tt : TermTarget.values()) { 
     218                        newTS = TermSearchType.Factory.newInstance(); 
     219                        newTS.setTermTarget(tt.fieldLabel()); 
     220                        boolean firstTerm = true; 
     221                        for (TermSearchType ts : termsType) {                            
     222                                if (tt.equals(DiscoveryDictionary.getTermType(ts.getTermTarget()))) { 
     223                                        if (newTS.getTerm() == null) { 
     224                                                newTS.setTerm(ts.getTerm()); 
     225                                        } else { 
     226                                                if (newTS.getTerm().length() == 0) { 
     227                                                        newTS.setTerm(ts.getTerm()); 
     228                                                } else { 
     229                                                        newTS.setTerm(newTS.getTerm() + " " + getOperator(ts.getOperator()) + " " + ts.getTerm()); 
     230                                                }        
     231                                        } 
     232                                        if (firstTerm) { 
     233                                                newTS.setOperator(ts.getOperator()); 
     234                                                firstTerm = false; 
     235                                        }        
     236                                } 
     237                        } 
     238                        if (newTS.getTerm() != null && newTS.getTerm().length() > 0) { 
     239                                retList.add(newTS);                      
     240                        } 
     241                } 
     242                return retList; 
     243        } 
     244         
    192245        private void preapareTermSearch(StringBuffer fromSQL, StringBuffer whereSQL, TermSearchType[] termsType) 
    193246                        throws AssembleQueryException { 
     
    195248                        return; 
    196249 
    197                 List<TermSearchType> terms = Arrays.asList(termsType); 
     250                List<TermSearchType> terms = aggregateTermTarget(termsType); 
    198251                Collections.sort(terms, new TermSearchTypeComparator()); 
    199252                boolean secondPass = false; 
  • TI01-discovery-API/trunk/MEDINDiscoveryService/src/test/java/ndg/common/SearchAgentTest.java

    r7915 r7918  
    11package ndg.common; 
    22 
    3 import static org.junit.Assert.*; 
     3import static org.junit.Assert.assertTrue; 
     4import static org.junit.Assert.fail; 
     5 
     6import java.util.ArrayList; 
    47import java.util.HashMap; 
    58import java.util.Map; 
    69 
    710import ndg.common.exception.AssembleQueryException; 
     11import ndg.services.discovery.medin.schema.SearchType; 
     12import ndg.services.discovery.medin.schema.SearchType.SearchCriteria; 
     13import ndg.services.discovery.medin.schema.TermSearchType; 
     14import ndg.services.discovery.model.SearchAgent; 
    815 
    916import org.junit.Before; 
     
    3946                tests.put("one-two", "one-two"); 
    4047        } 
     48         
    4149         
    4250 
     
    7987                test = "one & - \"\"two ring\"\""; 
    8088                try { 
    81                         assertTrue(tp.parseTerm(test).trim().equals("one & ! \\\'\\\'two ring\\\'\\\'")); 
     89                        assertTrue(tp.parseTerm(test).trim().equals("one & ! \\\'two ring\\\'")); 
    8290                } catch (AssembleQueryException e) { 
    8391                        fail(new MessageFormatter().getFormattedText(e.getBundlMessage())); 
     
    9199                } 
    92100        } 
     101         
     102        private void dotestPrepareTermSearch(SearchType st, String referenceQuery) { 
     103                SearchAgent sa = new SearchAgent(st);            
     104                try {                    
     105                        String query = sa.assembleSearch(st.getSearchCriteria(), 
     106                                        st.getRetrieveCriteria()); 
     107                        assertTrue(query.equals(referenceQuery)); 
     108                } catch (AssembleQueryException e) { 
     109                        e.printStackTrace(); 
     110                }                
     111        } 
     112         
     113        @Test 
     114        public void testPrepareTermSearch1() { 
     115                String referenceQuery = "SELECT distinct original_document_filename, original_document.original_document_id  " + 
     116                                "FROM original_document, transformed_document,  to_tsquery('acustic | seagrass') AS query0 " + 
     117                                "WHERE transformed_document.original_document_id = original_document.original_document_id AND  query0 @@ (document_ts_vector)"; 
     118 
     119                SearchType searchType = SearchType.Factory.newInstance(); 
     120                SearchCriteria sc = searchType.addNewSearchCriteria(); 
     121                TermSearchType ts = sc.addNewTermSearch(); 
     122                ts.setTerm("acustic OR seagrass"); 
     123                ts.setTermTarget("FullText"); 
     124                 
     125                dotestPrepareTermSearch(searchType, referenceQuery);     
     126        } 
     127 
     128        @Test 
     129        public void testPrepareTermSearch2() { 
     130                String referenceQuery = "SELECT distinct original_document_filename, original_document.original_document_id  " + 
     131                                "FROM original_document, transformed_document,  to_tsquery('acustic | seagrass') AS query0 " + 
     132                                "WHERE transformed_document.original_document_id = original_document.original_document_id AND  query0 @@ (document_ts_vector)"; 
     133                 
     134                SearchType searchType = SearchType.Factory.newInstance(); 
     135                SearchCriteria sc = searchType.addNewSearchCriteria(); 
     136                TermSearchType ts21 = sc.addNewTermSearch(); 
     137                ts21.setTerm("acustic"); 
     138                ts21.setTermTarget("FullText"); 
     139                TermSearchType ts22 = sc.addNewTermSearch(); 
     140                ts22.setTerm("seagrass"); 
     141                ts22.setTermTarget("FullText"); 
     142                ts22.setOperator("OR"); 
     143                 
     144                dotestPrepareTermSearch(searchType, referenceQuery);     
     145        }        
     146 
     147        @Test 
     148        public void testPrepareTermSearch3() { 
     149                String referenceQuery = "SELECT distinct original_document_filename, original_document.original_document_id  " + 
     150                                "FROM original_document, transformed_document,  to_tsquery('acustic | seagrass') AS query0,  to_tsquery('Maurizio') AS query1 " + 
     151                                "WHERE transformed_document.original_document_id = original_document.original_document_id " + 
     152                                "AND  query0 @@ (document_ts_vector) AND  query1 @@ (authors_ts_vector)"; 
     153                 
     154                SearchType searchType = SearchType.Factory.newInstance(); 
     155                SearchCriteria sc = searchType.addNewSearchCriteria(); 
     156                TermSearchType ts21 = sc.addNewTermSearch(); 
     157                ts21.setTerm("acustic"); 
     158                ts21.setTermTarget("FullText"); 
     159                TermSearchType ts22 = sc.addNewTermSearch(); 
     160                ts22.setTerm("Maurizio"); 
     161                ts22.setTermTarget("Author"); 
     162                ts22.setOperator("AND"); 
     163                TermSearchType ts23 = sc.addNewTermSearch(); 
     164                ts23.setTerm("seagrass"); 
     165                ts23.setTermTarget("FullText"); 
     166                ts23.setOperator("OR"); 
     167                 
     168                dotestPrepareTermSearch(searchType, referenceQuery);     
     169        }        
    93170} 
Note: See TracChangeset for help on using the changeset viewer.