Laboratoire ICAR » Plateforme TXM

import org.txm.searchengine.cqp.corpus.query.CQLQuery;

			Subcorpus sub = corpus.createSubcorpus(new CQLQuery("\"je\" expand to p"), "JEP"); //$NON-NLS-1$ //$NON-NLS-2$

import org.txm.searchengine.cqp.corpus.query.CQLQuery;

			QueryResult result = corpus.query(new CQLQuery("<"+properties.get(j).getFullName()+">[]"), "summary", false); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$

			result = corpus.query(new CQLQuery("[]</"+properties.get(j).getFullName()+">"), "summary", false); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$

import org.txm.searchengine.cqp.corpus.query.CQLQuery;

	CQLQuery query;

		this.query = new CQLQuery("<text>[]"); //$NON-NLS-1$

				QueryResult result2 = corpus.query(new CQLQuery("/region[text,a]:: a.text_id=\""+textids.get(i)+"\""), "temp", false); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$

import org.txm.searchengine.cqp.corpus.query.CQLQuery;

			QueryResult rez = src.query(new CQLQuery("[_.text_id=\""+textid+"\" & id=\""+wordid+"\"]"), "Align", false);

				QueryResult rez2 = dest.query(new CQLQuery("<"+struct+"_align=\""+aligned_struct+"\">[]"), "Align", false);

			QueryResult rez = src.query(new CQLQuery(query), "Align", false);

				QueryResult rez2 = dest.query(new CQLQuery(query), "Align", false);

		QueryResult rez = dest.query(new CQLQuery(query), "Align", false);

// Copyright © 2010-2013 ENS de Lyon.

// Copyright © 2007-2010 ENS de Lyon, CNRS, INRP, University of

// Lyon 2, University of Franche-Comté, University of Nice

// Sophia Antipolis, University of Paris 3.

// 

// The TXM platform is free software: you can redistribute it

// and/or modify it under the terms of the GNU General Public

// License as published by the Free Software Foundation,

// either version 2 of the License, or (at your option) any

// later version.

// 

// The TXM platform is distributed in the hope that it will be

// useful, but WITHOUT ANY WARRANTY; without even the implied

// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR

// PURPOSE. See the GNU General Public License for more

// details.

// 

// You should have received a copy of the GNU General

// Public License along with the TXM platform. If not, see

// http://www.gnu.org/licenses.

// 

// 

// 

// $LastChangedDate: 2015-05-13 09:46:56 +0200 (Wed, 13 May 2015) $

// $LastChangedRevision: 2967 $

// $LastChangedBy: mdecorde $ 

//

package org.txm.searchengine.cqp.corpus.query;

import java.util.ArrayList;

import java.util.List;

import java.util.regex.Matcher;

import java.util.regex.Pattern;

import org.txm.core.preferences.TXMPreferences;

import org.txm.searchengine.core.Query;

/**

 * Implements a CQL query. Use fixQuery to use query sugar.

 * 

 * @author sloiseau

 * @author jpmague

 * @author sheiden

 * @author sjacquot

 */

public class CQLQuery implements Query {

	/** The Constant NoStrategy. */

	private static final Integer NoStrategy = 0;

	/** The Constant JPMStrategy. */

	private static final Integer JPMStrategy = 1;

	/** The Constant WLXStrategy. */

	private static final Integer WLXStrategy = 2;

	/** The Constant ElectricStrategy. */

	private static final Integer ElectricStrategy = 3;

	/** espace char |"{()}+*. */

	private static String chars = "^$<>|\\\"{([])}?+*."; //$NON-NLS-1$

	/**

	 * The query string.

	 */

	protected String queryString;

	/**

	 * Instantiates a new query.

	 */

	protected CQLQuery() {

	}

	/**

	 * Instantiates a new query.

	 * 

	 * @param queryString

	 *            the query string

	 * 

	 *            public Query(String queryString){

	 *            this.queryString=queryString.trim(); }

	 */

	public CQLQuery(String queryString) {

		if (queryString != null) {

			this.queryString = queryString.trim();

		}

		else {

			this.queryString = "";

		}

	}

	/**

	 * Converts the specified string to a list of Query.

	 * Input string must contains queries separated by a tabulation.

	 * @param str

	 * @return

	 */

	public static List<CQLQuery> stringToQueries(String str) {

		ArrayList<CQLQuery> queries = new ArrayList<CQLQuery>();

		if (str == null || str.length() == 0) {

			return queries;

		}

		String[] split = str.split(TXMPreferences.LIST_SEPARATOR);

		for (String s : split) {

			queries.add(new CQLQuery(s));

		}

		return queries;

	}

