/*
 * Licensed to the Apache Software Foundation (ASF) under one or more contributor license
 * agreements. See the NOTICE file distributed with this work for additional information regarding
 * copyright ownership. The ASF licenses this file to You under the Apache License, Version 2.0 (the
 * "License"); you may not use this file except in compliance with the License. You may obtain a
 * copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software distributed under the License
 * is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express
 * or implied. See the License for the specific language governing permissions and limitations under
 * the License.
 */
package org.apache.geode.cache.query;

import java.util.*;
import org.apache.geode.cache.*;
import org.apache.geode.cache.query.internal.Undefined;

/**
 * Interface for the query service, which is used for instantiating queries, creating and destroying
 * indexes, creating CQs and operating on CQs.
 * 
 * Creating an index on an employee's age using QueryService in region "employeeRegion",
 * QueryService queryService = cache.getQueryService(); queryService.createIndex ("SampleIndex",
 * //IndexName "e.age" //indexExpression "/employeeRegion e", //regionPath );
 * 
 * The CQs work on the server regions, the client can use the CQ methods supported in this class to
 * create/operate CQs on the server. The CQ obtains the Server connection from the corresponding
 * local region on the client. The implementation of this interface is obtained from the Cache using
 * {@link Cache#getQueryService}.
 *
 * 
 * @since GemFire 4.0
 */
public interface QueryService {

  /** The undefined constant */
  public static final Object UNDEFINED = new Undefined();

  /**
   * Constructs a new <code>Query</code> object.
   * 
   * @param queryString the String that is the query program
   * @return The new <code>Query</code> object.
   * @throws QueryInvalidException if the syntax of the queryString is invalid.
   * @see Query
   */
  public Query newQuery(String queryString);

  /**
   * Create a hash index that can be used when executing equal and not equal queries. Hash index is
   * not supported with asynchronous index maintenance. Hash index is also not supported with a from
   * clause with multiple iterators. Queries on numeric types must match the indexed value. For
   * Example: For a float field the query should be specified as floatField = 1.0f
   * 
   * @param indexName the name of this index.
   * @param indexedExpression refers to the field of the region values that are referenced by the
   *        regionPath.
   * @param regionPath that resolves to region values or nested collections of region values which
   *        will correspond to the FROM clause in a query. Check following examples. The regionPath
   *        is restricted to only one expression
   * 
   *        Example: Query1: "Select * from /portfolio p where p.mktValue = 25.00" For index on
   *        mktValue field: indexExpression: "p.mktValue" regionPath: "/portfolio p"
   * 
   * @return the newly created Index
   * @throws QueryInvalidException if the argument query language strings have invalid syntax
   * @throws IndexInvalidException if the arguments do not correctly specify an index
   * @throws IndexNameConflictException if an index with this name already exists
   * @throws IndexExistsException if an index with these parameters already exists with a different
   *         name
   * @throws RegionNotFoundException if the region referred to in the fromClause doesn't exist
   * @throws UnsupportedOperationException If Index is being created on a region which does not
   *         support indexes.
   * 
   */
  public Index createHashIndex(String indexName, String indexedExpression, String regionPath)
      throws IndexInvalidException, IndexNameConflictException, IndexExistsException,
      RegionNotFoundException, UnsupportedOperationException;

  /**
   * Defines a key index that can be used when executing queries. The key index expression indicates
   * query engine to use region key as index for query evaluation. They are used to make use of the
   * implicit hash index supported with GemFire regions.
   * 
   * @param indexName the name of this index.
   * @param indexedExpression refers to the keys of the region that is referenced by the regionPath.
   *        For example, an index with indexedExpression "ID" might be used for a query with a WHERE
   *        clause of "ID > 10", In this case the ID value is evaluated using region keys.
   * @param regionPath that resolves to the region which will correspond to the FROM clause in a
   *        query. The regionPath must include exactly one region.
   * 
   *        Example: Query1: "Select * from /portfolio p where p.ID = 10" indexExpression: "p.ID"
   *        regionPath: "/portfolio p"
   * 
   * @throws RegionNotFoundException if the region referred to in the fromClause doesn't exist
   */
  public void defineKeyIndex(String indexName, String indexedExpression, String regionPath)
      throws RegionNotFoundException;

