gemfire-core/src/main/java/com/gemstone/gemfire/cache/query/internal/QueryObserverAdapter.java - geode - Git at Google

 /*=========================================================================
  * Copyright Copyright (c) 2000-2014 Pivotal Software, Inc. All Rights Reserved.
  * This product is protected by U.S. and international copyright
  * and intellectual property laws. Pivotal products are covered by
  * more patents listed at http://www.pivotal.io/patents.
  * $Id: QueryObserverAdapter.java,v 1.2 2005/02/01 17:19:20 vaibhav Exp $
  *=========================================================================
  */
 package com.gemstone.gemfire.cache.query.internal;

 import java.util.*;

 import com.gemstone.gemfire.cache.query.*;

 /**
  * This class provides 'do-nothing' implementations of all of the methods of
  * interface QueryObserver. See the documentation for class QueryObserverHolder
  * for details.
  *
  * @version $Revision: 1.2 $
  * @author derekf
  */
 public class QueryObserverAdapter implements QueryObserver {

   /**
    * Called when a query begins, after any mutex locks have been acquired, but
    * before any other processing has taken place.
    */
   public void startQuery(Query query) {
   }

   /**
    * Called immediately before the query expression is evaluated. (After it was
    * compiled)
    *
    * @param expression The query Expression
    * @param context The execution context that will be used to evaluate the
    *          expression.
    */
   public void beforeQueryEvaluation(CompiledValue expression,
       ExecutionContext context) {
   }

   /**
    * Called once right before iteration of a 'select' statement begins.
    *
    * @param collection The collection being iterated over
    * @param whereClause The 'where' clause of the select statement
    */
   public void startIteration(Collection collection, CompiledValue whereClause) {
   }

   /**
    * Called once before the evaluation of an expression for a single iteration
    * of a 'select' statment. The RuntimeIterator that was passed to
    * startIteration should already be referencing the current iteration value.
    *
    * @param executer the object performing the iteration.
    * @param currentObject The current object in the iteration.
    */
   public void beforeIterationEvaluation(CompiledValue executer,
       Object currentObject) {
   }

   /**
    * Called once after the evaluation of an expression for a single iteration of
    * a 'select' statment.
    *
    * @param result The result of evaluating the where clause. Should be either a
    *          Boolean, NULL, or UNDEFINED. If evaluating the where clause threw
    *          an exception, should be NULL.
    */
   public void afterIterationEvaluation(Object result) {
   }

   /**
    * Called once right before iteration of a 'select' statement ends.
    *
    * @param results The set of results returned so far by the iteration.
    */
   public void endIteration(SelectResults results) {
   }

   /**
    * Called once right before the query subsystem has requested that the
    * indexing subsystem attempt an index lookup.
    *
    * @param index The index being used for the lookup
    * @param oper The operation being attemped on the index. AbstractIndex
    */
   public void beforeIndexLookup(Index index, int oper, Object key) {
   }

   /**
    * Called once right after the query subsystem has requested that the indexing
    * subsystem attempt an index lookup.
    *
    * @param results The results of the index lookup, or null if an exception was
    *          thrown.
    */
   public void afterIndexLookup(Collection results) {
   }

   /**
    * Called immediately after the query expression is evaluated.
    *
    * @param result The results of the evaluation, or null if an exception was
    *          thrown.
    */
   public void afterQueryEvaluation(Object result) {
   }

   /**
    * Called when a query ends, after all processing has taken place but before
    * any mutex locks have been released.
    */
   public void endQuery() {
   }

   /**
    * Asif : Called just before IndexManager executes the function
    * rerunIndexCreationQuery. After this function gets invoked, IndexManager
    * will iterate over all the indexes of the region making the data maps null &
    * re running the index creation query on the region. The method of Index
    * Manager gets executed from the clear function of the Region
    */
   public void beforeRerunningIndexCreationQuery() {
   }

   /**
    * Asif : Invoked just before the cartesian of the SelectResults obtained from
    * GroupJunctions, is done so as to expand the final resultset to the level of
    * iterators in the query. This function will get invoked from
    * AllGroupJunction during the evaluation of AND condition
    *
    * @param grpResults An array of intermediate SelectResults obtained by
    *          evaluation of GroupJunctions
    *
    */
   public void beforeCartesianOfGroupJunctionsInAnAllGroupJunctionOfType_AND(
       Collection[] grpResults) {
   };

   /**
    * Asif : Invoked just after the cartesian of the SelectResults obtained from
    * GroupJunctions, is done so as to expand the final resultset to the level of
    * iterators in the query. This function will get invoked from
    * AllGroupJunction during the evaluation of AND condition
    *
    *
    */
   public void afterCartesianOfGroupJunctionsInAnAllGroupJunctionOfType_AND() {
   };

   /**
    * Asif :Invoked just before the cartesian of the SelectResults obtained from
    * GroupJunctions, is done so as to expand the final resultset to the level of
    * Iterators for the CompositeGroupJunction. This function will get invoked
    * from CompositeGroupJunction during the evaluation of AND condition and only
    * if there exists more than one GroupJunction objects in the
    * CompositeGroupJunction
    *
    * @param grpResults An array of intermediate SelectResults obtained by
    *          evaluation of GroupJunctions
    *
    */
   public void beforeCartesianOfGroupJunctionsInCompositeGroupJunctionOfType_AND(
       Collection[] grpResults) {
   };

   /**
    * Asif :Invoked just before the cartesian of the SelectResults obtained from
    * GroupJunctions, is done so as to expand the final resultset to the level of
    * Iterators for the CompositeGroupJunction. This function will get invoked
    * from CompositeGroupJunction during the evaluation of AND condition and only
    * if there exists more than one GroupJunction objects in the
    * CompositeGroupJunction
    */
   public void afterCartesianOfGroupJunctionsInCompositeGroupJunctionOfType_AND() {
   }

   /**
    * Asif : Invoked just before doing expansion or cutdown of results obtained
    * from index usage for a filter evaluatable , non composite condition i.e for
    * a single base collection.
    *
    * @param index The index used by the filter evaluatable condition
    * @param initialResult The raw resultset obtained for the condition
    *
    */
   public void beforeCutDownAndExpansionOfSingleIndexResult(Index index,
       Collection initialResult) {
   }

   /**
    * Asif :Invoked just after doing expansion or cutdown of results obtained
    * from index usage for a filter evaluatable , non composite condition i.e for
    * a single base collection.
    *
    * @param finalResult The final conditioned resultset obtained from use of
    *          index on the condition
    *
    */
   public void afterCutDownAndExpansionOfSingleIndexResult(Collection finalResult) {
   }

   /**
    * Asif :Invoked before merging the results of the two indexes, identified for
    * evaluation of a filter evalua table equi join condition across two regions (
    * Composite Condition). During this merging the appropriate expansion &
    * cutdown of the individual index results to the final query level or
    * CompositeGroupJunction level also occurs. Also for AND conditions, the
    * cartesian with the intermediate resultset will also occur.
    *
    * @param index1 Range Index identified for one of the operand, to be used in
    *          equi join condition
    * @param index2 Range Index identified for the other operand , to be used in
    *          equi join condition
    * @param initialResult A list in which each element contains a TWO
    *          dimensional Object array containing two rows. First row contains
    *          Index Resultset obtained from 1st index & second row contains
    *          results obtained from second index. Each element of the list
    *          basically represents an equi join satisfying value ( i.e something
    *          like 1 = 1, 2 = 2 , 3 = 3 ) etc. Since multiple objects of a
    *          region can have same value , so there exits rows of Object Array
    *          for each Index.
    *
    */
   public void beforeMergeJoinOfDoubleIndexResults(Index index1, Index index2,
       Collection initialResult) {
   }

   /**
    * Asif :Invoked after merging the results of the two indexes, identified for
    * evaluation of a filter evalua table equi join condition across two regions (
    * Composite Condition). During this merging the appropriate expansion &
    * cutdown of the individual index results to the final query level or
    * CompositeGroupJunction level also occurs. Also for AND conditions, the
    * cartesian with the intermediate resultset will also occur.
    *
    * @param finalResult A SelectResults object created after expansion cutdown
    *          of two index results for a filter evaluatable CompositeCondition (
    *          which may have been cartesianed with the intermediate Results. The
    *          Results obtained may or may not be to the Top Level/
    *          CompositeGroupJunction level. The number & positions of iterators
    *          present will depend on whether it is invoked for an OR Junction or
    *          if Complete Expansion is true or not & the stage of evaluation it
    *          is in for an AND junction.
    *
    */
   public void afterMergeJoinOfDoubleIndexResults(Collection finalResult) {
   }

   /**
    * Asif :Invoked before intermediate resultset is iter evaluated to be used
    * with the usable index of the operand for filter evaluatable Composite
    * CompiledComparison for an AND type CompositeGroupJunction containing more
    * than one filter evaluatable composite condition. This invocation implies
    * that the indpendent group of iterators of one of the operands of the
    * condition is also present in the intermediate resultset which means that
    * index for that operand canot be used. Thus the intermediate Resultset is
    * iterated & for each tuple , the values set in the respective
    * RuntimeIterators. The operand without usable index is evaluated & the Index
    * on the other operand is used to get resultset for that value. Thus for each
    * tuple we query the index on other operand .
    *
    * @param usedIndex : The Index which will be used to obtain the ResultSet
    * @param unusedIndex : The Index which does not get used as the relevant
    *          iterators are present in the intermediate resultset
    *
    *
    */
   public void beforeIterJoinOfSingleIndexResults(Index usedIndex,
       Index unusedIndex) {
   }

   /**
    * Asif :Invoked after the intermediate resultset is iter evaluated to be used
    * with the usable index of the operand for filter evaluatable Composite
    * CompiledComparison for an AND type CompositeGroupJunction containing more
    * than one filter evaluatable composite condition. This invocation implies
    * that the indpendent group of iterators of one of the operands of the
    * condition is also present in the intermediate resultset which means that
    * index for that operand canot be used. Thus the intermediate Resultset is
    * iterated & for each tuple , the values set in the respective
    * RuntimeIterators. The operand without usable index is evaluated & the Index
    * on the other operand is used to get resultset for that value. Thus for each
    * tuple we query the index on other operand .
    *
    * @param finalResult : A SelectResults object created after expansion /
    *          cutdown of mergred results where one operand uses Index Results &
    *          other operand though has an Index available but cannot be used.
    *          The value of that operand is calculated by iteration of
    *          intermediate resultset for each tuple. This function gets invoked
    *          only for an AND junction. The resultset may or may not be up to
    *          the level of top level query iterators or CompositeGroupJunction
    *          iterators level.
    *
    */
   public void afterIterJoinOfSingleIndexResults(Collection finalResult) {
   }

   /**
    * @see com.gemstone.gemfire.cache.query.internal.QueryObserver#beforeIndexLookup(com.gemstone.gemfire.cache.query.Index,
    *      int, java.lang.Object, int, java.lang.Object, java.util.Set)
    */
   public void beforeIndexLookup(Index index, int lowerBoundOperator,
       Object lowerBoundKey, int upperBoundOperator, Object upperBoundKey,
       Set NotEqualKeys) {
   }

   public void beforeApplyingProjectionOnFilterEvaluatedResults(Object preProjectionApplied)
   {

   }

   public void invokedQueryUtilsIntersection(SelectResults sr1, SelectResults sr2)
   {
   }

   public void invokedQueryUtilsUnion(SelectResults sr1, SelectResults sr2)
   {
   }

   public void limitAppliedAtIndexLevel(Index index, int limit , Collection indexResult){

   }

   @Override
   public void orderByColumnsEqual() {

   }
 }
	/*=========================================================================
	* Copyright Copyright (c) 2000-2014 Pivotal Software, Inc. All Rights Reserved.
	* This product is protected by U.S. and international copyright
	* and intellectual property laws. Pivotal products are covered by
	* more patents listed at http://www.pivotal.io/patents.
	* $Id: QueryObserverAdapter.java,v 1.2 2005/02/01 17:19:20 vaibhav Exp $
	*=========================================================================
	*/
	package com.gemstone.gemfire.cache.query.internal;

	import java.util.*;

	import com.gemstone.gemfire.cache.query.*;

	/**
	* This class provides 'do-nothing' implementations of all of the methods of
	* interface QueryObserver. See the documentation for class QueryObserverHolder
	* for details.
	*
	* @version $Revision: 1.2 $
	* @author derekf
	*/
	public class QueryObserverAdapter implements QueryObserver {

	/**
	* Called when a query begins, after any mutex locks have been acquired, but
	* before any other processing has taken place.
	*/
	public void startQuery(Query query) {
	}

	/**
	* Called immediately before the query expression is evaluated. (After it was
	* compiled)
	*
	* @param expression The query Expression
	* @param context The execution context that will be used to evaluate the
	* expression.
	*/
	public void beforeQueryEvaluation(CompiledValue expression,
	ExecutionContext context) {
	}

	/**
	* Called once right before iteration of a 'select' statement begins.
	*
	* @param collection The collection being iterated over
	* @param whereClause The 'where' clause of the select statement
	*/
	public void startIteration(Collection collection, CompiledValue whereClause) {
	}

	/**
	* Called once before the evaluation of an expression for a single iteration
	* of a 'select' statment. The RuntimeIterator that was passed to
	* startIteration should already be referencing the current iteration value.
	*
	* @param executer the object performing the iteration.
	* @param currentObject The current object in the iteration.
	*/
	public void beforeIterationEvaluation(CompiledValue executer,
	Object currentObject) {
	}

	/**
	* Called once after the evaluation of an expression for a single iteration of
	* a 'select' statment.
	*
	* @param result The result of evaluating the where clause. Should be either a
	* Boolean, NULL, or UNDEFINED. If evaluating the where clause threw
	* an exception, should be NULL.
	*/
	public void afterIterationEvaluation(Object result) {
	}

	/**
	* Called once right before iteration of a 'select' statement ends.
	*
	* @param results The set of results returned so far by the iteration.
	*/
	public void endIteration(SelectResults results) {
	}

	/**
	* Called once right before the query subsystem has requested that the
	* indexing subsystem attempt an index lookup.
	*
	* @param index The index being used for the lookup
	* @param oper The operation being attemped on the index. AbstractIndex
	*/
	public void beforeIndexLookup(Index index, int oper, Object key) {
	}

	/**
	* Called once right after the query subsystem has requested that the indexing
	* subsystem attempt an index lookup.
	*
	* @param results The results of the index lookup, or null if an exception was
	* thrown.
	*/
	public void afterIndexLookup(Collection results) {
	}

	/**
	* Called immediately after the query expression is evaluated.
	*
	* @param result The results of the evaluation, or null if an exception was
	* thrown.
	*/
	public void afterQueryEvaluation(Object result) {
	}

	/**
	* Called when a query ends, after all processing has taken place but before
	* any mutex locks have been released.
	*/
	public void endQuery() {
	}

	/**
	* Asif : Called just before IndexManager executes the function
	* rerunIndexCreationQuery. After this function gets invoked, IndexManager
	* will iterate over all the indexes of the region making the data maps null &
	* re running the index creation query on the region. The method of Index
	* Manager gets executed from the clear function of the Region
	*/
	public void beforeRerunningIndexCreationQuery() {
	}

	/**
	* Asif : Invoked just before the cartesian of the SelectResults obtained from
	* GroupJunctions, is done so as to expand the final resultset to the level of
	* iterators in the query. This function will get invoked from
	* AllGroupJunction during the evaluation of AND condition
	*
	* @param grpResults An array of intermediate SelectResults obtained by
	* evaluation of GroupJunctions
	*
	*/
	public void beforeCartesianOfGroupJunctionsInAnAllGroupJunctionOfType_AND(
	Collection[] grpResults) {
	};

	/**
	* Asif : Invoked just after the cartesian of the SelectResults obtained from
	* GroupJunctions, is done so as to expand the final resultset to the level of
	* iterators in the query. This function will get invoked from
	* AllGroupJunction during the evaluation of AND condition
	*
	*
	*/
	public void afterCartesianOfGroupJunctionsInAnAllGroupJunctionOfType_AND() {
	};

	/**
	* Asif :Invoked just before the cartesian of the SelectResults obtained from
	* GroupJunctions, is done so as to expand the final resultset to the level of
	* Iterators for the CompositeGroupJunction. This function will get invoked
	* from CompositeGroupJunction during the evaluation of AND condition and only
	* if there exists more than one GroupJunction objects in the
	* CompositeGroupJunction
	*
	* @param grpResults An array of intermediate SelectResults obtained by
	* evaluation of GroupJunctions
	*
	*/
	public void beforeCartesianOfGroupJunctionsInCompositeGroupJunctionOfType_AND(
	Collection[] grpResults) {
	};

	/**
	* Asif :Invoked just before the cartesian of the SelectResults obtained from
	* GroupJunctions, is done so as to expand the final resultset to the level of
	* Iterators for the CompositeGroupJunction. This function will get invoked
	* from CompositeGroupJunction during the evaluation of AND condition and only
	* if there exists more than one GroupJunction objects in the
	* CompositeGroupJunction
	*/
	public void afterCartesianOfGroupJunctionsInCompositeGroupJunctionOfType_AND() {
	}

	/**
	* Asif : Invoked just before doing expansion or cutdown of results obtained
	* from index usage for a filter evaluatable , non composite condition i.e for
	* a single base collection.
	*
	* @param index The index used by the filter evaluatable condition
	* @param initialResult The raw resultset obtained for the condition
	*
	*/
	public void beforeCutDownAndExpansionOfSingleIndexResult(Index index,
	Collection initialResult) {
	}

	/**
	* Asif :Invoked just after doing expansion or cutdown of results obtained
	* from index usage for a filter evaluatable , non composite condition i.e for
	* a single base collection.
	*
	* @param finalResult The final conditioned resultset obtained from use of
	* index on the condition
	*
	*/
	public void afterCutDownAndExpansionOfSingleIndexResult(Collection finalResult) {
	}

	/**
	* Asif :Invoked before merging the results of the two indexes, identified for
	* evaluation of a filter evalua table equi join condition across two regions (
	* Composite Condition). During this merging the appropriate expansion &
	* cutdown of the individual index results to the final query level or
	* CompositeGroupJunction level also occurs. Also for AND conditions, the
	* cartesian with the intermediate resultset will also occur.
	*
	* @param index1 Range Index identified for one of the operand, to be used in
	* equi join condition
	* @param index2 Range Index identified for the other operand , to be used in
	* equi join condition
	* @param initialResult A list in which each element contains a TWO
	* dimensional Object array containing two rows. First row contains
	* Index Resultset obtained from 1st index & second row contains
	* results obtained from second index. Each element of the list
	* basically represents an equi join satisfying value ( i.e something
	* like 1 = 1, 2 = 2 , 3 = 3 ) etc. Since multiple objects of a
	* region can have same value , so there exits rows of Object Array
	* for each Index.
	*
	*/
	public void beforeMergeJoinOfDoubleIndexResults(Index index1, Index index2,
	Collection initialResult) {
	}

	/**
	* Asif :Invoked after merging the results of the two indexes, identified for
	* evaluation of a filter evalua table equi join condition across two regions (
	* Composite Condition). During this merging the appropriate expansion &
	* cutdown of the individual index results to the final query level or
	* CompositeGroupJunction level also occurs. Also for AND conditions, the
	* cartesian with the intermediate resultset will also occur.
	*
	* @param finalResult A SelectResults object created after expansion cutdown
	* of two index results for a filter evaluatable CompositeCondition (
	* which may have been cartesianed with the intermediate Results. The
	* Results obtained may or may not be to the Top Level/
	* CompositeGroupJunction level. The number & positions of iterators
	* present will depend on whether it is invoked for an OR Junction or
	* if Complete Expansion is true or not & the stage of evaluation it
	* is in for an AND junction.
	*
	*/
	public void afterMergeJoinOfDoubleIndexResults(Collection finalResult) {
	}

	/**
	* Asif :Invoked before intermediate resultset is iter evaluated to be used
	* with the usable index of the operand for filter evaluatable Composite
	* CompiledComparison for an AND type CompositeGroupJunction containing more
	* than one filter evaluatable composite condition. This invocation implies
	* that the indpendent group of iterators of one of the operands of the
	* condition is also present in the intermediate resultset which means that
	* index for that operand canot be used. Thus the intermediate Resultset is
	* iterated & for each tuple , the values set in the respective
	* RuntimeIterators. The operand without usable index is evaluated & the Index
	* on the other operand is used to get resultset for that value. Thus for each
	* tuple we query the index on other operand .
	*
	* @param usedIndex : The Index which will be used to obtain the ResultSet
	* @param unusedIndex : The Index which does not get used as the relevant
	* iterators are present in the intermediate resultset
	*
	*
	*/
	public void beforeIterJoinOfSingleIndexResults(Index usedIndex,
	Index unusedIndex) {
	}

	/**
	* Asif :Invoked after the intermediate resultset is iter evaluated to be used
	* with the usable index of the operand for filter evaluatable Composite
	* CompiledComparison for an AND type CompositeGroupJunction containing more
	* than one filter evaluatable composite condition. This invocation implies
	* that the indpendent group of iterators of one of the operands of the
	* condition is also present in the intermediate resultset which means that
	* index for that operand canot be used. Thus the intermediate Resultset is
	* iterated & for each tuple , the values set in the respective
	* RuntimeIterators. The operand without usable index is evaluated & the Index
	* on the other operand is used to get resultset for that value. Thus for each
	* tuple we query the index on other operand .
	*
	* @param finalResult : A SelectResults object created after expansion /
	* cutdown of mergred results where one operand uses Index Results &
	* other operand though has an Index available but cannot be used.
	* The value of that operand is calculated by iteration of
	* intermediate resultset for each tuple. This function gets invoked
	* only for an AND junction. The resultset may or may not be up to
	* the level of top level query iterators or CompositeGroupJunction
	* iterators level.
	*
	*/
	public void afterIterJoinOfSingleIndexResults(Collection finalResult) {
	}

	/**
	* @see com.gemstone.gemfire.cache.query.internal.QueryObserver#beforeIndexLookup(com.gemstone.gemfire.cache.query.Index,
	* int, java.lang.Object, int, java.lang.Object, java.util.Set)
	*/
	public void beforeIndexLookup(Index index, int lowerBoundOperator,
	Object lowerBoundKey, int upperBoundOperator, Object upperBoundKey,
	Set NotEqualKeys) {
	}

	public void beforeApplyingProjectionOnFilterEvaluatedResults(Object preProjectionApplied)
	{

	}

	public void invokedQueryUtilsIntersection(SelectResults sr1, SelectResults sr2)
	{
	}

	public void invokedQueryUtilsUnion(SelectResults sr1, SelectResults sr2)
	{
	}

	public void limitAppliedAtIndexLevel(Index index, int limit , Collection indexResult){

	}

	@Override
	public void orderByColumnsEqual() {

	}
	}