	/**

	 * Converts the specified list of Query to a string.

	 * Queries strings are separated by a tabulation.

	 * @param queries

	 * @return

	 */

	public static String queriesToString(List<CQLQuery> queries) {

		String str = "";

		for (int i = 0; i < queries.size(); i++) {

			if(i > 0)	{

				str += TXMPreferences.LIST_SEPARATOR;

			}

			str += queries.get(i).getQueryString();			

		}

		return str;

	}

	/**

	 * Gets the query string.

	 * 

	 * @return the query string

	 */

	public String getQueryString() {

		return queryString;

	}

	/* (non-Javadoc)

	 * @see java.lang.Object#toString()

	 */

	@Override

	public String toString() {

		return queryString;

	}

	/**

	 * Normalize white chars.

	 * 

	 * SLH algorithm :

		 * - first normalize white chars : We don't know from where the query

		 * comes from and how it was produced (pasted from a text editor after

		 * having been double-clicked and copied, typed in the query input

		 * field, etc.) The CQP syntax analyzer is sensible to white chars, so

		 * we have to normalize what the user may have leaved inadvertently

		 * because she may not see well the true query string (white chars are

		 * invisible), and it is dif ficult to accept and manage a syntax error

		 * when you can't "see" the source of the problem. That strategy decides

		 * to interpret every white chars contiguous sequence as one space

		 * character.

		 * 

		 * Please note that this may be compatible (or not) with other Search

		 * Engines query scanners.

		 * 

		 * Please note also that this may be compatible (or not) with the

		 * tokenization policy of a given corpus dealing with compound words.

		 * That strategy is compatible with a policy which separates words in

		 * compound words by one space character.

		 * 

		 * - then remove outer white chars : What is not seen should not be

		 * there if no explicit expression deals with it from the user's point

		 * of view. So white chars at the beginning or at the end of the query

		 * are removed. Those characters often come from rapid copy/paste or

		 * double-click/copy/paste (in a word processing software, the

		 * double-click strategy can for example select the white chars on the

		 * right of the selected strings to help the user move words around with

		 * their delimiters).

		 * 

		 * That strategy may seem aggressive, but experience shows that this

		 * little service helps silently users a lot and is rarely

		 * inappropriate.

		 * 

		 * In case of doubt, the user should be able to switch to another

		 * strategy.

	 *

	 * @param str the str

	 * @return the string with white chars normalized

	 */

	public static String normalizeWhiteChars(String str) {

		// normalize everything white to space

		String str1 = str.replaceAll("\\s+", " "); //$NON-NLS-1$ //$NON-NLS-2$

		// remove border whites

		str1 = str1.replaceFirst("^ ", ""); //$NON-NLS-1$ //$NON-NLS-2$

		str1 = str1.replaceFirst(" $", ""); //$NON-NLS-1$ //$NON-NLS-2$

		return str1;

	}

	/**

	 * Transforms a simplified query string into a proper CQP query string

	 * 

	 * Follows several different strategies to do that :

	 * 

	 * JPM Strategy : if the input query matches \w quote are added if the input

	 * query matches \w*="\w*", square brackets are added if the input query

	 * matches .\w=.\w (i.e. without quotes), quotes and square brackets are

	 * added (i.e. -> [$1="$2"]) otherwise, the query is left as if 

	 * 

	 * Weblex Strategy : normalize white chars add double quotes if no double

	 * quotes and no brackets

	 * 

	 * Electric Strategy : normalize white chars add double quote, equal,

	 * brackets, etc. depending on the presence/absence of those chars in the

	 * original query

	 * 

	 * No Strategy : do nothing

	 * 

	 * @param query

	 *            The query string to fix

	 * @return the fixed query string

	 */

