Examples of Query

• ch.ethz.inf.vs.californium.plugtests.resources.Query
  This resource implements a test of specification for the ETSI IoT CoAP Plugtests, Las Vegas, NV, USA, 19 - 22 Nov 2013. @author Matthias Kovatsch
• com.adidas.dam.marvin.client.query.Query
  Encapsulates different options used to call Marvins REST services which include

  • format – which should not be overwritten since only JSON is supported at the moment
  • page – used to retrieve the results in pages
  • order – an expression on which field and in which direction the results should be ordered
  • filters – a list of various filter expressions and combinations which allow the results to be restricted to only some values

  @author Daniel Eichten
• com.aneeshpu.dpdeppop.query.Query
• com.antlersoft.bbq_eclipse.searchresult.Query
  @author mike
• com.apitrary.api.annotation.Query
• com.atlassian.query.Query
• com.buschmais.cdo.api.Query
  Defines a query using a fluent API. @param < T> The return type of the query.
• com.buschmais.jqassistant.core.model.api.rule.Query
  A CYPHER query including all parameters.
• com.caucho.bam.packet.Query
  RPC call requesting information/data. The "id" field is used to match the query with the response. The target must either respond with a QueryResult or QueryError.
• com.caucho.db.sql.Query
• com.cfinkel.reports.wrappers.Query
  $Author:charles $ $Revision:9037 $ $Date:2006-05-08 13:14:49 -0400 (Mon, 08 May 2006) $ Created by IntelliJ IDEA. User: charles Date: Mar 25, 2006 Time: 6:09:54 PM To change this template use File | Settings | File Templates.
• com.chenshuo.muduo.codec.QueryProtos.Query
• com.clarkparsia.pellet.sparqldl.model.Query
  larkparsia.com>

  @author Petr Kremen
• com.compomics.mascotdatfile.util.mascot.Query
• com.couchbase.client.java.query.Query
• com.couchbase.client.protocol.views.Query
  the reduce phase as well: Query query = new Query(); query.setReduce(true); // Include the full docs: Query query = new Query(); query.setIncludeDocs(true);
• com.ctp.cdi.query.Query
• com.datastax.driver.core.Query
  An executable query.

  This represents either a {@link Statement} or a {@link BoundStatement}along with the query options (consistency level, whether to trace the query, ...).

