Open Source Projects Europe

#include "termproc.h"

#include "termproc.h"

#include "synfamily.h"

#include "synfamily.h"

#include "stemdb.h"

#include "stemdb.h"

#include "expansiondbs.h"

#include "expansiondbs.h"

#include "base64.h"

#include "base64.h"

namespace Rcl {

namespace Rcl {

typedef  vector<SearchDataClause *>::iterator qlist_it_t;

typedef  vector<SearchDataClause *>::iterator qlist_it_t;

typedef  vector<SearchDataClause *>::const_iterator qlist_cit_t;

typedef  vector<SearchDataClause *>::const_iterator qlist_cit_t;

static const int original_term_wqf_booster = 10;

static const int original_term_wqf_booster = 10;

{

{

}

}

// Expand categories and mime type wild card exps

// Expand categories and mime type wild card exps

// Actually, using getAllMimeTypes() here is a bit problematic because

// Actually, using getAllMimeTypes() here is a bit problematic because

// there maybe other types in the index, not indexed by content, but

// there maybe other types in the index, not indexed by content, but

    if (cfg->isMimeCategory(*it)) {

    if (cfg->isMimeCategory(*it)) {

        vector<string>tps;

        vector<string>tps;

        cfg->getMimeCatTypes(*it, tps);

        cfg->getMimeCatTypes(*it, tps);

        exptps.insert(exptps.end(), tps.begin(), tps.end());

        exptps.insert(exptps.end(), tps.begin(), tps.end());

    } else {

    } else {

        for (vector<string>::const_iterator ait = alltypes.begin();

        for (vector<string>::const_iterator ait = alltypes.begin();

         ait != alltypes.end(); ait++) {

         ait != alltypes.end(); ait++) {

        if (fnmatch(it->c_str(), ait->c_str(), FNM_CASEFOLD) 

        if (fnmatch(it->c_str(), ait->c_str(), FNM_CASEFOLD) 

            != FNM_NOMATCH) {

            != FNM_NOMATCH) {

            exptps.push_back(*ait);

            exptps.push_back(*ait);

        }

        }

        }

        }

    }

    }

    }

    }

    tps = exptps;

    tps = exptps;

    return true;

    return true;

}

}

bool SearchData::clausesToQuery(Rcl::Db &db, SClType tp, 

bool SearchData::clausesToQuery(Rcl::Db &db, SClType tp, 

                vector<SearchDataClause*>& query, 

                vector<SearchDataClause*>& query, 

{

{

    Xapian::Query xq;

    Xapian::Query xq;

    for (qlist_it_t it = query.begin(); it != query.end(); it++) {

    for (qlist_it_t it = query.begin(); it != query.end(); it++) {

    Xapian::Query nq;

    Xapian::Query nq;

    if (!(*it)->toNativeQuery(db, &nq)) {

        LOGERR(("SearchData::clausesToQuery: toNativeQuery failed: %s\n",

        LOGERR(("SearchData::clausesToQuery: toNativeQuery failed: %s\n",

            (*it)->getReason().c_str()));

            (*it)->getReason().c_str()));

        reason += (*it)->getReason() + " ";

        reason += (*it)->getReason() + " ";

        return false;

        return false;

    }       

    }       

            else 

            else 

                xq = nq;

                xq = nq;

        } else {

        } else {

            xq = Xapian::Query(op, xq, nq);

            xq = Xapian::Query(op, xq, nq);

        }

        }

        LOGERR(("Maximum Xapian query size exceeded."

        LOGERR(("Maximum Xapian query size exceeded."

            " Maybe increase maxXapianClauses."));

            " Maybe increase maxXapianClauses."));

        m_reason += "Maximum Xapian query size exceeded."

        m_reason += "Maximum Xapian query size exceeded."

        " Maybe increase maxXapianClauses.";

        " Maybe increase maxXapianClauses.";

        return false;

        return false;

   *((Xapian::Query *)d) = xq;

   *((Xapian::Query *)d) = xq;

    return true;

    return true;

}

}

bool SearchData::toNativeQuery(Rcl::Db &db, void *d)

{

{

    LOGDEB(("SearchData::toNativeQuery: stemlang [%s]\n", m_stemlang.c_str()));

    LOGDEB(("SearchData::toNativeQuery: stemlang [%s]\n", m_stemlang.c_str()));

    m_reason.erase();

    m_reason.erase();

    // Walk the clause list translating each in turn and building the 

    // Walk the clause list translating each in turn and building the 

    // Xapian query tree

    // Xapian query tree

    Xapian::Query xq;

    Xapian::Query xq;

    if (!clausesToQuery(db, m_tp, m_query, m_reason, &xq)) {

    LOGERR(("SearchData::toNativeQuery: clausesToQuery failed. reason: %s\n", 

    LOGERR(("SearchData::toNativeQuery: clausesToQuery failed. reason: %s\n", 

        m_reason.c_str()));

        m_reason.c_str()));

    return false;

    return false;

    }

    }

    m_query.push_back(cl);

    m_query.push_back(cl);

    return true;

    return true;

}

}