	static public String fixQuery(String query) {

		//if (query.startsWith("intersect ")) return query;

		if ("\"".equals(query)) return "\"\\\"\""; //$NON-NLS-1$ //$NON-NLS-2$

		Integer QueryFixStrategy = WLXStrategy;

		if (QueryFixStrategy == JPMStrategy) {

			// query = abc -> put double quotes

			Pattern simple = Pattern.compile("\\p{L}*"); //$NON-NLS-1$

			if (simple.matcher(query).matches()) {

				// System.out.println("match 1");

				return '"' + query + '"'; //$NON-NLS-1$

			}

			// query = prop="abc" -> put square brackets

			Pattern equalsWithQuotes = Pattern.compile("\\p{L}+=\"\\p{L}*\""); //$NON-NLS-1$

			if (equalsWithQuotes.matcher(query).matches()) {

				// System.out.println("match 2");

				return '[' + query + ']';

			}

			// query = abc=def -> put brackets + equal sign + double quotes

			Pattern equalsWithoutQuotes = Pattern

					.compile("(\\p{L}*)=(\\p{L}*)"); //$NON-NLS-1$

			Matcher matcher = equalsWithoutQuotes.matcher(query);

			if (matcher.matches()) {

				// System.out.println("match 2");

				return '[' + matcher.group(1) + '=' + '"' + matcher.group(2)

						+ '"' + ']';

			}

			// query doesn't start with ", ' and [ -> put double quotes

			if (!query.startsWith("\"") && !query.startsWith("\'") && !query.startsWith("[")) //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$

			{

				return '"' + query + '"'; //$NON-NLS-1$

			}

			// do nothing

			return query;

		} else if (QueryFixStrategy == WLXStrategy) {

			query = normalizeWhiteChars(query);

			// empty query

			if(query.isEmpty())	{

				return query;

			}

			// query contains double quotes

			else if (query.contains("\"")) { //$NON-NLS-1$

				return query;

			}

			// query contains brackets

			else if (query.contains("[") && query.contains("]")) { //$NON-NLS-1$ //$NON-NLS-2$

				return query; // probably [] or [...]

			}

			else {

				return '"' + query + '"'; //$NON-NLS-1$

			}

		} else if (QueryFixStrategy == ElectricStrategy) {

			// DON'T USE THAT STRATEGY : CODE NEEDS TO BE FIXED

			query = normalizeWhiteChars(query);

			if (query.contains("\"")) { //$NON-NLS-1$

				if (query.contains("=")) { //$NON-NLS-1$

					if (query.contains("[")) { //$NON-NLS-1$

						return query;

					} else {

						return '[' + query + ']';

					}

				} else {

					return query;

				}

			} else {

				if (query.contains("=")) { //$NON-NLS-1$

					return query.replaceAll("=([^= \"]+)", "=\"$1\""); //$NON-NLS-1$ //$NON-NLS-2$

				} else {

					return '"' + query + '"'; //$NON-NLS-1$

				}

			}

		} else if (QueryFixStrategy == NoStrategy) {

			// no strategy to apply : do nothing

			return query;

		} else {

			// we shouldn't be there

			// let silently return the query for the moment

			return query;

		}

	}

	/**

	 * Adds the back slash.

	 *

	 * @param squery the squery

	 * @return the string

	 */

	public static String addBackSlash(String squery) {

		if ("\"".equals(squery)) return "\"\\\"\""; //$NON-NLS-1$ //$NON-NLS-2$

		StringBuffer buff = new StringBuffer();

		//for(char c : chars.)

		for(int i = 0 ; i < squery.length() ; i++) {

			int j = chars.indexOf(squery.charAt(i));

			//System.out.println(""+i+" : "+squery.charAt(i)+ " >> "+j);

			if ( j >= 0 ) {

				buff.append("\\"+squery.charAt(i)); //$NON-NLS-1$

			}

			else {

				buff.append(squery.charAt(i));

			}

		}

		return buff.toString();

	}

	/**

	 * Sets the string of the query. 

	 * @param queryString

	 */

	public void setQueryString(String queryString) {

		this.queryString = queryString;

	}

	/**

	 * Checks whatever the query is empty (null, empty or contains only double quotes) or not.

	 * @return true if empty otherwise false

	 */

	public boolean isEmpty() {

		return queryString == null || queryString.length() == 0 || "\"\"".equals(queryString);

	}

	@Override

	public boolean equals(Object obj) {

		if (!(obj instanceof CQLQuery)) {

			return false;

		}

		return this.queryString.equals(((CQLQuery) obj).queryString);

	}

	/**

	 * The main method.

	 *

	 * @param args the arguments

	 */

	public static void main(String[] args) {

		String test = "^$sdf<>sdf|\\sdf\"{(sdf)}?+sdf*."; //$NON-NLS-1$

		System.out.println(CQLQuery.addBackSlash(test));

	}

}

public class QueryFocus extends CQLQuery {

public class QueryPart extends CQLQuery {

import org.txm.searchengine.cqp.corpus.query.CQLQuery;

	protected CQLQuery query;