  /**
   * Defines a hash index that can be used when executing equal and not equal queries. Hash index is
   * not supported with asynchronous index maintenance. Hash index is also not supported with a from
   * clause with multiple iterators. Queries on numeric types must match the indexed value. For
   * Example: For a float field the query should be specified as floatField = 1.0f To create all the
   * defined indexes call {@link #createDefinedIndexes()}
   * 
   * @param indexName the name of this index.
   * @param indexedExpression refers to the field of the region values that are referenced by the
   *        regionPath.
   * @param regionPath that resolves to region values or nested collections of region values which
   *        will correspond to the FROM clause in a query. Check following examples. The regionPath
   *        is restricted to only one expression
   * 
   *        Example: Query1: "Select * from /portfolio p where p.mktValue = 25.00" For index on
   *        mktValue field: indexExpression: "p.mktValue" regionPath: "/portfolio p"
   * 
   * @throws RegionNotFoundException if the region referred to in the fromClause doesn't exist
   * 
   */
  public void defineHashIndex(String indexName, String indexedExpression, String regionPath)
      throws RegionNotFoundException;


  /**
   * Defines a hash index that can be used when executing equal and not equal queries. Hash index is
   * not supported with asynchronous index maintenance. Hash index is also not supported with a from
   * clause with multiple iterators. Queries on numeric types must match the indexed value. For
   * Example: For a float field the query should be specified as floatField = 1.0f To create all the
   * defined indexes call {@link #createDefinedIndexes()}
   *
   * @param indexName the name of this index.
   * @param indexedExpression refers to the field of the region values that are referenced by the
   *        regionPath.
   * @param regionPath that resolves to region values or nested collections of region values which
   *        will correspond to the FROM clause in a query. The regionPath must include exactly one
   *        region The regionPath is restricted to only one expression
   * @param imports string containing imports (in the query language syntax, each import statement
   *        separated by a semicolon), provides packages and classes used in variable typing in the
   *        Indexed and FROM expressions. The use is the same as for the FROM clause in querying.
   * 
   *        Example: Query1: "Select * from /portfolio p where p.mktValue = 25.00" For index on
   *        mktValue field: indexExpression: "p.mktValue" regionPath: "/portfolio p"
   * 
   * @throws RegionNotFoundException if the region referred to in the fromClause doesn't exist
   */
  public void defineHashIndex(String indexName, String indexedExpression, String regionPath,
      String imports) throws RegionNotFoundException;

  /**
   * Defines an index that can be used when executing queries. To create all the defined indexes
   * call {@link #createDefinedIndexes()}
   *
   * @param indexName the name of this index.
   * @param indexedExpression refers to the field of the region values that are referenced by the
   *        regionPath.
   * @param regionPath that resolves to region values or nested collections of region values which
   *        will correspond to the FROM clause in a query. Check following examples. The regionPath
   *        must include exactly one region, but may include multiple expressions as required to
   *        drill down into nested region contents.
   * 
   *        Example: Query1: "Select * from /portfolio p where p.mktValue > 25.00" For index on
   *        mktValue field: indexExpression: "p.mktValue" regionPath: "/portfolio p"
   * 
   *        Query2: "Select * from /portfolio p, p.positions.values pos where pos.secId ='VMWARE'"
   *        For index on secId field: indexExpression: "pos.secId" regionPath: "/portfolio p,
   *        p.positions.values pos"
   * @throws RegionNotFoundException if the region referred to in the fromClause doesn't exist
   * 
   */
  public void defineIndex(String indexName, String indexedExpression, String regionPath)
      throws RegionNotFoundException;

  /**
   * Defines an index that can be used when executing queries. To create all the defined indexes
   * call {@link #createDefinedIndexes()}
   * 
   * @param indexName the name of this index.
   * @param indexedExpression refers to the field of the region values that are referenced by the
   *        regionPath.
   * @param regionPath that resolves to region values or nested collections of region values which
   *        will correspond to the FROM clause in a query. The regionPath must include exactly one
   *        region, but may include multiple expressions as required to drill down into nested
   *        region contents. Check following examples.
   * @param imports string containing imports (in the query language syntax, each import statement
   *        separated by a semicolon), provides packages and classes used in variable typing in the
   *        Indexed and FROM expressions. The use is the same as for the FROM clause in querying.
   * 
   *        Example: Query1: "Select * from /portfolio p where p.mktValue > 25.00" For index on
   *        mktValue field: indexExpression: "p.mktValue" regionPath: "/portfolio p"
   * 
   *        Query2: "Select * from /portfolio p, p.positions.values pos where pos.secId ='VMWARE'"
   *        For index on secId field: indexExpression: "pos.secId" regionPath: "/portfolio p,
   *        p.positions.values pos TYPE Position" imports: "package.Position"
   * @throws QueryInvalidException if the argument query language strings have invalid syntax
   * @throws IndexInvalidException if the arguments do not correctly specify an index
   * @throws RegionNotFoundException if the region referred to in the fromClause doesn't exist
   * @throws UnsupportedOperationException If Index is being created on a region which overflows to
   *         disk
   */
  public void defineIndex(String indexName, String indexedExpression, String regionPath,
      String imports) throws RegionNotFoundException;