// Make me all new

// Make me all new

void SearchData::erase() 

    LOGDEB0(("SearchData::erase\n"));

    LOGDEB0(("SearchData::erase\n"));

    m_tp = SCLT_AND;

    m_tp = SCLT_AND;

    for (qlist_it_t it = m_query.begin(); it != m_query.end(); it++)

    for (qlist_it_t it = m_query.begin(); it != m_query.end(); it++)

    delete *it;

    delete *it;

    m_query.clear();

    m_query.clear();

    TextSplitQ *m_ts;

    TextSplitQ *m_ts;

    map<int, string> m_terms;

    map<int, string> m_terms;

    map<int, bool> m_nste;

    map<int, bool> m_nste;

};

};

#if 1

#if 1

static void listVector(const string& what, const vector<string>&l)

static void listVector(const string& what, const vector<string>&l)

{

{

    string a;

    string a;

 * @param sterm output original input term if there were no wildcards

 * @param sterm output original input term if there were no wildcards

 * @param prefix field prefix in index. We could recompute it, but the caller

 * @param prefix field prefix in index. We could recompute it, but the caller

 *  has it already. Used in the simple case where there is nothing to expand, 

 *  has it already. Used in the simple case where there is nothing to expand, 

 *  and we just return the prefixed term (else Db::termMatch deals with it).

 *  and we just return the prefixed term (else Db::termMatch deals with it).

 */

 */

{

{

    LOGDEB0(("expandTerm: mods 0x%x fld [%s] trm [%s] lang [%s]\n",

    LOGDEB0(("expandTerm: mods 0x%x fld [%s] trm [%s] lang [%s]\n",

    sterm.clear();

    sterm.clear();

    oexp.clear();

    oexp.clear();

    if (term.empty())

    if (term.empty())

    return true;

    return true;

    bool haswild = term.find_first_of(cstr_minwilds) != string::npos;

    bool haswild = term.find_first_of(cstr_minwilds) != string::npos;

    // If there are no wildcards, add term to the list of user-entered terms

    // If there are no wildcards, add term to the list of user-entered terms

    if (!haswild)

    if (!haswild)

    m_hld.uterms.insert(term);

    bool nostemexp = (mods & SearchDataClause::SDCM_NOSTEMMING) != 0;

    bool nostemexp = (mods & SearchDataClause::SDCM_NOSTEMMING) != 0;

    // No stem expansion if there are wildcards or if prevented by caller

    // No stem expansion if there are wildcards or if prevented by caller

    LOGDEB2(("expandTerm: found wildcards or stemlang empty: no exp\n"));

    LOGDEB2(("expandTerm: found wildcards or stemlang empty: no exp\n"));

    nostemexp = true;

    nostemexp = true;

    }

    }

    bool noexpansion = nostemexp && !haswild;

    bool noexpansion = nostemexp && !haswild;

    // If any character has a diacritic, we become

    // If any character has a diacritic, we become

    // diacritic-sensitive. Note that the way that the test is

    // diacritic-sensitive. Note that the way that the test is

    // performed (conversion+comparison) will automatically ignore

    // performed (conversion+comparison) will automatically ignore

    // accented characters which are actually a separate letter

    // accented characters which are actually a separate letter

        LOGDEB0(("expandTerm: term has accents -> diac-sensitive\n"));

        LOGDEB0(("expandTerm: term has accents -> diac-sensitive\n"));

        diac_sensitive = true;

        diac_sensitive = true;

    }

    }

    // If any character apart the first is uppercase, we become

    // If any character apart the first is uppercase, we become

    // case-sensitive.  The first character is reserved for

    // case-sensitive.  The first character is reserved for

    // turning off stemming. You need to use a query language

    // turning off stemming. You need to use a query language

    // modifier to search for Floor in a case-sensitive way.

    // modifier to search for Floor in a case-sensitive way.

    Utf8Iter it(term);

    Utf8Iter it(term);

    it++;

    it++;

        LOGDEB0(("expandTerm: term has uppercase -> case-sensitive\n"));

        LOGDEB0(("expandTerm: term has uppercase -> case-sensitive\n"));

        case_sensitive = true;

        case_sensitive = true;

    }

    }

    // If we are sensitive to case or diacritics turn stemming off

    // If we are sensitive to case or diacritics turn stemming off

#endif

#endif

    if (noexpansion) {

    if (noexpansion) {

    sterm = term;

    sterm = term;

    oexp.push_back(prefix + term);

    oexp.push_back(prefix + term);

    m_hld.terms[term] = m_hld.uterms.size() - 1;

    LOGDEB(("ExpandTerm: final: %s\n", stringsToString(oexp).c_str()));

    LOGDEB(("ExpandTerm: final: %s\n", stringsToString(oexp).c_str()));

    return true;

    return true;

    } 

    } 

    // Make objects before the goto jungle to avoid compiler complaints

    // Make objects before the goto jungle to avoid compiler complaints

    SynTermTransUnac unacfoldtrans(UNACOP_UNACFOLD);

    SynTermTransUnac unacfoldtrans(UNACOP_UNACFOLD);

    XapComputableSynFamMember synac(db.m_ndb->xrdb, synFamDiCa, "all", 

                    &unacfoldtrans);

                    &unacfoldtrans);

    // This will hold the result of case and diacritics expansion as input

    // This will hold the result of case and diacritics expansion as input

    // to stem expansion.

    // to stem expansion.

    vector<string> lexp;

    vector<string> lexp;

    if (haswild) {

    if (haswild) {

    // Note that if there are wildcards, we do a direct from-index

    // Note that if there are wildcards, we do a direct from-index

    // expansion, which means that we are casediac-sensitive. There

    // expansion, which means that we are casediac-sensitive. There

    // would be nothing to prevent us to expand from the casediac

    // would be nothing to prevent us to expand from the casediac

    // synonyms first. To be done later

    // synonyms first. To be done later

    goto termmatchtoresult;

    goto termmatchtoresult;

    }

    }

    sterm = term;

    sterm = term;

#ifdef RCL_INDEX_STRIPCHARS

#ifdef RCL_INDEX_STRIPCHARS

#else

#else

    if (o_index_stripchars) {

    if (o_index_stripchars) {

    // If the index is raw, we can only come here if nostemexp is unset

    // If the index is raw, we can only come here if nostemexp is unset

    // and we just need stem expansion.

    // and we just need stem expansion.

    goto termmatchtoresult;

    goto termmatchtoresult;

    } 

    } 

    // No stem expansion when diacritic or case sensitivity is set, it

    // No stem expansion when diacritic or case sensitivity is set, it

    // makes no sense (it would mess with the diacritics anyway if

    // makes no sense (it would mess with the diacritics anyway if

    }

    }

    sort(lexp.begin(), lexp.end());

    sort(lexp.begin(), lexp.end());

    {

    {

    vector<string>::iterator uit = unique(lexp.begin(), lexp.end());

    vector<string>::iterator uit = unique(lexp.begin(), lexp.end());

    lexp.resize(uit - lexp.begin());

    lexp.resize(uit - lexp.begin());

    vector<string> exp1;

    vector<string> exp1;

    for (vector<string>::const_iterator it = lexp.begin(); 

    for (vector<string>::const_iterator it = lexp.begin(); 

         it != lexp.end(); it++) {

         it != lexp.end(); it++) {

    }

    }

    LOGDEB(("ExpTerm: stem exp-> %s\n", stringsToString(exp1).c_str()));

    LOGDEB(("ExpTerm: stem exp-> %s\n", stringsToString(exp1).c_str()));

    // Expand the resulting list for case (all stemdb content

    // Expand the resulting list for case (all stemdb content

    // is lowercase)

    // is lowercase)

    // Bogus wildcard expand to generate the result (possibly add prefixes)

    // Bogus wildcard expand to generate the result (possibly add prefixes)

exptotermatch:

exptotermatch:

    LOGDEB(("ExpandTerm:TM: lexp: %s\n", stringsToString(lexp).c_str()));

    LOGDEB(("ExpandTerm:TM: lexp: %s\n", stringsToString(lexp).c_str()));

    for (vector<string>::const_iterator it = lexp.begin();

    for (vector<string>::const_iterator it = lexp.begin();

     it != lexp.end(); it++) {

     it != lexp.end(); it++) {

    }

    }

#endif

#endif

    // Term match entries to vector of terms

    // Term match entries to vector of terms

termmatchtoresult:

termmatchtoresult:

    ermsg = "Maximum term expansion size exceeded."

    ermsg = "Maximum term expansion size exceeded."

        " Maybe increase maxTermExpand.";

        " Maybe increase maxTermExpand.";

    return false;

    return false;

    }

    }

    for (vector<TermMatchEntry>::const_iterator it = res.entries.begin(); 

    for (vector<TermMatchEntry>::const_iterator it = res.entries.begin(); 

    oexp.push_back(prefix + term);

    oexp.push_back(prefix + term);

    // Remember the uterm-to-expansion links

    // Remember the uterm-to-expansion links

    for (vector<string>::const_iterator it = oexp.begin(); 

    for (vector<string>::const_iterator it = oexp.begin(); 

     it != oexp.end(); it++) {

     it != oexp.end(); it++) {

    m_hld.terms[strip_prefix(*it)] = term;

    }

    }

    LOGDEB(("ExpandTerm: final: %s\n", stringsToString(oexp).c_str()));

    LOGDEB(("ExpandTerm: final: %s\n", stringsToString(oexp).c_str()));

    return true;

    return true;

}

}

    // vector)

    // vector)

    comb.pop_back();

    comb.pop_back();

    }

    }

}

}