	protected Subcorpus(String cqpId, String name, Corpus parent, CQLQuery query) throws InvalidCqpIdException {

	 * {@link Corpus#createSubcorpus(CQLQuery, String)}

	protected Subcorpus(String cqpId, String name, Corpus parent, CQLQuery query, boolean addToParent) throws InvalidCqpIdException {

			this.query = new CQLQuery(getSelfElement().getAttribute("query")); //$NON-NLS-1$

	private void registerToParent(String subcorpusName, CQLQuery query) {

	public CQLQuery getQuery() {

import org.txm.searchengine.cqp.corpus.query.CQLQuery;

	 * Not intended to be used directly. See {@link Corpus#query(CQLQuery, String)}

			CQLQuery query, int[] starts, int[] ends, int[] targets) throws InvalidCqpIdException {

import org.txm.searchengine.cqp.corpus.query.CQLQuery;

	protected CQLQuery query;

	 * Not intended to be used directly. See {@link Corpus#query(CQLQuery, String)}

			CQLQuery query) throws InvalidCqpIdException {

	public CQLQuery getQuery() {

import org.txm.searchengine.cqp.corpus.query.CQLQuery;

	protected Part(String cqpId, String partitionName, String shortName, Partition partition, CQLQuery query) throws InvalidCqpIdException {

		this.query = new CQLQuery(pquery);

import org.txm.searchengine.cqp.corpus.query.CQLQuery;

			CQLQuery query = new QueryPart(pProperty.getStructuralUnit(), pProperty, CQLQuery.addBackSlash(value));

			part = new Part(partCqpId, partitionName, partName, this, new CQLQuery(query));

	public List<QueryResult> query(CQLQuery query, String name) throws CqiClientException {

			values.set(i, CQLQuery.addBackSlash(values.get(i)));

import org.txm.searchengine.cqp.corpus.query.CQLQuery;

		CQLQuery query = new CQLQuery(elem.getAttribute("query")); //$NON-NLS-1$

	public Subcorpus createSubcorpus(CQLQuery query, String subcorpusName)

	public Subcorpus createSubcorpus(CQLQuery query, String subcorpusName,

			value += CQLQuery.addBackSlash(v) + "|"; //$NON-NLS-1$

		CQLQuery query = new QueryPart(structuralUnit, structuralUnitProperty, value);

		CQLQuery query = new QueryPart(structuralUnit, structuralUnitProperty,

				CQLQuery.addBackSlash(value));

		CQLQuery query = new QueryPart(structuralUnit, structuralUnitProperty,

	public QueryResult query(CQLQuery query, String queryResultName, boolean save)

import org.txm.searchengine.cqp.corpus.query.CQLQuery;

			QueryResult tmp = corpus.query(new CQLQuery("<" + this.getFullName() + ">[]"), UUID.randomUUID().toString(), false); //$NON-NLS-1$ //$NON-NLS-2$

import org.txm.searchengine.cqp.corpus.query.CQLQuery;

import org.txm.searchengine.cqp.corpus.query.CQLQuery;

			QueryResult queryResult = new QueryResult(queryResultId, queryResultId, this,	new CQLQuery("<text>[] expand to text")); //$NON-NLS-1$

		QueryResult queryResult = new QueryResult(queryResultId, queryResultId, this,	new CQLQuery(cql_limit));

import org.txm.searchengine.cqp.corpus.query.CQLQuery;

			QueryResult qresult = prop.getCorpus().query(new CQLQuery("<"+sprop.getFullName()+">[] expand to "+sprop.getName()), "TMP", false); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$

			QueryResult tmp = corpus.query(new CQLQuery("<" + property.getFullName() + ">[]"), UUID.randomUUID().toString(), false); //$NON-NLS-1$ //$NON-NLS-2$

							new CQLQuery("<" + prop.getFullName() + ">[] expand to "+prop.getName()), UUID.randomUUID().toString(), false); //$NON-NLS-1$ //$NON-NLS-2$

import org.txm.searchengine.cqp.corpus.query.CQLQuery;

	protected CQLQuery pQuery;

	public CQLQuery getQuery() {

	public void setParameters(CQLQuery query, Property prop, List<StructuralUnitProperty> pattern, Boolean hierarchicSort) {

			this.pQuery = new CQLQuery(this.getStringParameterValue(ReferencerPreferences.QUERY));

	public void setQuery(CQLQuery query) {

				s = CQLQuery.addBackSlash(s);

import org.txm.searchengine.cqp.corpus.query.CQLQuery;

			QueryResult result = corpus.query(new CQLQuery(query), "TMP", true);

				QueryResult resul2t = corpus.query(new CQLQuery(segquery), "TMP", true);

				QueryResult result = corpus.query(new CQLQuery(segquery+"+</"+struct+">"), "TMP", false);

import org.txm.searchengine.cqp.corpus.query.CQLQuery;