Changeset 3824


Ignore:
Timestamp:
2003-03-10T11:00:14+13:00 (21 years ago)
Author:
mdewsnip
Message:

Modified to use base class GS2Search. Implements processTextQuery, as this is partly specific to the search engine used. Also implements functionality specific to MGPP: fielded queries.

File:
1 edited

Legend:

Unmodified
Added
Removed

  • trunk/gsdl3/src/java/org/greenstone/gsdl3/service/GS2MGPPSearch.java

    r3680 r3824  
    1919package org.greenstone.gsdl3.service;
    2020
    21 // greenstone classes
     21
     22// Greenstone classes
    2223import org.greenstone.mgpp.*;
    23 import org.greenstone.gdbm.*;
    2424import org.greenstone.gsdl3.util.*;
    25 // xml classes
    26 import org.w3c.dom.Document;
     25
     26// XML classes
     27import org.w3c.dom.Element;
    2728import org.w3c.dom.Node;
    28 import org.w3c.dom.Text;
    29 import org.w3c.dom.Element;
    3029import org.w3c.dom.NodeList;
    31 // general java classes
     30
     31// General Java classes
    3232import java.util.HashMap;
    3333import java.util.Vector;
    … …  
    3535import java.util.Map;
    3636import java.util.Iterator;
    37 import java.util.Locale;
     37
    3838
    3939/**
    … …  
    4545 */
    4646public class GS2MGPPSearch
    47     extends ServiceRack {
     47    extends GS2Search {
    4848
    4949    // these strings must match what is found in the properties file
    5050    // the services on offer
    51     private static final String TEXT_QUERY_SERVICE = "TextQuery";
    5251    private static final String FIELD_QUERY_SERVICE = "FieldQuery";
    5352    private static final String ADVANCED_FIELD_QUERY_SERVICE = "AdvancedFieldQuery";
    54     // params used
    55     private static final String CASE_PARAM = "case";
    56     private static final String STEM_PARAM = "stem";
    57     private static final String MATCH_PARAM = "matchMode";
    58     private static final String MATCH_PARAM_ALL = "all";
    59     private static final String MATCH_PARAM_SOME = "some";
     53
     54    // Parameters used
    6055    private static final String INDEX_PARAM = "index";
    6156    private static final String LEVEL_PARAM = "level";
    … …  
    6358    private static final String RANK_PARAM_RANK = "rank";
    6459    private static final String RANK_PARAM_NONE = "natural";
    65     private static final String MAXDOCS_PARAM = "maxDocs";
    66     private static final String BOOLEAN_PARAM_ON = "1";
    67     private static final String BOOLEAN_PARAM_OFF = "0";
    68     private static final String QUERY_PARAM = "query";
    6960    private static final String SIMPLE_FIELD_PARAM = "simpleField";
    7061    private static final String ADVANCED_FIELD_PARAM = "complexField";
    … …  
    7869    private static final String FIELD_COMBINE_PARAM_OR = "1";
    7970    private static final String FIELD_COMBINE_PARAM_NOT = "2";
    80    
    81     // elements used in the config file that are specific to this class
     71
     72    // Elements used in the config file that are specific to this class
    8273    private static final String DEFAULT_INDEX_ELEM = "defaultIndex";
    8374    private static final String DEFAULT_LEVEL_ELEM = "defaultLevel";
    8475    private static final String INDEX_ELEM = "index";
    8576    private static final String LEVEL_ELEM = "level";
    86    
     77
    8778    private MGPPWrapper mgpp_src_=null;
    88     private GDBMWrapper gdbm_src_=null;
    89    
     79
    9080    private String default_index_=null;
    9181    private String default_level_=null;
    9282
    93     private Element config_info_ = null;
    9483   
    9584    /** constructor */
    96     public GS2MGPPSearch() {
     85    public GS2MGPPSearch()
     86    {
    9787    mgpp_src_ = new MGPPWrapper();
    98     gdbm_src_ = new GDBMWrapper();
    99 
    100     }
     88    }
     89
    10190   
    10291    /** configure this service */
    103     public boolean configure(Element info) {
    104 
    105     System.out.println("configuring GS2MGPPSearch");
    106     config_info_ = info;
    107 
    108     // get the default index from <defaultIndex>
    109     Element def = (Element)GSXML.getChildByTagName(info, DEFAULT_INDEX_ELEM );
    110     if (def !=null) {
     92    public boolean configure(Element info)
     93    {
     94    // Do generic configuration
     95    if (super.configure(info) == false)
     96        return false;
     97
     98    // Do specific configuration
     99    System.out.println("Configuring GS2MGPPSearch...");
     100
     101    // Get the default index out of <defaultIndex> (buildConfig.xml)
     102    Element def = (Element) GSXML.getChildByTagName(info, DEFAULT_INDEX_ELEM);
     103    if (def != null) {
    111104        default_index_ = def.getAttribute(GSXML.NAME_ATT);
    112105    }
    113     if (default_index_==null||default_index_.equals("")) {
     106    if (default_index_ == null || default_index_.equals("")) {
    114107        System.err.println("Error: default index not specified!");
    115108        return false;
    116109    }
    117 
    118     // get the default level out of <defaultLevel>
    119     def = (Element)GSXML.getChildByTagName(info, DEFAULT_LEVEL_ELEM);
    120     if (def !=null) {
     110    // System.out.println("Default index: " + default_index_);
     111
     112    // Get the default level out of <defaultLevel> (buildConfig.xml)
     113    def = (Element) GSXML.getChildByTagName(info, DEFAULT_LEVEL_ELEM);
     114    if (def != null) {
    121115        default_level_ = def.getAttribute(GSXML.NAME_ATT);
    122116    }
    123     if (default_level_==null||default_level_.equals("")) {
     117    if (default_level_ == null || default_level_.equals("")) {
    124118        System.err.println("Error: default level not specified!");
    125119        return false;
    126120    }
     121    // System.out.println("Default level: " + default_level_);
     122
    127123    // the default level is also the level which gdbm is expecting
    128124    mgpp_src_.setReturnLevel(default_level_);
    129125
    130126    // set up which services are available for this collection
    131     Element e = null;
    132127    // these entries should reflect the build config file - some services may not be available depending on how the collection was built.
    133128
    134129    // set up short_service_info_ - for now just has name and type
    135     e = doc_.createElement(GSXML.SERVICE_ELEM);
    136     e.setAttribute(GSXML.TYPE_ATT, GSXML.SERVICE_TYPE_QUERY);
    137     e.setAttribute(GSXML.NAME_ATT, TEXT_QUERY_SERVICE);
    138     short_service_info_.appendChild(e);
    139 
    140     e = doc_.createElement(GSXML.SERVICE_ELEM);
    141     e.setAttribute(GSXML.TYPE_ATT, GSXML.SERVICE_TYPE_QUERY);
    142     e.setAttribute(GSXML.NAME_ATT, FIELD_QUERY_SERVICE);
    143     short_service_info_.appendChild(e);
    144 
    145     e = doc_.createElement(GSXML.SERVICE_ELEM);
    146     e.setAttribute(GSXML.TYPE_ATT, GSXML.SERVICE_TYPE_QUERY);
    147     e.setAttribute(GSXML.NAME_ATT, ADVANCED_FIELD_QUERY_SERVICE);
    148     short_service_info_.appendChild(e);
     130    Element fq_service = doc_.createElement(GSXML.SERVICE_ELEM);
     131    fq_service.setAttribute(GSXML.TYPE_ATT, GSXML.SERVICE_TYPE_QUERY);
     132    fq_service.setAttribute(GSXML.NAME_ATT, FIELD_QUERY_SERVICE);
     133    short_service_info_.appendChild(fq_service);
     134
     135    Element afq_service = doc_.createElement(GSXML.SERVICE_ELEM);
     136    afq_service.setAttribute(GSXML.TYPE_ATT, GSXML.SERVICE_TYPE_QUERY);
     137    afq_service.setAttribute(GSXML.NAME_ATT, ADVANCED_FIELD_QUERY_SERVICE);
     138    short_service_info_.appendChild(afq_service);
    149139
    150140    // set up service_info_map_ - for now, just has the same elements as above
    151141    // should have full details about each service incl params lists etc.
    152142    // do the text query one - for now a static list. later use buildcfg.xml values to dynamically change this
    153     e = doc_.createElement(GSXML.SERVICE_ELEM);
    154     e.setAttribute(GSXML.TYPE_ATT, GSXML.SERVICE_TYPE_QUERY);
    155     e.setAttribute(GSXML.NAME_ATT, TEXT_QUERY_SERVICE);
    156     Element param_list = doc_.createElement(GSXML.PARAM_ELEM+GSXML.LIST_MODIFIER);
    157     createTextQueryParamList(param_list, false, null);
    158     e.appendChild(param_list);
    159     service_info_map_.put(TEXT_QUERY_SERVICE, e);
    160 
    161     e = doc_.createElement(GSXML.SERVICE_ELEM);
    162     e.setAttribute(GSXML.TYPE_ATT, GSXML.SERVICE_TYPE_QUERY);
    163     e.setAttribute(GSXML.NAME_ATT, FIELD_QUERY_SERVICE);
    164     Element param_list1 = doc_.createElement(GSXML.PARAM_ELEM+GSXML.LIST_MODIFIER);
    165     createFieldQueryParamList(param_list1, false, null);
    166     e.appendChild(param_list1);
    167     service_info_map_.put(FIELD_QUERY_SERVICE, e);
    168    
    169     e = doc_.createElement(GSXML.SERVICE_ELEM);
    170     e.setAttribute(GSXML.TYPE_ATT, GSXML.SERVICE_TYPE_QUERY);
    171     e.setAttribute(GSXML.NAME_ATT, ADVANCED_FIELD_QUERY_SERVICE);
    172     Element param_list2 = doc_.createElement(GSXML.PARAM_ELEM+GSXML.LIST_MODIFIER);
    173     createAdvancedFieldQueryParamList(param_list2, false, null);
    174     e.appendChild(param_list2);
    175     service_info_map_.put(ADVANCED_FIELD_QUERY_SERVICE, e);
    176 
    177     if (gdbm_src_.openDatabase(GSFile.GDBMDatabaseFile(site_home_, cluster_name_), GDBMWrapper.READER)) {
    178         return true;
    179     }
    180     else {
    181         System.err.println("couldn't open gdbm database!");
    182         return false;
    183     }
    184     }
     143    Element fq_service_full = (Element) fq_service.cloneNode(true);
     144    Element fq_param_list = doc_.createElement(GSXML.PARAM_ELEM+GSXML.LIST_MODIFIER);
     145    createFieldQueryParamList(fq_param_list, false, null);
     146    fq_service_full.appendChild(fq_param_list);
     147    service_info_map_.put(FIELD_QUERY_SERVICE, fq_service_full);
     148
     149    Element afq_service_full = (Element) afq_service.cloneNode(true);
     150    Element afq_param_list = doc_.createElement(GSXML.PARAM_ELEM+GSXML.LIST_MODIFIER);
     151    createAdvancedFieldQueryParamList(afq_param_list, false, null);
     152    afq_service_full.appendChild(afq_param_list);
     153    service_info_map_.put(ADVANCED_FIELD_QUERY_SERVICE, afq_service_full);
     154
     155    return true;
     156    }
     157
    185158 
    186159    /** creates a new param element and adds it to the param list */
    187160    protected void createParameter(String name, Element param_list, boolean display, String lang) {
    188161    Element param=null;
    189    
     162
    190163    if (name.equals(INDEX_PARAM)) {
    191164        // the index info - read from config file
    … …  
    221194        }
    222195        }
    223     } else if (name.equals(STEM_PARAM)) {
    224         if (display) {
    225         String[] bool_ops = {"0", "1"};
    226         String[] bool_texts = {getTextString("param.boolean.off", lang),getTextString("param.boolean.on", lang)};
    227         param = GSXML.createParameterDisplay(doc_, STEM_PARAM, getTextString("param."+STEM_PARAM, lang),  bool_ops, bool_texts);
    228         } else {
    229         param = GSXML.createParameter(doc_, STEM_PARAM, GSXML.PARAM_TYPE_BOOLEAN, BOOLEAN_PARAM_ON, null);
    230         }
    231     } else if (name.equals(CASE_PARAM)) {
    232         if (display) {
    233         String[] bool_ops = {"0", "1"};
    234         String[] bool_texts = {getTextString("param.boolean.off", lang),getTextString("param.boolean.on", lang)};
    235         param = GSXML.createParameterDisplay(doc_, CASE_PARAM, getTextString("param."+CASE_PARAM, lang),  bool_ops, bool_texts);
    236         } else {
    237         param = GSXML.createParameter(doc_, CASE_PARAM, GSXML.PARAM_TYPE_BOOLEAN, BOOLEAN_PARAM_ON, null);
    238         }
    239     } else if (name.equals(MATCH_PARAM)) {
    240         String []vals = {MATCH_PARAM_ALL, MATCH_PARAM_SOME};
    241         if (display) {
    242         String []val_texts = {getTextString("param."+MATCH_PARAM+"."+MATCH_PARAM_ALL, lang),getTextString("param."+MATCH_PARAM+"."+MATCH_PARAM_SOME, lang)};
    243 
    244         param = GSXML.createParameterDisplay(doc_, MATCH_PARAM, getTextString("param."+MATCH_PARAM, lang), vals, val_texts);
    245         } else {
    246         param = GSXML.createParameter(doc_, MATCH_PARAM, GSXML.PARAM_TYPE_ENUM_SINGLE, MATCH_PARAM_ALL, vals);
    247         }   
    248196    } else if (name.equals(RANK_PARAM)) {
    249197        String [] vals1 = {RANK_PARAM_RANK, RANK_PARAM_NONE };
    … …  
    255203        } else {
    256204        param = GSXML.createParameter(doc_, RANK_PARAM, GSXML.PARAM_TYPE_ENUM_SINGLE, RANK_PARAM_RANK, vals1 );
    257         }
    258     } else if (name.equals(MAXDOCS_PARAM)) {
    259         if (display) {
    260         param = GSXML.createParameterDisplay(doc_, MAXDOCS_PARAM, getTextString("param."+MAXDOCS_PARAM, lang), null, null);
    261         } else {
    262         param = GSXML.createParameter(doc_, MAXDOCS_PARAM, GSXML.PARAM_TYPE_INTEGER, "10", null);
    263         }
    264     } else if (name.equals(QUERY_PARAM)) {
    265         if (display) {
    266         param = GSXML.createParameterDisplay(doc_, QUERY_PARAM, getTextString("param."+QUERY_PARAM, lang), null, null);
    267         } else {
    268         param = GSXML.createParameter(doc_, QUERY_PARAM, GSXML.PARAM_TYPE_STRING, null, null);
    269205        }
    270206    } else if (name.equals(FIELD_QUERY_PARAM)) {
    … …  
    327263        param_list.appendChild(param);
    328264    }
    329     }
     265    else {
     266        super.createParameter(name, param_list, display, lang);
     267    }
     268    }
     269
     270
    330271    /** this creates all teh params and appends them to param_list.
    331272     * if display=true it creates the text strings version
    332273     * otherwise it creates the description version
    333274     */
    334     protected boolean createTextQueryParamList(Element param_list, boolean display, String lang) {
    335 
     275    protected boolean createTextQueryParamList(Element param_list, boolean display,
     276                           String lang)
     277    {
    336278    // the order they are specified here is the order they appear on
    337279    // the query form
    338280    createParameter(INDEX_PARAM, param_list, display, lang);
    339281    createParameter(LEVEL_PARAM, param_list, display, lang);
    340     createParameter(CASE_PARAM, param_list, display, lang);
    341     createParameter(STEM_PARAM, param_list, display, lang);
    342     createParameter(MATCH_PARAM, param_list, display, lang);
    343282    createParameter(RANK_PARAM, param_list, display, lang);
    344     createParameter(MAXDOCS_PARAM, param_list, display, lang);
    345     createParameter(QUERY_PARAM, param_list, display, lang);
    346     return true;
    347     }
     283    return super.createTextQueryParamList(param_list, display, lang);
     284    }
     285
     286
    348287    /** this creates all teh params and appends them to param_list.
    349288     * if display=true it creates the text strings version
    350289     * otherwise it creates the description version
    351290     */
    352     protected boolean createFieldQueryParamList(Element param_list, boolean display, String lang) {
    353 
     291    protected boolean createFieldQueryParamList(Element param_list, boolean display,
     292                        String lang)
     293    {
    354294    createParameter(MATCH_PARAM, param_list, display, lang);
    355295    createParameter(LEVEL_PARAM, param_list, display, lang);
    … …  
    382322    }
    383323
    384     protected boolean createAdvancedFieldQueryParamList(Element param_list, boolean display, String lang) {
     324    protected boolean createAdvancedFieldQueryParamList(Element param_list, boolean display,
     325                            String lang) {
    385326
    386327    // first do index and level params
    … …  
    426367    return true;
    427368    }
    428     /** creates a display element containing all the text strings needed to display the service page, in the language specified */
    429     protected Element createServiceDisplay(String service, String lang) {
    430     Element display = doc_.createElement(GSXML.DISPLAY_ELEM);
    431     display.appendChild(GSXML.createTextElement(doc_, GSXML.DISPLAY_NAME_ELEM,  getTextString(service+".name", lang)));
    432     display.appendChild(GSXML.createTextElement(doc_,  GSXML.DISPLAY_SUBMIT_ELEM, getTextString(service+".submit", lang)));
    433 
    434     // now need to add in the params
    435     if (service.equals(TEXT_QUERY_SERVICE)) {
    436        
    437         createTextQueryParamList(display, true, lang);
    438     }
    439     // now need to add in the params
     369
     370
     371    /** creates a display element containing all the text strings needed to display
     372    the service page, in the language specified */
     373    protected Element createServiceDisplay(String service, String lang)
     374    {
     375    // Create a service display for the basic text query service
     376    Element display = super.createServiceDisplay(service, lang);
     377
     378    // Now add MGPP's special services
    440379    if (service.equals(FIELD_QUERY_SERVICE)) {
    441        
    442         createFieldQueryParamList(display, true, lang);
    443     }
    444     // now need to add in the params
     380            createFieldQueryParamList(display, true, lang);
     381    }
    445382    if (service.equals(ADVANCED_FIELD_QUERY_SERVICE)) {
    446        
    447383        createAdvancedFieldQueryParamList(display, true, lang);
    448384    }
     385
    449386    return display;
    450    
    451387    }
    452388
    453389   
    454390    /** process a text query */
    455     protected Element processTextQuery(Element request) {
    456 
     391    protected Element processTextQuery(Element request)
     392    {
     393    // Create a new (empty) result message
    457394    Element result = doc_.createElement(GSXML.RESPONSE_ELEM);
    458395    String from = GSPath.appendLink(cluster_name_, TEXT_QUERY_SERVICE);
    459396    result.setAttribute(GSXML.FROM_ATT, from);
    460     result.setAttribute(GSXML.TYPE_ATT, GSXML.REQUEST_TYPE_QUERY);
    461    
    462     // get param list
    463     Element param_list = (Element)GSXML.getChildByTagName(request, GSXML.PARAM_ELEM+GSXML.LIST_MODIFIER);
    464     if (param_list==null) {
    465         System.err.println("GS2MGPPSearch, TextQuery Error: no param list in request!");
    466         return result; // empty result
    467     }
     397    result.setAttribute(GSXML.TYPE_ATT, GSXML.REQUEST_TYPE_PROCESS);
     398    Element result_content = doc_.createElement(GSXML.CONTENT_ELEM);
     399    result.appendChild(result_content);
     400
     401    // Get the parameters of the request
     402    Element param_list = (Element) GSXML.getChildByTagName(request, GSXML.PARAM_ELEM+GSXML.LIST_MODIFIER);
     403    if (param_list == null) {
     404        System.err.println("Error: TextQuery request had no paramList.");
     405        return result;  // Return the empty result
     406    }
     407
     408    // Process the request parameters
    468409    HashMap params = GSXML.extractParams(param_list);
    469     String query = (String)params.get(QUERY_PARAM);
    470     if (query == null) {
    471         // nothing to query
    472         return result;
    473     }
    474    
    475     String index = (String)params.get(INDEX_PARAM);
    476     if (index==null) { // if its not present, use the default index
    477         index=default_index_;
    478     }
    479 
    480     // now set up the mgpp stuff
    481     String basedir = GSFile.collectionBaseDir(site_home_,
    482                           cluster_name_);
     410
     411    // Make sure a query has been specified
     412    String query = (String) params.get(QUERY_PARAM);
     413    if (query == null || query == "") {
     414        return result;  // Return the empty result
     415    }
     416
     417    // If an index hasn't been specified, use the default
     418    String index = (String) params.get(INDEX_PARAM);
     419    if (index == null) {
     420        index = default_index_;
     421    }
     422
     423    // The location of the MGPP text files
     424    String basedir = GSFile.collectionBaseDir(site_home_, cluster_name_);
    483425    String indexdir = GSFile.collectionIndexPath(cluster_name_, index);
     426    System.out.println("Base directory: " + basedir);
     427    System.out.println("Index directory: " + indexdir);
    484428
    485429    mgpp_src_.loadIndexData(basedir, indexdir);
     430
    486431    setStandardQueryParams(params);
    487    
    488     mgpp_src_.runQuery(query);
     432        mgpp_src_.runQuery(query);
    489433    MGPPQueryResult mqr= mgpp_src_.getQueryResult();
    490    
    491     // get the docnums out, and convert to HASH ids
     434    long totalDocs = mqr.getTotalDocs();
     435    System.out.println("Total documents: " + totalDocs);
     436
     437    // Get the docnums out, and convert to HASH ids
    492438    Vector docs = mqr.getDocs();
    493439    if (docs.size()==0) {
    494         // no docs found
    495         return result;
    496     }
    497     // create a documentList element
    498     Element c = doc_.createElement(GSXML.CONTENT_ELEM);
    499     result.appendChild(c);
     440        System.out.println("Warning: No results found...\n");
     441        // return result;
     442    }
     443
     444    // Create a metadata list to store information about the query results
     445    Element metadata_list = GSXML.addMetaList(doc_, result);
     446
     447    // Add a metadata element specifying the number of matching documents
     448    Element num_matches_elem = doc_.createElement(GSXML.METADATA_ELEM);
     449    num_matches_elem.setAttribute(GSXML.NAME_ATT, "numDocsMatched");
     450    num_matches_elem.setAttribute(GSXML.VALUE_ATT, "" + totalDocs);
     451    metadata_list.appendChild(num_matches_elem);
     452
     453    // Create a document list to store the matching documents, and add them
    500454    Element document_list = doc_.createElement(GSXML.DOCUMENT_ELEM+GSXML.LIST_MODIFIER);
    501     c.appendChild(document_list);
    502     // add each document
    503     for (int d=0; d<docs.size(); d++) {
    504         long docnum = ((MGPPDocInfo)docs.elementAt(d)).num_;
    505         String id = gdbm_src_.docnum2Oid(docnum);
    506         Node no = GSXML.createDocumentElement(doc_, id);
    507         document_list.appendChild(no);
    508     }
     455    result_content.appendChild(document_list);
     456    for (int d = 0; d < docs.size(); d++) {
     457        long docnum = ((MGPPDocInfo) docs.elementAt(d)).num_;
     458        String doc_id = gdbm_src_.docnum2Oid(docnum);
     459        Element doc_node = createDocumentNodeElement(doc_id);
     460        document_list.appendChild(doc_node);
     461    }
     462
     463    // Create a term list to store the term information, and add it
     464    Element term_list = doc_.createElement(GSXML.TERM_ELEM+GSXML.LIST_MODIFIER);
     465    result_content.appendChild(term_list);
     466    Vector terms = mqr.getTerms();
     467    for (int t = 0; t < terms.size(); t++) {
     468        MGPPTermInfo term_info = (MGPPTermInfo) terms.get(t);
     469
     470        String term = term_info.term_;
     471        int stem_method = term_info.stem_method_;
     472        Vector equiv_terms = term_info.equiv_terms_;
     473
     474        Element term_elem = doc_.createElement(GSXML.TERM_ELEM);
     475        term_elem.setAttribute(GSXML.NAME_ATT, term);
     476        term_elem.setAttribute(STEM_ATT, "" + stem_method);
     477
     478        Element equiv_term_list = doc_.createElement(EQUIV_TERM_ELEM+GSXML.LIST_MODIFIER);
     479        term_elem.appendChild(equiv_term_list);
     480
     481        for (int et = 0; et < equiv_terms.size(); et++) {
     482        String equiv_term = (String) equiv_terms.get(et);
     483
     484        Element equiv_term_elem = doc_.createElement(GSXML.TERM_ELEM);
     485        equiv_term_elem.setAttribute(GSXML.NAME_ATT, equiv_term);
     486        equiv_term_elem.setAttribute(NUM_DOCS_MATCH_ATT, "");
     487        equiv_term_elem.setAttribute(FREQ_ATT, "");
     488        equiv_term_list.appendChild(equiv_term_elem);
     489        }
     490
     491        term_elem.setAttribute(FREQ_ATT, "" + term_info.term_freq_);
     492        term_list.appendChild(term_elem);
     493    }
     494
    509495    return result;
    510     }//processTextQuery
     496    }
     497
    511498
    512499    protected Element processFieldQuery(Element request) {
    … …  
    514501    }
    515502
     503
    516504    protected Element processAdvancedFieldQuery(Element request) {
    517505    return processAnyFieldQuery(request, "advanced");
    518506    }
     507
    519508
    520509    /** process a fielded query */
Note: See TracChangeset for help on using the changeset viewer.