/**********************************************************************
// @@@ START COPYRIGHT @@@
//
// 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.
//
// @@@ END COPYRIGHT @@@
**********************************************************************/
// code that is not compiled, but for some reason is reported
// just excluding the entire file
#include "AppliedStatMan.h"
#include "Analyzer.h"

void QueryAnalysis::initializeQueryGraphs()
{
  //FILE * f = stdout;

  //fprintf(f,"### InitializingQueryGraphs \n");

  //This method should be called after ASM initialization
  AppliedStatMan * appStatMan = ASM();

  if (appStatMan == NULL)
    return;

  ARRAY(JBB *) allJBBs = getJBBs();
  CollIndex remainingJBBs = allJBBs.entries();
  for (CollIndex i = 0; remainingJBBs > 0; i++)
  {
    if (allJBBs.used(i))
    {
      (allJBBs[i])->initializeQueryGraph();
    remainingJBBs--;
    }
  }
}

void JBB::initializeQueryGraph()
{
  //FILE * f = stdout;

  //fprintf(f,"### Enter QueryGraph\n");
  //iterate over each JBBC in the JBB

#ifndef NDEBUG
  if(0){
    debugQueryGraph();
  }
#endif

  JBBSubset allJBBCs = getMainJBBSubset();
  CANodeIdSet JBBCs = allJBBCs.getJBBCs();

  for(CANodeId JBBCId = JBBCs.init(); JBBCs.next(JBBCId); JBBCs.advance(JBBCId))
  {
    JBBC * currentJBBC = (JBBCId.getNodeAnalysis())->getJBBC();
    //initialize the Query Graph aspect of currentJBBC
    currentJBBC->initializeQueryGraphNode();
  }

  //enumerate reduction paths
  enumerateReductionPaths();
}
//JBB::initializeQueryGraph()

void JBB::enumerateReductionPaths()
{
  //FILE * f = stdout;

  //get list of reducers
  ReducerStat * reducers = getReducerStat();

  //get a list of local leaf reducers
  CANodeIdSet localLeafReducers = reducers->getLocalLeafReducers();
    //fprintf(f,"### Local Leaf reducers\n");
    //localLeafReducers.print();

  //iterate over all local leaf reducers
  CANodeId JBBCId;
  for(JBBCId = localLeafReducers.init();
      localLeafReducers.next(JBBCId);
      localLeafReducers.advance(JBBCId))
  {
    JBBC * currentJBBC = (JBBCId.getNodeAnalysis())->getJBBC();
    //start linear reduction paths from currentJBBC
    currentJBBC->startReductionPaths();
  }

  //get a list of local non leaf reducers
  CANodeIdSet localNonLeafReducers = reducers->getLocalNonLeafReducers();
    //fprintf(f,"### Local Non Leaf reducers\n");
    //localNonLeafReducers.print();

  //iterate over all local non leaf reducers
  for(JBBCId = localNonLeafReducers.init();
      localNonLeafReducers.next(JBBCId);
      localNonLeafReducers.advance(JBBCId))
  {
    JBBC * currentJBBC = (JBBCId.getNodeAnalysis())->getJBBC();
    //start linear reduction paths from currentJBBC
    currentJBBC->startReductionPaths();
  }


  //get a list of join leaf reducers
  CANodeIdSet  joinLeafReducers = reducers->getJoinLeafReducers();
    //fprintf(f,"### Join Leaf reducers\n");
    //joinLeafReducers.print();

  //iterate over all join leaf reducers
  //put this back in after ASM starts providing join reducers
  for(JBBCId = joinLeafReducers.init();
      joinLeafReducers.next(JBBCId);
      joinLeafReducers.advance(JBBCId))
  {
    JBBC * currentJBBC = (JBBCId.getNodeAnalysis())->getJBBC();
    //start linear reduction paths from currentJBBC
    currentJBBC->startReductionPaths();
  }


  //get a list of join non leaf reducers
  CANodeIdSet joinNonLeafReducers = reducers->getJoinNonLeafReducers();
    //fprintf(f,"### Join Leaf reducers\n");
    //joinNonLeafReducers.print();

  //iterate over all join non leaf reducers
  for(JBBCId = joinNonLeafReducers.init();
      joinNonLeafReducers.next(JBBCId);
      joinNonLeafReducers.advance(JBBCId))
  {
    JBBC * currentJBBC = (JBBCId.getNodeAnalysis())->getJBBC();
    //start linear reduction paths from currentJBBC
    currentJBBC->startReductionPaths();
  }

  //iterate over each JBBC in the JBB
  JBBSubset allJBBCs = getMainJBBSubset();
    CANodeIdSet JBBCs = allJBBCs.getJBBCs();

  for(JBBCId = JBBCs.init(); JBBCs.next(JBBCId); JBBCs.advance(JBBCId))
  {
    JBBC * currentJBBC = (JBBCId.getNodeAnalysis())->getJBBC();
    //initialize the Query Graph aspect of currentJBBC
    currentJBBC->mergeReductionPaths();
  }

}
//JBB::enumerateReductionPaths()