  /**
   * Create a hash index that can be used when executing equal and not equal queries. Hash index is
   * not supported with asynchronous index maintenance. Hash index is also not supported with a from
   * clause with multiple iterators. Queries on numeric types must match the indexed value. For
   * Example: For a float field the query should be specified as floatField = 1.0f
   *
   * @param indexName the name of this index.
   * @param indexedExpression refers to the field of the region values that are referenced by the
   *        regionPath.
   * @param regionPath that resolves to region values or nested collections of region values which
   *        will correspond to the FROM clause in a query. The regionPath must include exactly one
   *        region The regionPath is restricted to only one expression
   * @param imports string containing imports (in the query language syntax, each import statement
   *        separated by a semicolon), provides packages and classes used in variable typing in the
   *        Indexed and FROM expressions. The use is the same as for the FROM clause in querying.
   * 
   *        Example: Query1: "Select * from /portfolio p where p.mktValue = 25.00" For index on
   *        mktValue field: indexExpression: "p.mktValue" regionPath: "/portfolio p"
   * 
   * @return the newly created Index
   * @throws QueryInvalidException if the argument query language strings have invalid syntax
   * @throws IndexInvalidException if the arguments do not correctly specify an index
   * @throws IndexNameConflictException if an index with this name already exists
   * @throws IndexExistsException if an index with these parameters already exists with a different
   *         name
   * @throws RegionNotFoundException if the region referred to in the fromClause doesn't exist
   * @throws UnsupportedOperationException If Index is being created on a region which overflows to
   *         disk
   */
  public Index createHashIndex(String indexName, String indexedExpression, String regionPath,
      String imports) throws IndexInvalidException, IndexNameConflictException,
      IndexExistsException, RegionNotFoundException, UnsupportedOperationException;

  /**
   * 
   * @deprecated As of 6.6.2, use {@link #createIndex(String, String, String)} and
   *             {@link #createKeyIndex(String, String, String)} instead.
   * 
   *             Create an index that can be used when executing queries.
   * 
   * @param indexName the name of this index, used for statistics collection and to identify this
   *        index for later access
   * @param indexType the type of index. The indexType must be either IndexType.FUNCTIONAL or
   *        IndexType.PRIMARY_KEY.
   * @param indexedExpression refers to the elements of the collection (or collection of structs)
   *        that are referenced in the fromClause. This expression is used to optimize the
   *        comparison of the same path found in a query's WHERE clause when used to compare against
   *        a constant expression. For example, an index with indexedExpression "mktValue" might be
   *        used for a query with a WHERE clause of "mktValue > 25.00". The exact use and
   *        specification of the indexedExpression varies depending on the indexType. Query
   *        parameters and region paths are not allowed in the indexedExpression (e.g. $1).
   * @param fromClause expression, that resolves to a collection or list of collections which will
   *        correspond to the FROM clause or part of a FROM clause in a SELECT statement. The FROM
   *        clause must include exactly one region, but may include multiple FROM expressions as
   *        required to drill down into nested region contents. The collections that the FROM
   *        expressions evaluate to must be dependent on one and only one entry in the referenced
   *        region (otherwise the index could not be maintained on single entry updates). References
   *        to query parameters are not allowed. For primary key indexes, the fromClause must be
   *        just one collection which must be a region path only.
   * @return the newly created Index
   * @throws QueryInvalidException if the argument query language strings have invalid syntax
   * @throws IndexInvalidException if the arguments do not correctly specify an index
   * @throws IndexNameConflictException if an index with this name already exists
   * @throws IndexExistsException if an index with these parameters already exists with a different
   *         name
   * @throws RegionNotFoundException if the region referred to in the fromClause doesn't exist
   * @throws UnsupportedOperationException If Index is being created on a region which overflows to
   *         disk
   * 
   */
  @Deprecated
  public Index createIndex(String indexName, IndexType indexType, String indexedExpression,
      String fromClause) throws IndexInvalidException, IndexNameConflictException,
      IndexExistsException, RegionNotFoundException, UnsupportedOperationException;