• com.day.cq.search.Query
• com.db4o.query.Query
  handle to a node in a S.O.D.A. query graph.
  
  A node in the query graph can represent multiple classes, one class or an attribute of a class.
  
  The graph is automatically extended with attributes of added constraints (see {@link #constrain(Object)}) and upon calls to {@link #descend(java.lang.String)} that request nodes that do not yet exist.
  
  References to joined nodes in the query graph can be obtained by "walking" along the nodes of the graph with the method {@link #descend(String)}.
  
  {@link #execute()}evaluates the entire graph against all persistent objects.
  
  {@link #execute()} can be called from any {@link Query} nodeof the graph. It will return an {@link ObjectSet} filled withobjects of the class/classes that the node, it was called from, represents.
  
  Note:
  {@link Predicate Native queries} are the recommended main query interface of db4o.
• com.dotcms.repackage.net.sf.hibernate.Query
• com.dotcms.repackage.org.apache.lucene.search.Query
• com.dotmarketing.business.query.GenericQueryFactory.Query
• com.eclipsesource.tabris.passepartout.Query

  A {@link Query} is used to group {@link Condition}s and produce {@link Rule}s. It's main purpose is to provide a fluent API to enable you to create rules in one line e.g.

   PasseParout.when( condition1 ).and( condition2 ).then( instruction1, instruction2 ); 

  To create a {@link Query} you need to use the {@link PassePartout#when(Condition)} method.

  @see Condition @see Instruction @see Rule @noimplement This interface is not intended to be implemented by clients. @since 0.9
• com.enioka.jqm.api.Query
  Parameters for querying JobInstances. A null parameter (the default) is ignored in the query. To query a null String, specify "" (empty String). To query a null Integer, specify -1. It is not possible to query for null Calendar values, since it is far more efficient to query by status (the different Calendar fields are only null at certain statuses).
  See individual setters for the signification of query parameters.
  
  By default, querying only retrieves instances that have ended. See {@link Query#setQueryLiveInstances(boolean)} for details and how toretrieve living instances.
• com.esri.gpt.framework.resource.query.Query
  Query. Provides a way of obtaining a list matching metadata records from the remote repository. Typically, instance of the concrete implementation can be created through {@link QueryBuilder#newQuery(Criteria)}. @see QueryBuilder
• com.facebook.presto.sql.tree.Query
• com.flaptor.indextank.query.Query
  Wrapper for IndexTank queries, holds query metadata.
• com.gemstone.gemfire.cache.query.Query
• com.github.jmkgreen.morphia.query.Query
  @author Scott Hernandez
• com.github.seratch.scalikesolr.request.query.Query
• com.github.youtube.vitess.jdbc.vtocc.QueryService.Query
• com.google.appengine.api.datastore.Query
  {@link Query} encapsulates a request for zero or more {@link Entity} objectsout of the datastore. It supports querying on zero or more properties, querying by ancestor, and sorting. {@link Entity} objects which match thequery can be retrieved in a single list, or with an unbounded iterator.
• com.google.appengine.api.search.Query
• com.google.apphosting.api.DatastorePb.Query
• com.google.code.morphia.query.Query
• com.google.enterprise.connector.adgroups.AdDbUtil.Query
• com.google.gdata.client.Query
  The Query class is a helper class that aids in the construction of a GData query. It provides a simple API and object model that exposes query parameters. Once constructed, the query can be executed against a GData service.

  The Query class also acts as a simple base class for GData services that support custom query parameters. These services can subclass the base Query class, add APIs to represent service query parameters, and participate in the Query URI generation process. @see Service#query(Query,Class)

• com.google.gwt.visualization.client.Query
  e.com/apis/visualization/documentation/reference.html#Query"> Query API Reference
• com.google.visualization.datasource.query.Query
  google.com/apis/visualization/documentation/querylanguage.html"> query language reference . A Query can be executed by the query engine (see: {@link com.google.visualization.datasource.DataSourceHelper#applyQuery}). It can be split in 2 Query objects based on the Capabilities value (see: {@link com.google.visualization.datasource.DataSourceHelper#splitQuery}). Note on errors: Since this class handles a user generated query, all errors (of type INVALID_QUERY) should provide a descriptive error message for both the user. @author Itai R. @author Yonatan B.Y.
• com.googlecode.jmxtrans.model.Query
  Represents a JMX Query to ask for obj, attr and one or more keys. @author jon
• com.googlecode.mjorm.query.Query
• com.googlecode.objectify.Query
• com.hp.hpl.jena.graph.query.Query
  The class of graph queries, plus some machinery (which should move) for implementing them. @author hedgehog
• com.hp.hpl.jena.query
• com.hp.hpl.jena.query.Query
  The data structure for a query as presented externally. There are two ways of creating a query - use the parser to turn a string description of the query into the executable form, and the programmatic way (the parser is calling the programmatic operations driven by the quyery string). The declarative approach of passing in a string is preferred. Once a query is built, it can be passed to the QueryFactory to produce a query execution engine. @see QueryExecutionFactory @see ResultSet
• com.im.imjutil.query.Query
  Interface que defina uma consulta para sistemas de busca. Essa consulta pode ser filtrada por uma instancia de {@link Filter}, podendo ser de qualquer tipo e deve conhecer como processar os filtros passados na consulta gerada. @author Felipe Zappala
• com.impetus.kundera.query.Query
  Query Interface, clients query class must implement these method in order to support pagination. @author Kuldeep.Mishra
• com.intellij.util.Query
  @author max
• com.intersys.gds.query.Query
  Query is a base class for all ad-hoc GDS query types. It is an abstract class allowing each query subtype to provide it's own execute method. Query implements next method, which returns the next Document returned by the underlying query. It is important to state that the data is not materialized on the Java side until next is called. Query execution merely generates a set of candidate ids, which are then used in next to return the actual Documents. Total number of Documents, after the query has been executed, but before a first call to next is made, is available by calling size. Number of remaining Documents *after* at least one call to next is available by calling itemsLeft. Number of Documents a query can return can be limited by using limit Important: For now only index based queries are supported, meaning data has to have been previously indexed in order for queries to work. Should an attempt be made to run a query and no index is present an exception is thrown.
• com.javaeye.jert.domain.query.Query
  @author Quake Wang @since 2004-12-26 @version $Revision: 1.3 $
• com.liferay.portal.kernel.dao.orm.Query
• com.mobixess.jodb.soda.api.Query
  handle to a node in the query graph.
  
  A node in the query graph can represent multiple classes, one class or an attribute of a class.
  
  The graph is automatically extended with attributes of added constraints (see {@link #constrain constrain()}) and upon calls to {@link #descend(java.lang.String) descend()}that request nodes that do not yet exist.
  
  References to joined nodes in the query graph kann be obtained by "walking" along the nodes of the graph with the method {@link #descend(java.lang.String) descend()}.
  
  {@link #execute()}evaluates the entire graph against all persistent objects.
  
  {@link #execute()} can be called from any {@link Query} nodeof the graph. It will return an {@link ObjectSet} filled withobjects of the class/classes that the node, it was called from, represents.
• com.mozilla.grouperfish.model.Query
  Simple query+name wrapper.
• com.mysql.clusterj.Query
  A Query instance represents a specific query with bound parameters. The instance is created by the method {@link com.mysql.clusterj.Session#createQuery}.
• com.netfever.dbmanager.object.Query
• com.onpositive.commons.ui.tableeditor.Query
• com.ponysdk.core.query.Query
• com.projity.algorithm.Query
  This class applies an action visitor closure over an interval and select clauses
• com.proverby.api.Query
• com.psddev.dari.db.Query
• com.redspr.redquerybuilder.core.client.command.dml.Query
• com.salas.bb.domain.query.articles.Query
  Query for IArticle objects.
• com.skyline.energy.annotation.Query
• com.sosnoski.seismic.common.Query
• com.taobao.metamorphosis.tools.query.Query
  offset��ѯ���� @author pingwei
• com.taobao.tdhs.client.easy.Query
  @author 文通 @since 11-12-27 下午2:45
• com.tridion.broker.querying.Query
• com.twitterapime.search.Query
• com.youtube.vitess.vtgate.Query
  Represents a VtGate query request. Use QueryBuilder to construct instances.
• de.dfki.owlsmx.gui.data.Query
• de.fzi.herakles.commons.Query
  Interface to deal with generic reasoning queries. Queries consist of

  • Name of the reasoning task
  • Array of argument types
  • Array of argument values
  • Result type

  Query objects are immutable, i.e. only getter methods are currently provided. This keeps queries nice and consistent, such that for instance the number of argument types and argument values are equal. Implementing classes should ensure that this constraint is enforced. @author Juergen Bock
• de.iritgo.aktera.query.Query
  This component provides a general-purpose interface to Queries against persistent stores. Each implementation of the persistent service can provide it's own implementation of Query - for example, the default implementation might query databases via JDBC. The exact structure of the query is based on configuration. Each query can be refined at runtime by specifying variable criteria in one of two ways: By named criteria (using the setCriteria(String, Object) method, or by passing the Query a list of ObjectKey objects, which may be the result of the operation of a Criteria component. In either case, the Query returns a set of Maps in the specified order. @author Michael Nash, Eliot Clingman
• de.sebastianbenz.task.query.Query
  A representation of the model object 'Query'.

  The following features are supported:

  • {@link de.sebastianbenz.task.query.Query#getExpression Expression}

  @see de.sebastianbenz.task.query.QueryPackage#getQuery() @model @generated
• de.uni_mannheim.swt.codeconjurer.domain.search.Query
  @author Werner Janjic
• de.unigoettingen.sub.search.opac.Query
• edu.berkeley.cs.db.yfilterplus.queryparser.Query
• eu.balticdiversity.search.models.Query
• gov.nasa.arc.mct.test.util.gui.Query
• hendrey.orm.Query
• info.bliki.api.query.Query
  kipedia.org/w/api.php?action=query&prop=revisions&meta=siteinfo&titles=Main%20Page&rvprop=user%7Ccomment" >api.php?action=query&prop=revisions&meta=siteinfo&titles=Main%20 Page&rvprop=user|comment
• info.magnolia.cms.core.search.Query
• io.druid.query.Query
• io.fabric8.insight.metrics.model.Query
• io.prediction.examples.java.recommendations.tutorial1.Query
• it.eng.qbe.query.Query
  @author Andrea Gioia (andrea.gioia@eng.it)
• it.unimi.dsi.mg4j.query.nodes.Query
  A node of a composite representing a query.

  A query is abstractly represented by a composite made of implementations of this interface. The syntax can be different from parser to parser, but the {@linkplain it.unimi.dsi.mg4j.query.parser.QueryParser#parse(String) result of the parsing process} is an instance of this class.

  Queries support building visits: invoking {@link #accept(QueryBuilderVisitor)} ona suitable {@link it.unimi.dsi.mg4j.query.nodes.QueryBuilderVisitor} will return an objectthat has been built by the visitor.

  To this purpose, the implementation of {@link it.unimi.dsi.mg4j.query.nodes.Query#accept(QueryBuilderVisitor)}on internal nodes must gather in an array (or in an element) the results returned by the recursive calls to {@link it.unimi.dsi.mg4j.query.nodes.Query#accept(QueryBuilderVisitor)}on subnodes and pass the array (or the element) to the suitable visitPost() method of {@link it.unimi.dsi.mg4j.query.nodes.QueryBuilderVisitor}.

  Since allocating a generic array is impossible, every visitor must provide an explicit {@link it.unimi.dsi.mg4j.query.nodes.QueryBuilderVisitor#newArray(int)} method which returns an array of the correct type. @see Query @author Sebastiano Vigna

• jabber.iq.auth.Query
  3.org/2001/XMLSchema}anyType"> <sequence> <element name="username" type="{http://www.w3.org/2001/XMLSchema}string" minOccurs="0"/> <choice> <element name="password" type="{http://www.w3.org/2001/XMLSchema}string" minOccurs="0"/> <element name="digest" type="{http://www.w3.org/2001/XMLSchema}string" minOccurs="0"/> </choice> <element name="resource" type="{http://www.w3.org/2001/XMLSchema}string" minOccurs="0"/> </sequence> </restriction> </complexContent> </complexType>
• javax.jcr.query.Query
• javax.jdo.Query
  The Query interface allows applications to obtain persistent instances, values, and aggregate data from the data store. The {@link PersistenceManager} is the factory for Query instances. There may be many Query instances associated with a PersistenceManager. Multiple queries might be executed simultaneously by different threads, but the implementation might choose to execute them serially. In either case, the implementation must be thread safe.

  There are three required elements in a Query: the class of the results, the candidate collection of instances, and the filter.

  There are optional elements: parameter declarations, variable declarations, import statements, ordering and grouping specifications, result and result class, the range of results, and flags indicating whether the query result is unique and whether the query can be modified.

  The query namespace is modeled after methods in Java:

  • setClass corresponds to the class definition
  • declareParameters corresponds to formal parameters of a method
  • declareVariables corresponds to local variables of a method
  • setFilter and setOrdering correspond to the method body

  There are two namespaces in queries. Type names have their own namespace that is separate from the namespace for fields, variables and parameters.

  The method setClass introduces the name of the candidate class in the type namespace. The method declareImports introduces the names of the imported class or interface types in the type namespace. Imported type names must be unique. When used (e.g. in a parameter declaration, cast expression, etc.) a type name must be the name of the candidate class, the name of a class or interface imported by method declareImports, or denote a class or interface from the same package as the candidate class.

  The method setClass introduces the names of the candidate class fields.

  The method declareParameters introduces the names of the parameters. A name introduced by declareParameters hides the name of a candidate class field of the same name. Parameter names must be unique.

  The method declareVariables introduces the names of the variables. A name introduced by declareVariables hides the name of a candidate class field if equal. Variable names must be unique and must not conflict with parameter names.

  The result of the query by default is a list of result class instances, but might be specified via setResult. The class of the result by default is the candidate class, but might be specified via setResultClass.

  A hidden field may be accessed using the 'this' qualifier: this.fieldName.

  The Query interface provides methods which execute the query based on the parameters given. They return a single instance or a List of result class instances which the user can iterate to get results. The signature of the execute methods specifies that they return an Object which must be cast to the appropriate result by the user.

  Any parameters passed to the execute methods are used only for this execution, and are not remembered for future execution. @version 2.1

• javax.persistence.Query
  @version $Rev: 107 $ $Date: 2009-02-27 16:21:04 +0200 (Fri, 27 Feb 2009) $
• jimm.datavision.source.Query
  A data source query. @author Jim Menard, jimm@io.com
• jp.ameba.mongo.protocol.Query
  OP_QUERY リクエストメッセージ @author suguru
• jpl.Query
• loxia.annotation.Query
• mil.nga.giat.geowave.store.query.Query
  This interface fully describes a query
• mondrian.olap.Query
  rian-release/3.2/src/main/mondrian/olap/Query.java#8 $
• muduo.codec.tests.QueryProtos.Query
• mungbean.query.Query
• net.bpiwowar.mg4j.extensions.query.Query
  A query representation @author Benjamin Piwowarski
• net.didion.jwnl.dictionary.database.Query
• net.fortytwo.twitlogic.proof.Query
  two.net).
• net.hamnaberg.json.Query
• net.hydromatic.tpcds.query.Query
• net.java.ao.Query
• net.kuujo.copycat.Query
• net.nutch.searcher.Query
  A Nutch query.
• net.opentsdb.core.Query
  A query to retreive data from the TSDB.
• net.sf.domainbeans.operation.annotation.Db.query
• net.sf.hibernate.Query
• net.sf.redmine_mylyn.api.model.Query
• net.sf.redmine_mylyn.api.query.Query
• nexj.core.persistence.Query
  Query node representing a set of class instances of the same base type.
• ojb.broker.query.Query
• org.alfresco.webservice.types.Query
• org.apache.abdera.ext.opensearch.model.Query
  Open Search 1.1 Query element: defines a search query that can be performed by search clients.
  This supports all parts of the Open Search 1.1 Url specification.
• org.apache.ambari.server.api.query.Query
  Responsible for querying the back end for read requests
• org.apache.blur.thrift.generated.Query
  The Query object holds the query string (normal Lucene syntax), filters and type of scoring (used when super query is on).
• org.apache.cayenne.query.Query
  Defines minimal API of a query descriptor that is executable via Cayenne.
• org.apache.clerezza.rdf.core.sparql.query.Query

  This interface represents a SPARQL query.

  There are four types of SPARQL queries: {@link SelectQuery}, {@link ConstructQuery}, {@link DescribeQuery}, and {@link AskQuery}.

  @author hasan
• org.apache.deltaspike.data.api.Query
• org.apache.gora.query.Query
  A query to a data store to retrieve objects. Queries are constructed by the DataStore implementation via {@link DataStore#newQuery()}.
• org.apache.hadoop.gateway.util.urltemplate.Query
• org.apache.isis.applib.query.Query
  For use by repository implementations, representing the values of a query.

  The implementations of these objects are be provided by the underlying persistor/object store; consult its documentation.

  Implementations are expected to implement the {@link #getStart()} and {@link #getCount()} methods, which are used to support range / pagingthe data. Returned result sets are expected to start from index "start", and no more than "count" items are expected.

  Note: that not every object store will necessarily support this interface. In particular, the in-memory object store does not. For this, you can use the {@link Predicate} interface to similar effect, for example in{@link DomainObjectContainer#allMatches(Class,Predicate,long)}). Note that the predicate is applied within the {@link DomainObjectContainer} (ie client-side)rather than being pushed back to the object store.

• org.apache.jackrabbit.api.security.user.Query
  A query to match {@link Authorizable}s. Pass an instance of this interface to {@link UserManager#findAuthorizables(Query)}. The following query finds all users named 'Bob' which have the word 'engineer' in its description and returns them in ascending order wrt. to the name.

   Iterator result = userMgr.findAuthorizables(new Query() { public  void build(QueryBuilder builder) { builder.setCondition(builder. and(builder. property("@name", RelationOp.EQ, valueFactory.createValue("Bob")), builder. contains("@description", "engineer"))); builder.setSortOrder("@name", Direction.ASCENDING); builder.setSelector(Selector.USER); } }); 

• org.apache.jackrabbit.ocm.query.Query
  JCR Query interface @author Christophe Lombart
• org.apache.lenya.util.Query

  Utility class to analyze a query string of the form key1=value1&key2=value2&.... Access is not thread-safe.

  Invalid parts (not a valid key-value-pair) are omitted.

• org.apache.lucene.search.Query
  The abstract base class for queries.

  Instantiable subclasses are:

  • {@link TermQuery}
  • {@link MultiTermQuery}
  • {@link BooleanQuery}
  • {@link WildcardQuery}
  • {@link PhraseQuery}
  • {@link PrefixQuery}
  • {@link MultiPhraseQuery}
  • {@link FuzzyQuery}
  • {@link TermRangeQuery}
  • {@link NumericRangeQuery}
  • {@link org.apache.lucene.search.spans.SpanQuery}

  A parser for queries is contained in:

  • {@link org.apache.lucene.queryParser.QueryParser QueryParser}
• org.apache.metamodel.query.Query
  Represents a query to retrieve data by. A query is made up of six clauses, equivalent to the SQL standard:

  • the SELECT clause, which define the wanted columns of the resulting DataSet
  • the FROM clause, which define where to retrieve the data from
  • the WHERE clause, which define filters on the retrieved data
  • the GROUP BY clause, which define if the result should be grouped and aggregated according to some columns acting as categories
  • the HAVING clause, which define filters on the grouped data
  • the ORDER BY clause, which define sorting of the resulting dataset

  In addition two properties are applied to queries to limit the resulting dataset:

  • First row: The first row (aka. offset) of the result of the query.
  • Max rows: The maximum amount of rows to return when executing the query.

  Queries are executed using the DataContext.executeQuery method or can alternatively be used directly in JDBC by using the toString() method. @see DataContext
• org.apache.nutch.searcher.Query
  A Nutch query.
• org.apache.ode.ql.tree.nodes.Query
• org.apache.ojb.broker.query.Query
  represents Queries that can be used by the OJB PersistenceBroker to retrieve Objects from the underlying DB. Until now there are two implementations: 1. QueryByCriteria, represents SELECT * FROM ... WHERE ... queries 2. QueryByIdentity, uses Example objects or OIDs as templates for the db lookup there could additional implementations, e.g for user defined SQL For the Criteria API I reused code from the COBRA project, as you will see by their class comments. I removed all stuff that relies on knowlegde of the DataDictionary or MetaData layer. The Query and Criteria classes thus don't know how to build SQL statements, as in the COBRA original sources. I use the this classes as mere data-structures, that are processed by the OJB Accesslayer (SqlGenerator, JdbcAccess). This design will allow to reuse the org.apache.ojb.broker.query package in other projects without breaking any references. I hope this will be useful for someone. @author Thomas Mahler @version $Id: Query.java,v 1.17.2.3 2005/12/21 22:27:09 tomdz Exp $
• org.apache.oodt.cas.filemgr.structs.Query
  @author mattmann @author bfoster @version $Revision$

  A Query is a {@link List} of {@link QueryCriteria}.

• org.apache.openejb.jee.Query
  3.org/2001/XMLSchema}anyType"> <sequence> <element name="description" type="{http://java.sun.com/xml/ns/javaee}descriptionType" minOccurs="0"/> <element name="query-method" type="{http://java.sun.com/xml/ns/javaee}query-methodType"/> <element name="result-type-mapping" type="{http://java.sun.com/xml/ns/javaee}result-type-mappingType" minOccurs="0"/> <element name="ejb-ql" type="{http://java.sun.com/xml/ns/javaee}xsdStringType"/> </sequence> <attribute name="id" type="{http://www.w3.org/2001/XMLSchema}ID" /> </restriction> </complexContent> </complexType>
• org.apache.openjpa.kernel.Query
  OpenJPA query interface. @since 0.3.0 @author Patrick Linskey @author Abe White
• org.apache.portals.graffito.jcr.query.Query
• org.apache.stanbol.factstore.model.Query
• org.apache.tajo.master.querymaster.Query
• org.apache.torque.sql.Query
  Contains the various parts of a SQL statement (select, update or delete). Attributes exist for the sections of these statements: modifiers, columns, from clause, where clause, and order by clause. Most parts of the query are appended to buffers which only accept unique entries. @author John D. McNally @author Sam Joseph @author Martin Poeschl @author Thomas Fischer @version $Id: Query.java 1450486 2013-02-26 22:18:00Z tfischer $TODO rename to SqlStatement
• org.apache.torque.util.Query
  Used to assemble an SQL SELECT query. Attributes exist for the sections of a SELECT: modifiers, columns, from clause, where clause, and order by clause. The various parts of the query are appended to buffers which only accept unique entries. This class is used primarily by BasePeer. @author John D. McNally @author Sam Joseph @author Martin Poeschl @author Thomas Fischer @version $Id: Query.java 239636 2005-08-24 12:38:09Z henning $
• org.apache.turbine.util.db.Query
  Used to assemble an SQL SELECT query. Attributes exist for the sections of a SELECT: modifiers, columns, from clause, where clause, and order by clause. The various parts of the query are appended to buffers which only accept unique entries. This class is used primarily by BasePeer. @author John D. McNally @version $Id$
• org.atomojo.sparql.Query
  @author alex
• org.b3log.latke.repository.Query
  Query. @author Liang Ding @version 1.0.1.0, Jun 27, 2012 @see Projection @see Filter @see SortDirection
• org.compiere.model.Query
• org.conventionsframework.qualifier.Query
• org.datanucleus.store.query.Query
  Abstract implementation for all queries in DataNucleus. Implementations of JDOQL, SQL, JPQL, etc should extend this. Parameters can be implicit (defined in the query via syntaxes such as ":name", "?1") or explicit (defined via declareParameters). They can also be named or numbered. When passing a map of parameters with values, they are keyed by String (named parameters) or Integer (numbered parameters).
• org.drools.core.rule.Query
• org.drools.eclipse.core.Query
  This represents a query.
• org.drools.rule.Query
• org.eclipse.bpel.model.Query
  A representation of the model object 'Query'.

  The following features are supported:

  • {@link org.eclipse.bpel.model.Query#getValue Value}
  • {@link org.eclipse.bpel.model.Query#getQueryLanguage Query Language}

  @see org.eclipse.bpel.model.BPELPackage#getQuery() @model @generated
• org.eclipse.bpel.model.messageproperties.Query
  A representation of the model object 'Query'.

  The following features are supported:

  • {@link org.eclipse.bpel.model.messageproperties.Query#getQueryLanguage Query Language}
  • {@link org.eclipse.bpel.model.messageproperties.Query#getValue Value}

  @see org.eclipse.bpel.model.messageproperties.MessagepropertiesPackage#getQuery() @model @generated
• org.eclipse.equinox.internal.provisional.p2.query.Query
  @author Ian Ibbotson @version $Id: Query.java 5 2007-03-09 23:22:30Z gremid $ @see org.jzkit.SearchProvider.iface.BaseQuery
• org.eclipse.ocl.Query
• org.eclipse.persistence.internal.jpa.rs.metadata.model.Query
• org.ejbca.util.query.Query
  A class used to produce advanced querys from the log and user data tables. It's main function is getQueryString which returns a string which should be placed in the 'WHERE' clause of a SQL statement. @author tomselleck @version $Id: Query.java 10397 2010-11-08 14:18:57Z anatom $
• org.eobjects.metamodel.query.Query
• org.exist.atom.modules.Query
  @author R. Alexander Milowski
• org.exist.soap.Query
• org.exolab.castor.jdo.Query
  A query object. Obtained from the database and used to construct and execute a query on that database. All query operations are bound to the database transaction. Closing the database or the transaction will effectively close the query.

  If the query specified parameters these parameters must be set (bound) before executing the query. Execution of the query will result in an enumeration of all the objects found by the query. The query can be re-executed by binding new parameters and calling the {@link #execute()} method a second time. A query can bere-execute while objects are still retrieved from a previous execution. @author Assaf Arkin @version $Revision: 7121 $ $Date: 2006-03-16 16:04:24 -0700 (Thu, 16 Mar 2006) $ @see OQLQuery @see Database#getQuery

• org.exoplatform.services.database.annotation.Query
• org.exoplatform.services.organization.Query
  Created by The eXo Platform SAS . Author : Tuan Nguyen tuan08@users.sourceforge.net Date: Jun 14, 2003 Time: 1:12:22 PM
• org.exoplatform.services.resources.Query
  Created by The eXo Platform SAS . Author : Tuan Nguyen tuan08@users.sourceforge.net Date: Jun 14, 2003 Time: 1:12:22 PM
• org.firebrandocm.dao.Query
  Encapsulates information regarding a query
• org.geoserver.monitor.Query
• org.geoserver.wfs.request.Query
  Query of a GetFeature/LockFeature request. @author Justin Deoliveira, OpenGeo
• org.geotools.data.Query
  Encapsulates a request for data, typically as:

   Query query = ... myFeatureSource.getFeatures(query); 

  The query class is based on the Web Feature Server specification and offers a few interesting capabilities such as the ability to sort results and use a filter (similar to the WHERE clause in SQL).

  Additional capabilities:

  • {@linkplain #setMaxFeatures(int)} and {@linkplain #setStartIndex(Integer)} can be usedimplement 'paging' through the data source's content. This is useful if, for example, the FeatureSource has an upper limit on the number of features it can return in a single request or you are working with limited memory.
  • {@linkplain #setHandle(String)} can be used to give the query a mnemonic namewhich will appear in error reporing and logs.
  • {@linkplain #setCoordinateSystem(CoordinateReferenceSystem)} is used to to specify thecoordinate system that retrieved features will be "forced" into. This is often used to correct a feature source when the application and the data format have different ideas about the coordinate system (for example, the "axis order" issue).
  • {@linkplain #setCoordinateSystemReproject(CoordinateReferenceSystem)} is used to ask forthe retrieved features to be reproejcted.

  Vendor specific:

  • {@linkplain setHints(Hints)} is used to specify venfor specific capabilitiesprovided by a feature source implementation.

  Joins:

  The Query class supports the concepts of joins in that a query can result in a join of the feature type to other feature types in the same datastore. For example, the following would be a spatial join that selected the country that contain a particular city.

   Query query = new Query("countries"); Join join = new Join("cities", CQL.toFilter("CONTAINS(geometry, b.geometry)")); join.setAlias("b"); join.setFilter(CQL.toFilter("CITY_NAME = 'Canmore'")) query.getJoins().add(join); 

  Example:

   Filter filter = CQL.toFilter("NAME like '%land'"); Query query = new Query( "countries", filter ); FeatureCollection features = featureSource.getFeatures( query ); 

  @author Chris Holmes @source $URL$ @version $Id$
• org.gephi.filters.api.Query
  Queries are wrapping filters and are assembled in a query tree. Each query is built from a single filter instance and it's role is to basically to execute the filter. The graph that is passed to the filter depends on the fact the query belongs to a complex query tree or if the tree is a single leaf.

  The system works like this. Leaves of the query tree receives the complete graph and the subgraphs they return are passed to the parent query. Thus the root query is the last query to get the subgraphs and returns the final result. This querying system make possible to create query chains and complex scenario with various operators (AND, OR, ...).

  Queries are built by the FilterController from filter instances. @author Mathieu Bastian @see FilterController

• org.gitlab.api.http.Query
  Models the Query aspect of a URL
• org.h2.command.dml.Query
  Represents a SELECT statement (simple, or union).
• org.hibernate.Query
  An object-oriented representation of a Hibernate query. A Query instance is obtained by calling Session.createQuery(). This interface exposes some extra functionality beyond that provided by Session.iterate() and Session.find():

  • a particular page of the result set may be selected by calling setMaxResults(), setFirstResult()
  • named query parameters may be used
  • the results may be returned as an instance of ScrollableResults

  
  Named query parameters are tokens of the form :name in the query string. A value is bound to the integer parameter :foo by calling
  
  setParameter("foo", foo, Hibernate.INTEGER);
  
  for example. A name may appear multiple times in the query string.
  
  JDBC-style ? parameters are also supported. To bind a value to a JDBC-style parameter use a set method that accepts an int positional argument (numbered from zero, contrary to JDBC).
  
  You may not mix and match JDBC-style parameters and named parameters in the same query.
  
  Queries are executed by calling list(), scroll() or iterate(). A query may be re-executed by subsequent invocations. Its lifespan is, however, bounded by the lifespan of the Session that created it.
  
  Implementors are not intended to be threadsafe. @see org.hibernate.Session#createQuery(java.lang.String) @see org.hibernate.ScrollableResults @author Gavin King
• org.infinispan.query.dsl.Query
  @author anistor@redhat.com @since 6.0
• org.jboss.dna.graph.query.model.Query
• org.jmxtrans.embedded.Query
  Describe a JMX query on which metrics are collected and hold the query and export business logic ( {@link #collectMetrics()} and {@link #exportCollectedMetrics()}). @author Cyrille Le Clerc @author Jon Stevens
• org.jongo.query.Query
• org.jooq.Query
  Any query @author Lukas Eder
• org.josql.Query
• org.jrdf.query.Query
  A query to a graph. @author Tom Adams @version $Id: Query.java 3011 2009-06-03 20:31:59Z newmana $
• org.jruby.pg.internal.messages.Query
• org.jugile.util.Query
  Simple S-expression query. @author RAHKOJUK
• org.jwall.rbl.dns.Query
  This class implements the basis for all DNS queries. It provides a parsing-method for reading query objects from a byte array. @author Christian Bockermann <chris@jwall.org>
• org.kie.api.definition.rule.Query
• org.lealone.command.dml.Query
  Represents a SELECT statement (simple, or union).
• org.lilyproject.hbaseindex.Query
  Description of query.

  A query is performed by instantiating this object, adding conditions to it, and then passing it to {@link Index#performQuery}.

  A query can contain equals conditions on zero or more fields, and at most one range condition. The range condition should always be on the last used field. A query does not need to use all fields defined in the index, but you have to use them 'left to right'.

  A query can also have an optional {@link IndexFilter}to do some additional filtering on the results, based on the fields and data stored in the index.

  The structural validity of the query will be checked once the query is supplied to {@link Index#performQuery}, not while adding the individual conditions.

• org.modeshape.jcr.api.query.Query
  A specialization of the standard JCR {@link javax.jcr.query.Query} interface that adds the ModeShape-specific constant for the{@link #FULL_TEXT_SEARCH full-text search} query language.
• org.modeshape.jcr.query.model.Query
• org.mongojack.DBQuery.Query
• org.mule.common.query.Query
• org.mule.module.db.internal.domain.query.Query
  Represents an instantiation of a {@link QueryTemplate} with parameter values
• org.neo4j.cypher.commands.Query
• org.neo4j.cypherdsl.query.Query
  Model for a Cypher Query. The model is serializable and cloneable, to make it easy to save on disk or transfer over the wire. Being cloneable also helps with query builder continuation.
• org.objectweb.speedo.jmx.mbeans.Query
  @author S.Chassande-Barrioz
• org.ocpsoft.rewrite.servlet.config.Query
  A {@link Condition} that inspects the value of {@link HttpServletRewrite#getRequestQueryString()} @author Lincoln Baxter, III
• org.odbms.Query
  handle to a query graph and reference to a specific node.
  
  The query graph consists of multiple nodes, each representing a class or a member of a class. The structure can be linked in any way that the class model used allows. A Query object references a single node of this graph.
  
  The graph can be traversed with the functions descendant() and parent() which return references to other nodes of the graph. These two functions will automatically extend the graph, if necessary.
  
  execute() evaluates the entire graph against the objects stored in the data container. execute() can be called from any node of the graph and will create an ObjectSet filled with objects of the object type that the node, it was called from, represents. Objects for all descendant nodes of the caller Query object will be instantiated. Objects of parent nodes will not be visible in the ObjectSet if they are not referenced from the caller Query object.
• org.openrdf.query.Query
  A query that can be formulated in one of the supported query languages (for example SeRQL or SPARQL). It allows one to predefine bindings in the query to be able to reuse the same query with different bindings. @author Arjohn Kampman @author jeen @author James Leigh @see org.openrdf.repository.RepositoryConnection
• org.opensolaris.opengrok.egrok.query.Query
• org.pentaho.metadata.query.model.Query
• org.pentaho.reporting.engine.classic.core.designtime.datafactory.editor.model.Query
• org.qi4j.api.query.Query
  This represents a Query in an indexing system. It is created from a {@link QueryBuilder}, which decides the "where" clause in the query. Additional limitations, such as paging, ordering, and variables, can be set on a Query before it is executed by calling one of find(), iterator(), or count().

  DDD tip: typically Queries are created in the Domain Model and passed to the UI, which sets the order and paging before executing it.

• org.restsql.core.sqlresource.Query
  3.org/2001/XMLSchema>string"> </extension> </simpleContent> </complexType>
• org.saiku.query.Query
• org.simpleframework.http.Query
  The Query object is used to represent HTTP query parameters. Parameters are acquired by name and can be either a string, float, int, or boolean value. This ensures that data can be conveniently extracted in the correct type. This stores the parameters in a map of key value pairs. Each parameter can be acquired using the name of the parameter, if the parameter is named twice then all values can be acquired. @author Niall Gallagher
• org.skife.jdbi.v2.Query
  Statement prviding convenience result handling for SQL queries.
• org.springframework.data.gemfire.repository.Query
• org.springframework.data.jpa.repository.Query
• org.springframework.data.mongodb.core.query.Query
  @author Thomas Risberg @author Oliver Gierke @author Thomas Darimont @author Christoph Strobl
• org.springframework.data.neo4j.annotation.Query
• org.springframework.data.simpledb.annotation.Query
• org.springframework.data.solr.core.query.Query
  A Query that can be translated into a solr understandable Query. @author Christoph Strobl @author Rosty Kerei @author Luke Corpe @author Andrey Paramonov @author Francisco Spaeth
• org.sql2o.Query
  Represents a sql2o statement. With sql2o, all statements are instances of the Query class.
• org.structr.core.app.Query
  @author Christian Morgner @param < T>
• org.switchyard.common.version.Query
  Represents a Query to a VersionFactory. @author David Ward <dward@jboss.org> (C) 2012 Red Hat Inc.
• org.teiid.query.sql.lang.Query
  A representation of a data query. A query consists of various parts, referred to as clauses. The following list the types of clauses that a query can hold, and their purpose:

   CLAUSE          PURPOSE =========       ============================================== Select          Defines the variables data to be retrieved for From			Defines the groups to retrieve data from Criteria        Defines constraints on data retrieval ("where") GroupBy			Defines how rows being returned should be grouped Having			Defines how groups should be filtered, also a criteria OrderBy         Defines how the results should be sorted Option			Defines any extra options on the query 

• org.terrier.querying.parser.Query
  An abstract class that models a query, that consists of subqueries and query terms. The subqueries can be phrase queries, field queries, required queries, and combinations of those queries. @author Vassilis Plachouras & Craig Macdonald
• org.timedex.query.Query
• org.timepedia.chronoscope.gviz.api.client.Query
• org.topbraid.spin.model.Query
• org.vfny.geoserver.wfs.Query
  Provides an internal, generic representation of a query component to a Feature request. Note that Feature requests can contain multiple query components and that the 'version' inside the query component is different than the 'version' of the GetFeature request. @author Rob Hranac, TOPP @author Chris Holmes, TOPP @version $Id: Query.java,v 1.16 2004/02/16 21:42:10 dmzwiers Exp $
• org.wso2.carbon.cep.core.Query
• org.wso2.carbon.dataservices.core.description.query.Query
  Represents a query in a data service.
• org.xmlBlaster.engine.mime.Query
  Little container which holds a <filter> query string. For better performance you can preparse the query string and store your query object here as well (see example in GnuRegexFilter). @see org.xmlBlaster.engine.mime.regex.GnuRegexFilter
• protocol.Query
  A general representation of a query @author Yury Michurin
• ptolemy.gui.Query
  Create a query with various types of entry boxes and controls. Each type of entry box has a colon and space appended to the end of its label, to ensure uniformity. Here is one example of creating a query with a radio button:

   query = new Query(); getContentPane().add(query); String[] options = {"water", "soda", "juice", "none"}; query.addRadioButtons("radio", "Radio buttons", options, "water"); 

  @author Edward A. Lee, Manda Sutijono, Elaine Cheong @version $Id: Query.java,v 1.127 2007/12/16 07:29:47 cxh Exp $ @since Ptolemy II 0.3 @Pt.ProposedRating Yellow (eal) @Pt.AcceptedRating Red (eal)
• queries.Query
• quickdb.query.Query
  @author Diego Sarmentero
• railo.runtime.type.Query
  inteface for resultset (query) object
• rex.metadata.Query

  Title: WHEX

  Description:

  Copyright: Copyright (c) 2003

  Company:

  @author igor @version 1.0
• twitter4j.Query
  .twitter.com/Search-API-Documentation">Twitter API / Search API Documentation @see Twitter API / Search Operators @author Yusuke Yamamoto - yusuke at mac.com
• uk.ac.ebi.ricordo.rdfstore.bean.Query
• uk.ac.ucl.panda.retrieval.query.Query
  The abstract base class for queries.

  Instantiable subclasses are:

  • {@link TermQuery}
  • {@link MultiTermQuery}
  • {@link BooleanQuery}
  • {@link WildcardQuery}
  • {@link PhraseQuery}
  • {@link PrefixQuery}
  • {@link MultiPhraseQuery}
  • {@link FuzzyQuery}
  • {@link RangeQuery}
  • {@link org.apache.lucene.search.spans.SpanQuery}

  A parser for queries is contained in:

  • {@link org.apache.lucene.queryParser.QueryParser QueryParser}
• unbbayes.prs.mebn.ssbn.Query
• whitedb.holder.Query

Examples of whitedb.holder.Query