void JBB::displayReductionPaths()
{
  FILE * f = stdout;

  fprintf(f,"All reduction paths in this JBB\n");

  JBBSubset allJBBCs = getMainJBBSubset();
  CANodeIdSet JBBCs = allJBBCs.getJBBCs();

  for(CANodeId JBBCId = JBBCs.init(); JBBCs.next(JBBCId); JBBCs.advance(JBBCId))
  {
    JBBC * currentJBBC = (JBBCId.getNodeAnalysis())->getJBBC();
    //initialize the Query Graph aspect of currentJBBC
    currentJBBC->displayQueryGraphNodeText();
  }
}

#ifndef NDEBUG
void JBB::debugQueryGraph(){
  //get integer representing the reduction path to be built
  Lng32 reductionPathString=0;

  CANodeIdSet currentReductionPath;
  EstLogPropSharedPtr currentReductionPathProps;

  //add the first JBBC to the reduction path, before extending the
  //reduction path by doing a join with the second JBBC.
  if(reductionPathString > 0){
    //get the first JBBC
    Int32 firstJBBCNodeId = reductionPathString % 100;
    //update reductionPathString now that we have extracted the last two digits
    reductionPathString = reductionPathString / 100;
    //get the first JBBC and insert into the empty reduction path
    CANodeId firstJBBC(firstJBBCNodeId);
    currentReductionPath.insert(firstJBBC);
    currentReductionPathProps = (QueryAnalysis::ASM())->\
      getStatsForCANodeIdSet(currentReductionPath);
  }

  //loop over the reductionPathString joining in a JBBC at a time
  //each JBBC is represent by a two digit number that gives its id
  while (reductionPathString > 0){
    //extend currentReductionPath by joining to next JBBC in the
    //reductionPathString

    //first get the CANodeId of the JBBC to join to the currentReductionPath
    Int32 jBBCToJoinId = reductionPathString % 100;
    //update reductionPathString now that we have extracted the last two digits
    reductionPathString = reductionPathString / 100;
    CANodeId jBBCToJoin(jBBCToJoinId);
    CANodeIdSet jBBCToJoinSet(jBBCToJoin);

    //extend the reduction path by doing a join of the current reduction path
    //with jBBCToJoin
    EstLogPropSharedPtr joinEstLogProp = (QueryAnalysis::ASM())->\
      joinJBBChildren(currentReductionPath, jBBCToJoinSet);

    //insert join JBBC into current reduction path
    currentReductionPath.insert(jBBCToJoin);

    //update currentReductionPath
    currentReductionPathProps = (QueryAnalysis::ASM())->\
      getStatsForCANodeIdSet(currentReductionPath);
  }

}
#endif

const NAString JBBC::getQueryGraphNodeText() const{
  NAString result("QueryGraph Info for node "+ getId().getText()+"\n");

  //iterator over all the reduction paths at this node.
  CollIndex i;
  for(i=0; i < reductionPaths_->entries();i++)
  {
    result += ("Reduction Path " + istring(i) + "\n");

    //print the reduction path
    result += (*reductionPaths_)[i]->getText();

    Int32 cardinality = ((*cardinalityOfReductionPaths_)[i]).getValue();
    result += ("cardinality: " + istring(cardinality)+"\n");
  }

  return result;
}

void JBBC::printQueryGraphNodeText (FILE *f,
  const char * prefix,
  const char * suffix) const
{
#ifndef NDEBUG
  fprintf (f, getQueryGraphNodeText());
#endif
};