  /**
   * @deprecated As of 6.6.2, use {@link #createIndex(String, String, String, String)} and
   *             {@link #createKeyIndex(String, String, String)} instead.
   * 
   *             Create an index that can be used when executing queries.
   * 
   * @param indexName the name of this index, used for statistics collection and to identify this
   *        index for later access
   * @param indexType the type of index. The indexType must be either IndexType.FUNCTIONAL or
   *        IndexType.PRIMARY_KEY.
   * @param indexedExpression refers to the elements of the collection (or collection of structs)
   *        that are referenced in the fromClause. This expression is used to optimize the
   *        comparison of the same path found in a query's WHERE clause when used to compare against
   *        a constant expression. For example, an index with indexedExpression "mktValue" might be
   *        used for a query with a WHERE clause of "mktValue > 25.00". The exact use and
   *        specification of the indexedExpression varies depending on the indexType. Query
   *        parameters and region paths are not allowed in the indexedExpression (e.g. $1).
   * @param fromClause expression, that resolves to a collection or list of collections which will
   *        correspond to the FROM clause or part of a FROM clause in a SELECT statement. The FROM
   *        clause must include exactly one region, but may include multiple FROM expressions as
   *        required to drill down into nested region contents. The collections that the FROM
   *        expressions evaluate to must be dependent on one and only one entry in the referenced
   *        region (otherwise the index could not be maintained on single entry updates). References
   *        to query parameters are not allowed. For primary key indexes, the fromClause must be
   *        just one collection which must be a region path only.
   * @param imports string containing imports (in the query language syntax, each import statement
   *        separated by a semicolon), provides packages and classes used in variable typing in the
   *        Indexed and FROM expressions. The use is the same as for the FROM clause in querying.
   * @return the newly created Index
   * @throws QueryInvalidException if the argument query language strings have invalid syntax
   * @throws IndexInvalidException if the arguments do not correctly specify an index
   * @throws IndexNameConflictException if an index with this name already exists
   * @throws IndexExistsException if an index with these parameters already exists with a different
   *         name
   * @throws RegionNotFoundException if the region referred to in the fromClause doesn't exist
   * @throws UnsupportedOperationException If Index is being created on a region which overflows to
   *         disk
   */
  @Deprecated
  public Index createIndex(String indexName, IndexType indexType, String indexedExpression,
      String fromClause, String imports) throws IndexInvalidException, IndexNameConflictException,
      IndexExistsException, RegionNotFoundException, UnsupportedOperationException;

  /**
   * Create an index that can be used when executing queries.
   * 
   * @param indexName the name of this index.
   * @param indexedExpression refers to the field of the region values that are referenced by the
   *        regionPath.
   * @param regionPath that resolves to region values or nested collections of region values which
   *        will correspond to the FROM clause in a query. Check following examples. The regionPath
   *        must include exactly one region, but may include multiple expressions as required to
   *        drill down into nested region contents.
   * 
   *        Example: Query1: "Select * from /portfolio p where p.mktValue > 25.00" For index on
   *        mktValue field: indexExpression: "p.mktValue" regionPath: "/portfolio p"
   * 
   *        Query2: "Select * from /portfolio p, p.positions.values pos where pos.secId ='VMWARE'"
   *        For index on secId field: indexExpression: "pos.secId" regionPath: "/portfolio p,
   *        p.positions.values pos"
   * @return the newly created Index
   * @throws QueryInvalidException if the argument query language strings have invalid syntax
   * @throws IndexInvalidException if the arguments do not correctly specify an index
   * @throws IndexNameConflictException if an index with this name already exists
   * @throws IndexExistsException if an index with these parameters already exists with a different
   *         name
   * @throws RegionNotFoundException if the region referred to in the fromClause doesn't exist
   * @throws UnsupportedOperationException If Index is being created on a region which does not
   *         support indexes.
   * 
   */
  public Index createIndex(String indexName, String indexedExpression, String regionPath)
      throws IndexInvalidException, IndexNameConflictException, IndexExistsException,
      RegionNotFoundException, UnsupportedOperationException;