{

{

    LOGDEB0(("StringToXapianQ::processSimpleSpan: [%s] mods 0x%x\n",

    LOGDEB0(("StringToXapianQ::processSimpleSpan: [%s] mods 0x%x\n",

        span.c_str(), (unsigned int)mods));

        span.c_str(), (unsigned int)mods));

    vector<string> exp;  

    vector<string> exp;  

    string sterm; // dumb version of user term

    string sterm; // dumb version of user term

    string prefix;

    string prefix;

    const FieldTraits *ftp;

    const FieldTraits *ftp;

    if (!m_field.empty() && db.fieldToTraits(m_field, &ftp)) {

    prefix = wrap_prefix(ftp->pfx);

    prefix = wrap_prefix(ftp->pfx);

    }

    }

    if (!expandTerm(ermsg, mods, span, exp, sterm, prefix))

    return;

    return;

    // Set up the highlight data. No prefix should go in there

    // Set up the highlight data. No prefix should go in there

    for (vector<string>::const_iterator it = exp.begin(); 

    for (vector<string>::const_iterator it = exp.begin(); 

     it != exp.end(); it++) {

     it != exp.end(); it++) {

    m_hld.groups.push_back(vector<string>(1, it->substr(prefix.size())));

    m_hld.slacks.push_back(0);

    m_hld.grpsugidx.push_back(m_hld.ugroups.size() - 1);

    }

    }

    // Push either term or OR of stem-expanded set

    // Push either term or OR of stem-expanded set

    Xapian::Query xq(Xapian::Query::OP_OR, exp.begin(), exp.end());

    Xapian::Query xq(Xapian::Query::OP_OR, exp.begin(), exp.end());

    m_curcl += exp.size();

    m_curcl += exp.size();

    // If sterm (simplified original user term) is not null, give it a

    // If sterm (simplified original user term) is not null, give it a

    // relevance boost. We do this even if no expansion occurred (else

    // relevance boost. We do this even if no expansion occurred (else

    // the non-expanded terms in a term list would end-up with even

    // the non-expanded terms in a term list would end-up with even

    // less wqf). This does not happen if there are wildcards anywhere

    // less wqf). This does not happen if there are wildcards anywhere

    // in the search.

    // in the search.

    if (doBoostUserTerm && !sterm.empty()) {

        xq = Xapian::Query(Xapian::Query::OP_OR, xq, 

        xq = Xapian::Query(Xapian::Query::OP_OR, xq, 

               Xapian::Query(prefix+sterm, 

               Xapian::Query(prefix+sterm, 

                     original_term_wqf_booster));

                     original_term_wqf_booster));

    }

    }

    pqueries.push_back(xq);

    pqueries.push_back(xq);

