Ejemplo n.º 1
0
// ***************************************************************************
// Initialize internal data structures.
// ***************************************************************************
void DescriptorDetails::init(CollHeap* heap)
{
  // Map all the IDs in the MV descriptor for easy access.
  // This call does a tree walk to initialize the idHash_ map of IDs to elements.
  MapIDsVisitorPtr visitor1 = new(heap) MapIDsVisitor(idHash_, ADD_MEMCHECK_ARGS(heap));
  descriptor_->treeWalk(visitor1);
  deletePtr(visitor1);
  
  RefFinderVisitorPtr visitor2 = new(heap) RefFinderVisitor(this, ADD_MEMCHECK_ARGS(heap));
  descriptor_->treeWalk(visitor2);
  deletePtr(visitor2);

  // Map all the JoinPreds to their participating columns.
  // This must be done before initializing outputs and other preds.
  initJoinPreds();

  // Init the list of JBBDetails
  const NAPtrList<QRJBBPtr>& jbbs = descriptor_->getJbbList();
  for (CollIndex i = 0; i < jbbs.entries(); i++)
  {
    QRJBBPtr jbb = jbbs[i];
    JBBDetailsPtr jbbDetails = 
      new(heap) JBBDetails(jbb, this, isAnMV_, ADD_MEMCHECK_ARGS(heap));
    jbbDetails->init(heap);
    addJBBDetails(jbbDetails);
  }
}
//*****************************************************************************
// Calculate the needed size of the permutationMatrix, allocate it, 
// and initialize it.
// The permutationMatrix has a column for each SelfJoin segment, and a row
// for each permutation.
//*****************************************************************************
void SelfJoinHandler::preparePermutationMatrix()
{
  totalPermutations_ = 1;
  CollIndex segments = segmentArray_.entries();
  UInt32 matrixWidth = 0;
  // The permVector holds for each SelfJoin segment its number of permutations.
  UInt32* permVector = new (heap_) UInt32[segments];
  ShiftMatrixFactoryPtr factory = ShiftMatrixFactory::getInstance(heap_);

  // Go over each segment in the array.
  for (CollIndex i=0; i<segments; i++)
  {
    SelfJoinSegmentPtr segment = segmentArray_[i];
    if (segment->isSelfJoinSegment())
    {
      totalPermutations_ *= segment->getPermutations();
      segment->setMatrixIndex(matrixWidth);
      permVector[matrixWidth] = segment->getPermutations();
      matrixWidth++;
      segment->setShiftMatrix(factory->getMatrixForSize(segment->getSize()));
    }
  }
  
  // Allocate the permutationMatrix.
  permMatrix_ = new(heap_) 
    Array2D(matrixWidth, totalPermutations_, 9999, ADD_MEMCHECK_ARGS(heap_));

  // And initialize it.
  initPermutationMatrix(permVector);
}
Ejemplo n.º 3
0
// ***************************************************************************
// ***************************************************************************
void JBBDetails::initBaseTables(CollHeap* heap)
{
  // Create BaseTableDetails objects for the JBB hub tables.
  const ElementPtrList& hubTables = jbbDesc_->getHub()->getJbbcList()->getList();
  for (CollIndex i=0; i<hubTables.entries(); i++)
  {
    const QRElementPtr jbbc = hubTables[i];
    if (jbbc->getElementType() != ET_Table)
      continue; // Skip reference to other JBBs.

    const QRTablePtr table = jbbc->downCastToQRTable();
    if (table->hasLOJParent())
      hasLOJs_ = TRUE;

    // Rest of the stuff only needed for MVs.
    if (!isAnMV_)
      continue;

    BaseTableDetailsPtr tableDetails = new(heap) 
      BaseTableDetails(table, TRUE, ADD_MEMCHECK_ARGS(heap));
    baseTablesByID_.insert(&tableDetails->getID(), tableDetails);
  }

  // Now do the same for the extra-hub tables.
  const QRTableListPtr extraHubTables = jbbDesc_->getExtraHub()->getTableList();
  if (extraHubTables != NULL)
  {
    for (CollIndex j=0; j<extraHubTables->entries(); j++)
    {
      const QRTablePtr table = (*extraHubTables)[j];
      if (table->hasLOJParent())
        hasLOJs_ = TRUE;

      // Rest of the stuff only needed for MVs.
      if (!isAnMV_)
        continue;

      BaseTableDetailsPtr tableDetails = new(heap) 
	BaseTableDetails(table, FALSE, ADD_MEMCHECK_ARGS(heap));
      baseTablesByID_.insert(&tableDetails->getID(), tableDetails);
    }
  }
}
//*****************************************************************************
// Create and initialize a ShiftMatrix of size size.
//*****************************************************************************
ShiftMatrix::ShiftMatrix(Int32  size,
	                 ADD_MEMCHECK_ARGS_DECL(CollHeap* heap))
  : NAIntrusiveSharedPtrObject(ADD_MEMCHECK_ARGS_PASS(heap)),
    theMatrix_(NULL),
    elements_(size),  
    combinations_(factorial(elements_)),  // The number of permutations is size!
    heap_(heap)
{
  // Allocate the array of permutations
  theMatrix_ = new(heap) 
    Array2D(combinations_, elements_, 9999, ADD_MEMCHECK_ARGS(heap));

  // Initialize the matrix.
  init();
}
//*****************************************************************************
// Get a ShiftMatrix for a specific size.
//*****************************************************************************
const ShiftMatrixPtr ShiftMatrixFactory::getMatrixForSize(Int32 size)
{
  // Did we already build a ShiftMatrix for this size?
  if (matrixSizeArray_.used(size))
  {
    // Yes - return it.
    return matrixSizeArray_[size];
  }
  else
  {
    // No - build one now.
    ShiftMatrixPtr newMatrix = new (heap_) ShiftMatrix(size, ADD_MEMCHECK_ARGS(heap_));
    // And keep the pointer in the array.
    matrixSizeArray_.insertAt(size, newMatrix);
    return newMatrix;
  }
}
MVCandidatesForJBBSubsetPtr QRGroupLattice::search(QRJBBPtr	           queryJbb, 
						   MVCandidatesForJBBPtr   mvCandidates, 
						   QRJoinSubGraphMapPtr    map,
                                                   ElementPtrList*         minimizedGroupingList)
{
  QRTRACER("QRGroupLattice::search()");
  DescriptorDetailsPtr queryDetails = mvCandidates->getAllCandidates()->getQueryDetails();
  LatticeKeyList keyList(heap_);

  if (minimizedGroupingList)
  {
    if (!elementListToKeyList(*minimizedGroupingList, keyList, map, queryDetails, FALSE))
      return NULL;
  }
  else
  {
    // Get the grouping columns of the passed query JBB, and create a key list
    // from them. Return now if there are no grouping items -- a query without a
    // Group By can't match an MV that has one.
    QRGroupByPtr groupBy = queryJbb->getGroupBy();
    if (!groupBy)
      return NULL;

    // An aggregate query with no GroupBy has an empty key list.
    if (!getGroupingLatticeKeys(keyList, map, queryDetails, queryJbb, TRUE, FALSE))
      return NULL;
  }

  // Create the search node, disallowing the addition of any new keys to the hash
  // table used by the lattice; if the key isn't already used, the node can have
  // no supersets.
  QRLatticeIndexSearchNode searchNode(keyList, lattice_, TRUE, heap_);
  if (!searchNode.isValid())   // because a key wasn't added
    return NULL;

  NAString keysText;
  searchNode.dumpNode(keysText, *lattice_->getKeyArr());
  QRLogger::log(CAT_GRP_LATTCE_INDX, LL_DEBUG, 
    "Searching LatticeIndex for: %s.", keysText.data());

  // Find the supersets of the query's group-by list in the MV group lattice
  // index. For each lattice index node returned, create an MVCandidate
  // corresponding to each MV represented by that node, and add it to the
  // candidate list passed by the caller.
  NAPtrList<QRLatticeIndexNodePtr> nodes;
  lattice_->findSupersets(searchNode, nodes);

  if (nodes.entries() == 0)
  {
    QRLogger::log(CAT_GRP_LATTCE_INDX, LL_DEBUG, "No match found.");
    return NULL;
  }

  MVCandidatesForJBBSubsetPtr jbbSubset = new(heap_) 
    MVCandidatesForJBBSubset(mvCandidates, ADD_MEMCHECK_ARGS(heap_));
  jbbSubset->setSubGraphMap(map);
  jbbSubset->setGroupBy(TRUE);

  if (minimizedGroupingList != NULL)
    jbbSubset->setMinimizedGroupingList(minimizedGroupingList);

  for (CollIndex i=0; i<nodes.entries(); i++)
    {
      QRLatticeIndexNodePtr thisNode = nodes[i];
      const SubGraphMapList& matchingMVs = thisNode->getMVs();
      NABoolean isPreferred = (*thisNode == searchNode); // preferred if exact match

      GroupingList* extraGroupingColumns = new(heap_) GroupingList(heap_);
      if (!isPreferred)
      {
	// For preferred match modes, there are no extraGroupingColumns.
	LatticeKeySubArray* diff = thisNode->computeDiff(searchNode, heap_);
	for(CollIndex i = 0; diff->nextUsed(i); i++)
	{
          LatticeIndexablePtr key = diff->element(i);
          QRElementPtr elem = keyToElement(key, map);
	  extraGroupingColumns->insert(elem);
	}
	delete diff;
      }

      for (CollIndex j=0; j<matchingMVs.entries(); j++)
        {
	  MVDetailsPtr mv = matchingMVs[j]->getMVDetails();
          QRLogger::log(CAT_GRP_LATTCE_INDX, LL_DEBUG, 
            "Found MV: %s!", mv->getMVName().data() );
	  jbbSubset->insert(mv, queryJbb, isPreferred, extraGroupingColumns, NULL, heap_);
        }
    }

  return jbbSubset;

}  // QRGroupLattice::search()
//*****************************************************************************
// Add a segment to the segment array.
//*****************************************************************************
void SelfJoinHandler::addSegment(SelfJoinSegment::SegmentType type)
{
  SelfJoinSegmentPtr newSegment = new (heap_) 
    SelfJoinSegment(type, segmentStart_, segmentEnd_, ADD_MEMCHECK_ARGS(heap_));
  segmentArray_.insertAt(segmentArray_.entries(), newSegment);
}