  /**
   * Create an index that can be used when executing queries.
   * 
   * @param indexName the name of this index.
   * @param indexedExpression refers to the field of the region values that are referenced by the
   *        regionPath.
   * @param regionPath that resolves to region values or nested collections of region values which
   *        will correspond to the FROM clause in a query. The regionPath must include exactly one
   *        region, but may include multiple expressions as required to drill down into nested
   *        region contents. Check following examples.
   * @param imports string containing imports (in the query language syntax, each import statement
   *        separated by a semicolon), provides packages and classes used in variable typing in the
   *        Indexed and FROM expressions. The use is the same as for the FROM clause in querying.
   * 
   *        Example: Query1: "Select * from /portfolio p where p.mktValue > 25.00" For index on
   *        mktValue field: indexExpression: "p.mktValue" regionPath: "/portfolio p"
   * 
   *        Query2: "Select * from /portfolio p, p.positions.values pos where pos.secId ='VMWARE'"
   *        For index on secId field: indexExpression: "pos.secId" regionPath: "/portfolio p,
   *        p.positions.values pos TYPE Position" imports: "package.Position"
   * @return the newly created Index
   * @throws QueryInvalidException if the argument query language strings have invalid syntax
   * @throws IndexInvalidException if the arguments do not correctly specify an index
   * @throws IndexNameConflictException if an index with this name already exists
   * @throws IndexExistsException if an index with these parameters already exists with a different
   *         name
   * @throws RegionNotFoundException if the region referred to in the fromClause doesn't exist
   * @throws UnsupportedOperationException If Index is being created on a region which overflows to
   *         disk
   */
  public Index createIndex(String indexName, String indexedExpression, String regionPath,
      String imports) throws IndexInvalidException, IndexNameConflictException,
      IndexExistsException, RegionNotFoundException, UnsupportedOperationException;

  /**
   * Create a key index that can be used when executing queries. The key index expression indicates
   * query engine to use region key as index for query evaluation. They are used to make use of the
   * implicit hash index supported with GemFire regions.
   * 
   * @param indexName the name of this index.
   * @param indexedExpression refers to the keys of the region that is referenced by the regionPath.
   *        For example, an index with indexedExpression "ID" might be used for a query with a WHERE
   *        clause of "ID > 10", In this case the ID value is evaluated using region keys.
   * @param regionPath that resolves to the region which will correspond to the FROM clause in a
   *        query. The regionPath must include exactly one region.
   * 
   *        Example: Query1: "Select * from /portfolio p where p.ID = 10" indexExpression: "p.ID"
   *        regionPath: "/portfolio p"
   * 
   * @return the newly created Index
   * @throws QueryInvalidException if the argument query language strings have invalid syntax
   * @throws IndexInvalidException if the arguments do not correctly specify an index
   * @throws IndexNameConflictException if an index with this name already exists
   * @throws IndexExistsException if an index with these parameters already exists with a different
   *         name
   * @throws RegionNotFoundException if the region referred to in the fromClause doesn't exist
   * @throws UnsupportedOperationException If Index is being created on a region which overflows to
   *         disk
   */
  public Index createKeyIndex(String indexName, String indexedExpression, String regionPath)
      throws IndexInvalidException, IndexNameConflictException, IndexExistsException,
      RegionNotFoundException, UnsupportedOperationException;


  /**
   * Creates all the indexes that were defined using {@link #defineIndex(String, String, String)}
   * 
   * @throws MultiIndexCreationException which consists a map of failed indexNames and the
   *         Exceptions.
   */
  public List<Index> createDefinedIndexes() throws MultiIndexCreationException;

  /**
   * Clears all the indexes that were defined using {@link #defineIndex(String, String, String)}
   */
  public boolean clearDefinedIndexes();

  /**
   * Get the Index from the specified Region with the specified name.
   * 
   * @param region the Region for the requested index
   * @return the index of the region with this name, or null if there isn't one
   */
  public Index getIndex(Region<?, ?> region, String indexName);

  /**
   * Get a collection of all the indexes in the Cache.
   * 
   * @return the collection of all indexes in this Cache
   */
  public Collection<Index> getIndexes();