void JBBC::displayQueryGraphNodeText() const
{
  printQueryGraphNodeText();
};

void JBBC::initializeQueryGraphNode()
{
  //Allocate the list used to store reduction paths
  //use whatever heap the JBBC is on
  reductionPaths_ = new (heap_) NAList<CANodeIdSet *>(heap_);

  cardinalityOfReductionPaths_ =  new (heap_) NAList<CostScalar>(heap_);
  //create a list of QueryGraphConnections where each connection represents
  //a incoming connection
  CANodeIdSet connectedJBBCs = getJoinedJBBCs();

  //Allocate the list that will store all incoming connections
  Int32 numIncomingConnections = connectedJBBCs.entries();
  incomingConnections_ = new (heap_) NAList<QueryGraphConnection *>(heap_,numIncomingConnections);

  //create a QueryGraphConnection object representing a connection from
  //each of the connected JBBCs to 'this' JBBC.
  for(CANodeId JBBCId = connectedJBBCs.init();
      connectedJBBCs.next(JBBCId);
      connectedJBBCs.advance(JBBCId))
  {
    //create a QueryGraphConnection Object representing a connection
    //from JBBC with id JBBCId to 'this' JBBC
    QueryGraphConnection * newConnection =
      new (heap_) QueryGraphConnection(getId(), JBBCId);
    incomingConnections_->insert(newConnection);
  }

  //set the after local predicate cardinality of this node
  CANodeIdSet localNodeId(this->getId());
  afterLocalPredCardinality_ = ((QueryAnalysis::ASM())->getStatsForCANodeIdSet(localNodeId))->getResultCardinality();
}
//JBBC::initializeQueryGraphNode()


void JBBC::extendReductionPath(CANodeIdSet currentReductionPath,
                               CostScalar cardinalityOfCurrentReductionPath,
                               CANodeId from)
{
  //Node Id set representing this JBBC
  //CANodeIdSet thisJBBC(getId());

  //variable to get logical properties for the current reduction path
  //EstLogPropSharedPtr logPropsOfCurrentReductionPath;

  //check if we are not starting a reduction path i.e. we are extending a
  //reduction path that has already been started. A reduction path is started
  //by calling startReductionPaths(), which passes NULL_CA_ID in parameter
  //'from'
  if(from != NULL_CA_ID)
  {
    //store the reduction path passed in
    CANodeIdSet * reductionPathToStore = new (collHeap()) CANodeIdSet(currentReductionPath);
    reductionPaths_->insert(reductionPathToStore);

    //find the connection from which this reduction path is coming in
    CollIndex i;
    for(i = 0; i < incomingConnections_->entries(); i++)
    {
      if((*incomingConnections_)[i]->getConnectedJBBC() == from)
      {
        //add the latest connection to the QueryGraphConnection Object
        (*incomingConnections_)[i]->addIncomingReductionPath(reductionPathToStore,
                                    cardinalityOfCurrentReductionPath);
         break;
      }
    }

    //insert cardinality into array of cardinalities this will be used by
    //getReducingJoinSet to get cardinalities without the need to lookup the
    //cache.
    cardinalityOfReductionPaths_->insert(cardinalityOfCurrentReductionPath);
  }

  //add this node's JBBCId to the reduction path, since it has to be extended.
  //This is the reduction path that will be joined to the connected JBBCs (i.e.
  //extended).
  currentReductionPath.insert(getId());


  //try to extend the reduction path to each connected JBBC except the
  //JBBC where  currentReductionPath came from
  //get all the connected JBBCs
  CANodeIdSet connectedJBBCs = getJoinedJBBCs();

  //iterate over all the connected JBBCs, trying to extend the reduction path
  //to each connected JBBC except the one from which currentReductionPath
  //came from
  CANodeId JBBCId;
  for(JBBCId = connectedJBBCs.init();
      connectedJBBCs.next(JBBCId);
      connectedJBBCs.advance(JBBCId))
  {
    //check if current JBBC is not the JBBC from which currentReductionPath
    //came from and that currentJBBC is not already in the reduction path.
    //By checking if the JBBC we are trying to extend the reduction path to,
    //is not already in the reduction path, we avoid cycles.
    if((JBBCId != from) && (!currentReductionPath.contains(JBBCId)))
    {
      //get a handle to the connected JBBC
      JBBC * connectedJBBC = JBBCId.getNodeAnalysis()->getJBBC();


      //only try extending reduction path if cardinality of the connected
      //table is at least 10% more than the cardinality of the reduction
      //path to extend
      if((cardinalityOfCurrentReductionPath * 1.1) <
          connectedJBBC->getAfterLocalPredCardinality())
      {
        //Do a join of currentReductionPath with the JBBC represented by JBBCId
        CANodeIdSet currentJBBC(JBBCId);
        EstLogPropSharedPtr joinEstLogProp = (QueryAnalysis::ASM())->joinJBBChildren(currentReductionPath, currentJBBC);

        CostScalar joinCardinality = joinEstLogProp->getResultCardinality();

        //if the cardinality of the join is atleast 5 % lower than the
        //after local predicate cardinality of the connected JBBC,
        //extend the reduction path
        if(joinCardinality < (connectedJBBC->getAfterLocalPredCardinality()*.95))
        {
          connectedJBBC->extendReductionPath(currentReductionPath, joinCardinality,getId());
        }
      }

    }
  }
}
//JBBC::extendReductionPath()