// User entry element had several terms: transform into a PHRASE or

// User entry element had several terms: transform into a PHRASE or

// NEAR xapian query, the elements of which can themselves be OR

// NEAR xapian query, the elements of which can themselves be OR

// queries if the terms get expanded by stemming or wildcards (we

// queries if the terms get expanded by stemming or wildcards (we

// don't do stemming for PHRASE though)

// don't do stemming for PHRASE though)

{

{

    Xapian::Query::op op = useNear ? Xapian::Query::OP_NEAR : 

    Xapian::Query::op op = useNear ? Xapian::Query::OP_NEAR : 

    Xapian::Query::OP_PHRASE;

    Xapian::Query::OP_PHRASE;

    vector<Xapian::Query> orqueries;

    vector<Xapian::Query> orqueries;

#ifdef XAPIAN_NEAR_EXPAND_SINGLE_BUF

#ifdef XAPIAN_NEAR_EXPAND_SINGLE_BUF

    bool hadmultiple = false;

    bool hadmultiple = false;

#endif

#endif

    vector<vector<string> >groups;

    vector<vector<string> >groups;

    string prefix;

    string prefix;

    const FieldTraits *ftp;

    const FieldTraits *ftp;

    if (!m_field.empty() && db.fieldToTraits(m_field, &ftp)) {

    prefix = wrap_prefix(ftp->pfx);

    prefix = wrap_prefix(ftp->pfx);

    }

    }

    if (mods & Rcl::SearchDataClause::SDCM_ANCHORSTART) {

    if (mods & Rcl::SearchDataClause::SDCM_ANCHORSTART) {

    orqueries.push_back(Xapian::Query(prefix + start_of_field_term));

    orqueries.push_back(Xapian::Query(prefix + start_of_field_term));

    int lmods = mods;

    int lmods = mods;

    if (nostemexp)

    if (nostemexp)

        lmods |= SearchDataClause::SDCM_NOSTEMMING;

        lmods |= SearchDataClause::SDCM_NOSTEMMING;

    string sterm;

    string sterm;

    vector<string> exp;

    vector<string> exp;

    if (!expandTerm(ermsg, lmods, *it, exp, sterm, prefix))

        return;

        return;

    LOGDEB0(("ProcessPhraseOrNear: exp size %d\n", exp.size()));

    LOGDEB0(("ProcessPhraseOrNear: exp size %d\n", exp.size()));

    listVector("", exp);

    listVector("", exp);

    // groups is used for highlighting, we don't want prefixes in there.

    // groups is used for highlighting, we don't want prefixes in there.

    vector<string> noprefs;

    vector<string> noprefs;

    }

    }

    groups.push_back(noprefs);

    groups.push_back(noprefs);

    orqueries.push_back(Xapian::Query(Xapian::Query::OP_OR, 

    orqueries.push_back(Xapian::Query(Xapian::Query::OP_OR, 

                      exp.begin(), exp.end()));

                      exp.begin(), exp.end()));

    m_curcl += exp.size();

    m_curcl += exp.size();

        return;

        return;

#ifdef XAPIAN_NEAR_EXPAND_SINGLE_BUF

#ifdef XAPIAN_NEAR_EXPAND_SINGLE_BUF

    if (exp.size() > 1) 

    if (exp.size() > 1) 

        hadmultiple = true;

        hadmultiple = true;

#endif

#endif

    vector<string> comb;

    vector<string> comb;

    multiply_groups(groups.begin(), groups.end(), comb, allcombs);

    multiply_groups(groups.begin(), groups.end(), comb, allcombs);

    // Insert the search groups and slacks in the highlight data, with

    // Insert the search groups and slacks in the highlight data, with

    // a reference to the user entry that generated them:

    // a reference to the user entry that generated them:

    m_hld.slacks.insert(m_hld.slacks.end(), allcombs.size(), slack);

    m_hld.grpsugidx.insert(m_hld.grpsugidx.end(), allcombs.size(), 

               m_hld.ugroups.size() - 1);

}

}