  /**
   * Get a collection of all the indexes on the specified Region
   * 
   * @param region the region for the requested indexes
   * @return the collection of indexes on the specified region
   */
  public Collection<Index> getIndexes(Region<?, ?> region);

  /**
   * 
   * @deprecated As of 6.6.2, use {@link #getIndexes(Region)} only.
   * 
   *             Get a collection of all the indexes on the specified Region of the specified index
   *             type.
   * 
   * @param region the region for the requested indexes
   * @param indexType the type of indexes to get. Currently must be Indexable.FUNCTIONAL
   * @return the collection of indexes for the specified region and type
   */
  @Deprecated
  public Collection<Index> getIndexes(Region<?, ?> region, IndexType indexType);

  /**
   * Remove the specified index.
   * 
   * @param index the Index to remove
   */
  public void removeIndex(Index index);

  /**
   * Remove all the indexes from this cache.
   */
  public void removeIndexes();

  /**
   * Remove all the indexes on the specified Region
   * 
   * @param region the Region to remove all indexes from
   */
  public void removeIndexes(Region<?, ?> region);


  // CQ Service related APIs.

  /**
   * Constructs a new continuous query, represented by an instance of CqQuery. The CqQuery is not
   * executed until the execute method is invoked on the CqQuery.
   * 
   * @since GemFire 5.5
   * @param queryString the OQL query
   * @param cqAttr the CqAttributes
   * @return the newly created CqQuery object
   * @throws IllegalArgumentException if queryString or cqAttr is null.
   * @throws IllegalStateException if this method is called from a cache server.
   * @throws QueryInvalidException if there is a syntax error in the query.
   * @throws CqException if failed to create CQ. E.g.: Query string should refer to only one region.
   *         Joins are not supported. The query must be a SELECT statement. DISTINCT queries are not
   *         supported. Projections are not supported. Only one iterator in the FROM clause is
   *         supported, and it must be a region path. Bind parameters in the query are not yet
   *         supported.
   */
  public CqQuery newCq(String queryString, CqAttributes cqAttr)
      throws QueryInvalidException, CqException;

  /**
   * Constructs a new continuous query, represented by an instance of CqQuery. The CqQuery is not
   * executed until the execute method is invoked on the CqQuery.
   *
   * @since GemFire 5.5
   * @param queryString the OQL query
   * @param cqAttr the CqAttributes
   * @param isDurable true if the CQ is durable
   * @return the newly created CqQuery object
   * @throws IllegalArgumentException if queryString or cqAttr is null.
   * @throws IllegalStateException if this method is called from a cache server.
   * @throws QueryInvalidException if there is a syntax error in the query.
   * @throws CqException if failed to create CQ. E.g.: Query string should refer to only one region.
   *         Joins are not supported. The query must be a SELECT statement. DISTINCT queries are not
   *         supported. Projections are not supported. Only one iterator in the FROM clause is
   *         supported, and it must be a region path. Bind parameters in the query are not yet
   *         supported.
   */
  public CqQuery newCq(String queryString, CqAttributes cqAttr, boolean isDurable)
      throws QueryInvalidException, CqException;

  /**
   * Constructs a new named continuous query, represented by an instance of CqQuery. The CqQuery is
   * not executed until the execute method is invoked on the CqQuery. The name of the query will be
   * used to identify this query in statistics archival.
   *
   * @since GemFire 5.5
   * @param name the String name for this query
   * @param queryString the OQL query
   * @param cqAttr the CqAttributes
   * @return the newly created CqQuery object
   * @throws CqExistsException if a CQ by this name already exists on this client
   * @throws IllegalArgumentException if queryString or cqAttr is null.
   * @throws IllegalStateException if this method is called from a cache server.
   * @throws QueryInvalidException if there is a syntax error in the query.
   * @throws CqException if failed to create cq. E.g.: Query string should refer to only one region.
   *         Joins are not supported. The query must be a SELECT statement. DISTINCT queries are not
   *         supported. Projections are not supported. Only one iterator in the FROM clause is
   *         supported, and it must be a region path. Bind parameters in the query are not yet
   *         supported.
   *
   */
  public CqQuery newCq(String name, String queryString, CqAttributes cqAttr)
      throws QueryInvalidException, CqExistsException, CqException;