CostScalar JBBC::getAfterLocalPredCardinality()
{
  return afterLocalPredCardinality_;
};
//JBBC::getAfterLocalPredCardinality()

NABoolean JBBC::mergeReductionPaths()
{
  if((incomingConnections_->entries() < 3)&&
     (reductionPaths_->entries() < 2))
  return FALSE;

  NABoolean returnValue=FALSE;

  //create CANodeIdSet to hold mergedReductionPath
  //initially the set is empty because nothing has been merged
  CANodeIdSet mergedReductionPath;

    //create CANodeIdSet to keep track of connections which are
    //merged. Initially empty because no connections have been merged
    CANodeIdSet mergedConnections;

  //iterate over all the connections
  CollIndex i;
  for(i=0; i < incomingConnections_->entries(); i++)
  {
    //Get the most reducing reduction path coming through this connection
    const CANodeIdSet * bestIncomingReductionPath =
      (*incomingConnections_)[i]->getBestIncomingReductionPath();

    //If this connection has a reduction path coming over it
    if(bestIncomingReductionPath){
      CANodeIdSet tempNodeSet = *bestIncomingReductionPath;
      //Join mergedReductionPath with bestIncomingReductionPath
      EstLogPropSharedPtr joinEstLogProp =
        (QueryAnalysis::ASM())->joinJBBChildren(mergedReductionPath, tempNodeSet);

      //update the merged reduction path to include JBBCs in the path just merged
      mergedReductionPath.insert(*bestIncomingReductionPath);

      //update mergedConnections set to indicate the reduction path
      //from this connenction (i.e. incomingConnections[i]) was merged
      mergedConnections.insert((*incomingConnections_)[i]->getConnectedJBBC());
    }
  }


  //if a merge of two or more reduction paths occurred
  if(mergedConnections.entries() > 1)
  {
    //do a join of the merged reduction path with this JBBC to see if
    //the merged reduction path causes a significant reduction in this
    //JBBC
    CANodeIdSet thisJBBC;
    thisJBBC.insert(getId());
    EstLogPropSharedPtr joinEstLogProp = (QueryAnalysis::ASM())->joinJBBChildren(mergedReductionPath, thisJBBC);

    CostScalar mergedReductionPathCardinality = joinEstLogProp->getResultCardinality();

    //if merged path produces at least a 5% reduction in cardinality of
    //this JBBC
    if(mergedReductionPathCardinality <
        (getAfterLocalPredCardinality() * .95))
    {
      returnValue = TRUE;
      //insert merged reduction path in the list of reduction paths
      //store the reduction path passed in
      //store the reduction path passed in
      CANodeIdSet * reductionPathToStore = new (collHeap())\
                                           CANodeIdSet(mergedReductionPath);
      reductionPaths_->insert(reductionPathToStore);

      //insert cardinality into array of cardinalities this will be used by
      //getReducingJoinSet to get cardinalities without the need to lookup the
      //cache.
      cardinalityOfReductionPaths_->insert(mergedReductionPathCardinality);

      //insert this nodes id into merged reduction path as it is to be extended
      //to connected JBBCs now.
      mergedReductionPath.insert(getId());

      //iterate over each connection, if a connection did not
      //participate in the merge try to extend the reduction path
      //to that connected JBBC. The connectedJBBC will be used to
      //identify the connection.
      for(i=0; i < incomingConnections_->entries(); i++)
      {
        //Get CANodeId of connected JBBC
        CANodeId connectedNodeId = ((*incomingConnections_)[i])->\
                                                           getConnectedJBBC();
        //Check to see that this is not a connected node from where one of the
        //merged reduction paths come.
        //Also check if this node is already part of the merged reduction path
        //this avoids cycles
        if((!mergedConnections.contains(connectedNodeId))&&
           (!mergedReductionPath.contains(connectedNodeId)))
        {
          //Get reference to connected JBBC
          JBBC * connectedJBBC =
           (connectedNodeId.getNodeAnalysis())->getJBBC();

          //Do a join of the merged reduction path with the connected JBBC
          CANodeIdSet connectedNode(connectedNodeId);
          joinEstLogProp = (QueryAnalysis::ASM())->\
                           joinJBBChildren(mergedReductionPath, connectedNode);

          CostScalar joinCardinality = joinEstLogProp->getResultCardinality();

          //only extend merged reduction path to a connected JBBC
          //if cardinality of connected JBBC is 10% more than the
          //cardinality of the reduction path to extend
          if((mergedReductionPathCardinality*1.1) <
            connectedJBBC->getAfterLocalPredCardinality())
          {
            //if the cardinality of the join is atleast 5 % lower than the
            //after local predicate cardinality of the connected JBBC,
            //extend the reduction path
            if(joinCardinality < (connectedJBBC->getAfterLocalPredCardinality()*.95))
            {
              //Extend merged redution path to connected JBBC
              connectedJBBC->\
                extendReductionPath(mergedReductionPath, joinCardinality,getId());
            }
          }
        }
      }
    }

  }

  return returnValue;
};
//JBBC::mergeReductionPaths()