// Trim string beginning with ^ or ending with $ and convert to flags

// Trim string beginning with ^ or ending with $ and convert to flags

static int stringToMods(string& s)

static int stringToMods(string& s)

{

{

 *   - Elements corresponding to phrase/near are an OP_PHRASE/NEAR

 *   - Elements corresponding to phrase/near are an OP_PHRASE/NEAR

 *     composition of the phrase terms (no stem expansion in this case)

 *     composition of the phrase terms (no stem expansion in this case)

 * @return the subquery count (either or'd stem-expanded terms or phrase word

 * @return the subquery count (either or'd stem-expanded terms or phrase word

 *   count)

 *   count)

 */

 */

                    string &ermsg,

{

{

    LOGDEB(("StringToXapianQ:pUS:: qstr [%s] fld [%s] mods 0x%x "

    LOGDEB(("StringToXapianQ:pUS:: qstr [%s] fld [%s] mods 0x%x "

        "slack %d near %d\n", 

        "slack %d near %d\n", 

        iq.c_str(), m_field.c_str(), mods, slack, useNear));

        iq.c_str(), m_field.c_str(), mods, slack, useNear));

    ermsg.erase();

    ermsg.erase();

    m_curcl = 0;

    m_curcl = 0;

    const StopList stops = db.getStopList();

    // Simple whitespace-split input into user-level words and

    // Simple whitespace-split input into user-level words and

    // double-quoted phrases: word1 word2 "this is a phrase". 

    // double-quoted phrases: word1 word2 "this is a phrase". 

    //

    //

    // The text splitter may further still decide that the resulting

    // The text splitter may further still decide that the resulting

        continue;// ??

        continue;// ??

        case 1: {

        case 1: {

        int lmods = mods;

        int lmods = mods;

        if (splitter.nostemexps.front())

        if (splitter.nostemexps.front())

            lmods |= SearchDataClause::SDCM_NOSTEMMING;

            lmods |= SearchDataClause::SDCM_NOSTEMMING;

        m_hld.ugroups.push_back(vector<string>(1, *it));

        }

        }

        break;

        break;

        default:

        default:

        m_hld.ugroups.push_back(vector<string>(1, *it));

        processPhraseOrNear(ermsg, &splitter, mods, pqueries,

                    useNear, slack);

                    useNear, slack);

        }

        }

        ermsg = "Maximum Xapian query size exceeded."

        ermsg = "Maximum Xapian query size exceeded."

            " Maybe increase maxXapianClauses.";

            " Maybe increase maxXapianClauses.";

        break;

        break;

        }

        }

    }

    }

    }

    }

    return true;

    return true;

}

}