  /**
   * Constructs a new named continuous query, represented by an instance of CqQuery. The CqQuery is
   * not executed until the execute method is invoked on the CqQuery. The name of the query will be
   * used to identify this query in statistics archival.
   *
   * @since GemFire 5.5
   * @param name the String name for this query
   * @param queryString the OQL query
   * @param cqAttr the CqAttributes
   * @param isDurable true if the CQ is durable
   * @return the newly created CqQuery object
   * @throws CqExistsException if a CQ by this name already exists on this client
   * @throws IllegalArgumentException if queryString or cqAttr is null.
   * @throws IllegalStateException if this method is called from a cache server.
   * @throws QueryInvalidException if there is a syntax error in the query.
   * @throws CqException if failed to create cq. E.g.: Query string should refer to only one region.
   *         Joins are not supported. The query must be a SELECT statement. DISTINCT queries are not
   *         supported. Projections are not supported. Only one iterator in the FROM clause is
   *         supported, and it must be a region path. Bind parameters in the query are not yet
   *         supported.
   *
   */
  public CqQuery newCq(String name, String queryString, CqAttributes cqAttr, boolean isDurable)
      throws QueryInvalidException, CqExistsException, CqException;

  /**
   * Unregister all Continuous Queries. All artifacts and resources associated with the CQs are
   * released. Any attempt to access closed CqQuery objects will result in the CqClosedException
   * being thrown to the caller.
   * 
   * @since GemFire 5.5
   */
  public void closeCqs();

  /**
   * Retrieve all registered Continuous Queries. This is a collection of CqQuery objects.
   *
   * @since GemFire 5.5
   * @return CqQuery[] list of registered CQs, null if there are no CQs.
   */
  public CqQuery[] getCqs();

  /**
   * Retrieves all the registered Continuous Queries for a given region. This is a collection of
   * CqQuery objects.
   * 
   * @since GemFire 5.5
   * @return CqQuery[] list of registered CQs on the specified region, null if there are no CQs.
   * @exception CqException if the region does not exist.
   */
  public CqQuery[] getCqs(String regionName) throws CqException;

  /**
   * Retrieves the Continuous Query specified by the name.
   * 
   * @since GemFire 5.5
   * @param cqName - String, name of the CQ
   * @return CqQuery object, null if no CqQuery object is found.
   */
  public CqQuery getCq(String cqName);

  /**
   * Starts execution of all the registered continuous queries for this client. This is
   * complementary to stopCqs.
   * 
   * @see QueryService#stopCqs()
   * 
   * @since GemFire 5.5
   * @throws CqException if failure to execute CQ.
   */
  public void executeCqs() throws CqException;

  /**
   * Stops execution of all the continuous queries for this client to become inactive. This is
   * useful when client needs to control the incoming CQ messages during bulk region operations.
   * 
   * @see QueryService#executeCqs()
   * 
   * @since GemFire 5.5
   * @throws CqException if failure to execute CQ.
   */
  public void stopCqs() throws CqException;

  /**
   * Starts execution of all the continuous queries registered on the specified region for this
   * client. This is complementary method to stopCQs().
   * 
   * @see QueryService#stopCqs()
   * 
   * @since GemFire 5.5
   * @throws CqException if failure to stop CQs.
   */
  public void executeCqs(String regionName) throws CqException;

  /**
   * Stops execution of all the continuous queries registered on the specified region for this
   * client. This is useful when client needs to control the incoming CQ messages during bulk region
   * operations.
   * 
   * @see QueryService#executeCqs()
   * 
   * @since GemFire 5.5
   * @throws CqException if failure to execute CQs.
   */
  public void stopCqs(String regionName) throws CqException;

  /**
   * Retrieves all the durable CQs registered by the client calling this method.
   *
   * @since GemFire 7.0
   * @return List of names of registered durable CQs, empty list if no durable cqs.
   */
  public List<String> getAllDurableCqsFromServer() throws CqException;

  /**
   * Returns CqServiceStatistics object, which provides helper methods to get CQ service related
   * statistics for this client. Specifically the following aggregate information on the client's
   * CQs is collected: Number of CQs created (cumulative) Number of CQs active currently Number of
   * CQs stopped or suspended currently Number of CQs closed (cumulative) Number of CQs active on a
   * specified region currently
   * 
   * @see CqServiceStatistics
   * 
   * @since GemFire 5.5
   * @return CqServiceStatistics
   * 
   */
  public CqServiceStatistics getCqStatistics();

}