JBBSubset * JBBC::getReducingJoinSet(CANodeIdSet & availableJBBCs,
                                     CANodeIdSet * usedSet)
{
  //cardinality produced by the best reducing join set.
  CostScalar minCardinality = getAfterLocalPredCardinality();

  //the best reducing join set as computed till now
  CANodeIdSet * currentBestRJS = NULL;

  //if no recomputation required
  if(!usedSet){
    //iterator over all the reduction paths at this node.
    CollIndex i;
    for(i=0; i < reductionPaths_->entries();i++)
    {
      //check if the current reduction path is a subset of the
      //availableJBBCs
      if(availableJBBCs.contains(*(*reductionPaths_)[i]))
      {
        //get cardinaliy of current reduction path
        CostScalar cardinalityOfCurrentReductionPath =
          (*cardinalityOfReductionPaths_)[i];

          //if cardinality of current reduction path is lower than
          //minCardinality i.e. current reduction path produces a
          //greater reduction.
          if(cardinalityOfCurrentReductionPath < minCardinality)
          {
          //set currentBestRJS to current reduction path
          currentBestRJS = (*reductionPaths_)[i];
          //set minCardinality to cardinality of current reduction
          //path.
          minCardinality = cardinalityOfCurrentReductionPath;
        }
      }
    }
  }
  //recomputation is required
  else
  {
    //Set available and used JBBCs
    CANodeIdSet extendedAvailableJBBCs = availableJBBCs;
    extendedAvailableJBBCs += *usedSet;

    //iterate over all the reduction paths at this node.
    CollIndex i;
    for(i=0; i<reductionPaths_->entries();i++)
    {
      if(extendedAvailableJBBCs.contains(*(*reductionPaths_)[i]))
      {
        //get cardinaliy of current reduction path
        CostScalar cardinalityOfCurrentReductionPath =
          (*cardinalityOfReductionPaths_)[i];

        //if cardinality of current reduction path is lower than
        //minCardinality i.e. current reduction path produces a
        //greater reduction.
        if(cardinalityOfCurrentReductionPath < minCardinality)
        {
          if(currentBestRJS && availableJBBCs.contains(*currentBestRJS))
          {
            //set currentBestRJS to current reduction path
            currentBestRJS = (*reductionPaths_)[i];
            //set minCardinality to cardinality of current reduction
            //path.
            minCardinality = cardinalityOfCurrentReductionPath;
          }
          //recomputation is required for this reduction path
          else{
            //JBBCs that are part of the reduction path and have
            //to be exclude from the used set before doing a join
            //to recompute reduction path
            CANodeIdSet elementsToRemove = *(*reductionPaths_)[i];
            elementsToRemove.intersectSet(availableJBBCs);

            //JBBCs that have to be combined (joined) to the RP
            //in a recomputed reduction path.
            CANodeIdSet recomputationSet = *usedSet;
            recomputationSet.subtractSet(elementsToRemove);

            //use ASM to figure out the cardinality produced by
            //combining recomputationSet with the current reduction
            //path
            CANodeIdSet currentReductionPath = *(*reductionPaths_)[i];
            //add this JBBC to current reduction path since we want the
            //cardinality of join between the recomputed reduction path
            //and this JBBC.
            currentReductionPath.insert(getId());

            EstLogPropSharedPtr recomputedLogProps =
                          (QueryAnalysis::ASM())->joinJBBChildren(currentReductionPath,
                                                                 recomputationSet);
            CostScalar recomputedCardinality = recomputedLogProps->getResultCardinality();

            if(recomputedCardinality < minCardinality)
            {
              //set currentBestRJS to recomputed reduction path
              currentBestRJS = new (CmpCommon::statementHeap()) CANodeIdSet(*(*reductionPaths_)[i]);
              currentBestRJS->insert(recomputationSet);

              //set minCardinality to cardinality of current reduction
              //path.
              minCardinality = recomputedCardinality;
            }
          }
        }
      }
    }
  }

  //JBBSubset for returning
  JBBSubset * bestRJS=NULL;

  //if a RJS was found return it as a JBBSubset
  if(currentBestRJS)
  {
    //create JBBSubset
    bestRJS = new (CmpCommon::statementHeap()) JBBSubset();
    //add elements from currentBestRJS
    bestRJS->addJBBCs(*currentBestRJS);
    }

  return bestRJS;
};
//JBBC::getReducingJoinSet