// Translate a simple OR, AND, or EXCL search clause. 

// Translate a simple OR, AND, or EXCL search clause. 

{

{

    LOGDEB2(("SearchDataClauseSimple::toNativeQuery: stemlang [%s]\n",

    LOGDEB2(("SearchDataClauseSimple::toNativeQuery: stemlang [%s]\n",

         getStemLang().c_str()));

         getStemLang().c_str()));

    Xapian::Query *qp = (Xapian::Query *)p;

    Xapian::Query *qp = (Xapian::Query *)p;

    case SCLT_EXCL: op = Xapian::Query::OP_OR; break;

    case SCLT_EXCL: op = Xapian::Query::OP_OR; break;

    default:

    default:

    LOGERR(("SearchDataClauseSimple: bad m_tp %d\n", m_tp));

    LOGERR(("SearchDataClauseSimple: bad m_tp %d\n", m_tp));

    return false;

    return false;

    }

    }

    vector<Xapian::Query> pqueries;

    vector<Xapian::Query> pqueries;

    return false;

    return false;

    if (pqueries.empty()) {

    if (pqueries.empty()) {

    LOGERR(("SearchDataClauseSimple: resolved to null query\n"));

    LOGERR(("SearchDataClauseSimple: resolved to null query\n"));

    return true;

    return true;

    }

    }

//

//

// We do not split the entry any more (used to do some crazy thing

// We do not split the entry any more (used to do some crazy thing

// about expanding multiple fragments in the past). We just take the

// about expanding multiple fragments in the past). We just take the

// value blanks and all and expand this against the indexed unsplit

// value blanks and all and expand this against the indexed unsplit

// file names

// file names

{

{

    Xapian::Query *qp = (Xapian::Query *)p;

    Xapian::Query *qp = (Xapian::Query *)p;

    *qp = Xapian::Query();

    *qp = Xapian::Query();

    vector<string> names;

    vector<string> names;

    db.filenameWildExp(m_text, names, maxexp);

    db.filenameWildExp(m_text, names, maxexp);

    *qp = Xapian::Query(Xapian::Query::OP_OR, names.begin(), names.end());

    *qp = Xapian::Query(Xapian::Query::OP_OR, names.begin(), names.end());

    if (m_weight != 1.0) {

    if (m_weight != 1.0) {

    *qp = Xapian::Query(Xapian::Query::OP_SCALE_WEIGHT, *qp, m_weight);

    *qp = Xapian::Query(Xapian::Query::OP_SCALE_WEIGHT, *qp, m_weight);

    }

    }

    return true;

    return true;

}

}

// Translate NEAR or PHRASE clause. 

// Translate NEAR or PHRASE clause. 

{

{

    LOGDEB(("SearchDataClauseDist::toNativeQuery\n"));

    LOGDEB(("SearchDataClauseDist::toNativeQuery\n"));

    Xapian::Query *qp = (Xapian::Query *)p;

    Xapian::Query *qp = (Xapian::Query *)p;

    *qp = Xapian::Query();

    *qp = Xapian::Query();

    vector<Xapian::Query> pqueries;

    vector<Xapian::Query> pqueries;

    Xapian::Query nq;

    Xapian::Query nq;

    // We produce a single phrase out of the user entry then use

    // We produce a single phrase out of the user entry then use

    // stringToXapianQueries() to lowercase and simplify the phrase

    // stringToXapianQueries() to lowercase and simplify the phrase

    // terms etc. This will result into a single (complex)

    // terms etc. This will result into a single (complex)

    // Xapian::Query.

    // Xapian::Query.

    if (m_text.find('\"') != string::npos) {

    if (m_text.find('\"') != string::npos) {

    m_text = neutchars(m_text, "\"");

    m_text = neutchars(m_text, "\"");

    }

    }

    string s = cstr_dquote + m_text + cstr_dquote;

    string s = cstr_dquote + m_text + cstr_dquote;

    bool useNear = (m_tp == SCLT_NEAR);

    bool useNear = (m_tp == SCLT_NEAR);

               m_slack, useNear))

    return false;

    return false;

    if (pqueries.empty()) {

    if (pqueries.empty()) {

    LOGERR(("SearchDataClauseDist: resolved to null query\n"));

    LOGERR(("SearchDataClauseDist: resolved to null query\n"));

    return true;

    return true;

    }

    }