QueryGraphConnection::QueryGraphConnection(CANodeId targetJBBC,
                                           CANodeId connectedJBBC,
                                           CollHeap *outHeap)
{
  targetJBBC_ = targetJBBC;

  connectedJBBC_ = connectedJBBC;

  bestIncomingReductionPath_ = NULL;

  cardinalityOfBestIncomingReductionPath_ = 0;

  heap_ = outHeap;

};
//QueryGraphConnection::QueryGraphConnection

NABoolean QueryGraphConnection::addIncomingReductionPath
                         (CANodeIdSet * incomingReductionPath,
                        CostScalar cardinalityOfIncomingReductionPath)
{

  //if this is the first reduction path coming in over this connection
  if(!bestIncomingReductionPath_)
  {
    //incoming reduction path is the best reduction path as it is the
    //only reduction path coming over this connection till now
    bestIncomingReductionPath_ = incomingReductionPath;

    //set the cardinality of the best incoming reduction path
    cardinalityOfBestIncomingReductionPath_ =
      cardinalityOfIncomingReductionPath;

    //return TRUE indicating bestIncomingReductionPath_ was updated
    return TRUE;
  }
  else
  {
    if(cardinalityOfIncomingReductionPath <
       cardinalityOfBestIncomingReductionPath_)
       {
         //incoming reduction path is the best reduction path as it has a
         //lower cardinality than the current best reduction path
         bestIncomingReductionPath_ = incomingReductionPath;

         //update the cardinality of the best incoming reduction path
         cardinalityOfBestIncomingReductionPath_ =
           cardinalityOfIncomingReductionPath;

         //return TRUE indicating bestIncomingReductionPath_ was updated
           return TRUE;
       }
  }

  //bestIncomingReductionPath_ was not updated
  return FALSE;
};
//QueryGraphConnection::addIncomingReductionPath

const CANodeIdSet * QueryGraphConnection::getBestIncomingReductionPath()
{
  return bestIncomingReductionPath_;
}
//QueryGraphConnection::getBestIncomingReductionPath