public function multiGet($noderefs, NodePartials $nodePartials, $forceReadWrite = false, $checkJumpPermissions = false, $allowDeleted = false)
 {
     //        foreach((array)$noderefs as $nodeRef)
     //            $this->NodeEvents->fireNodeEvents('get', '', &$nodeRef);
     if (empty($noderefs)) {
         return array();
     }
     $results = array();
     $idField = 'ID';
     $connectionCouplets = $this->getResolvedConnectionCouplets(is_array($noderefs) ? $noderefs : array($noderefs), $forceReadWrite);
     foreach ($connectionCouplets as $connectionCouplet) {
         $db = $connectionCouplet->getConnection();
         $tableToSlugs = $connectionCouplet->getAttribute('tablesToSlugs');
         foreach ($tableToSlugs as $table => $tableInfo) {
             extract($tableInfo);
             if ($checkJumpPermissions && !$this->NodePermissions->check('get', $tableNodeRef, $nodePartials, true)) {
                 continue;
             }
             foreach (array_chunk($slugs, 1000) as $slugs) {
                 $rows = $this->multiGetFromDB($db, $tableid, $table, $tableNodeRef, $slugs, false, $forceReadWrite, $allowDeleted);
                 if (!empty($rows)) {
                     $ids = ArrayUtils::arrayMultiColumn($rows, $idField);
                     $outTags = $this->NodeTagsDAO->findOutTags($db, $tableNodeRef, $ids, $nodePartials->getOutPartials(), $forceReadWrite, $checkJumpPermissions, $nodePartials->getRestrictedOutPartials(), $nodePartials->isResolveLinks());
                     $inTags = $this->NodeTagsDAO->findInTags($db, $tableNodeRef, $ids, $nodePartials->getInPartials(), $forceReadWrite, $checkJumpPermissions, $nodePartials->getRestrictedInPartials(), $nodePartials->isResolveLinks());
                     $meta = $this->NodeMetaDAO->findMeta($db, $tableNodeRef, $ids, $nodePartials->getMetaPartials(), $forceReadWrite, $nodePartials->getRestrictedMetaPartials());
                     foreach ($rows as $nodeRefString => $row) {
                         $row->setNodePartials($nodePartials);
                         if (isset($meta[$row[$idField]])) {
                             $row->setMetas($meta[$row[$idField]]);
                         }
                         if (isset($outTags[$row[$idField]])) {
                             $row->setOutTags($outTags[$row[$idField]]);
                         }
                         if (isset($inTags[$row[$idField]])) {
                             $row->setInTags($inTags[$row[$idField]]);
                         }
                         //$this->NodeMapper->populateNodeCheaters($row);
                         $results[$nodeRefString] = $row;
                     }
                     unset($ids);
                     unset($outTags);
                     unset($inTags);
                     unset($meta);
                 }
                 unset($rows);
             }
             unset($slugs);
         }
         unset($tableToSlugs);
     }
     unset($connectionCouplets);
     if (!empty($results) && !is_array($noderefs)) {
         return current($results);
     }
     return $results;
 }
예제 #2
0
 /**
  * {@inheritdoc}
  */
 public function getNodes(NodeRef $nodeRef, $slugs, $localOnly = false)
 {
     $cacheKeys = array();
     $nodeRefPart = $nodeRef->getElement()->getSlug();
     foreach ((array) $slugs as $slug) {
         $cacheKeys[] = 'node-' . $nodeRefPart . ':' . $slug;
     }
     if (!empty($cacheKeys)) {
         if (($cachedRows = $this->multiGet($cacheKeys, $localOnly)) && !empty($cachedRows)) {
             $cachedSlugs = ArrayUtils::arrayMultiColumn($cachedRows, 'Slug');
             return array($cachedSlugs, $cachedRows);
         }
     }
     return array(array(), array());
 }
예제 #3
0
 protected function findTags($direction, $db, NodeRef $originNodeRef, $ids, $partials = 'fields', $forceReadWrite = false, $checkJumpPermissions = false, $restrictedPartials, $resolveLinkedRecords = true, $existingRows = null)
 {
     if (!is_null($db) && !$db instanceof DatabaseInterface) {
         throw new NodeException('Argument 2 passed to NodeTagsDAO::findTags() must implement interface DatabaseInterface');
     }
     $results = array();
     if (empty($partials)) {
         return $results;
     }
     $returnOne = false;
     if (!is_array($ids)) {
         $returnOne = $ids;
         $ids = array($originNodeRef->getRefURL() => $ids);
     }
     $fixedId = false;
     if (!is_null($existingRows)) {
         $fixedId = 1;
         $returnOne = 1;
     }
     $tagFields = $this->tagFields;
     $this->Logger->debug('findTags [' . $direction . '] with partials [' . $partials . '] restrict [' . $restrictedPartials . ']');
     if ($direction == 'out') {
         $table = $this->NodeDBMeta->getOutTagsTable($originNodeRef);
         $partials = PartialUtils::unserializeOutPartials($partials);
         $restrictedPartials = PartialUtils::unserializeOutPartials($restrictedPartials);
     } else {
         $table = $this->NodeDBMeta->getInTagsTable($originNodeRef);
         $partials = PartialUtils::unserializeInPartials($partials);
         $restrictedPartials = PartialUtils::unserializeInPartials($restrictedPartials);
         //            $tagFields[] = 'TagOutID';
     }
     //        $this->Logger->debug($partials);
     $tableid = $this->NodeDBMeta->getPrimaryKey($originNodeRef);
     $now = $this->DateFactory->newLocalDate();
     $rows = array();
     $fieldlikePartials = array();
     $childexprPartials = array();
     $addlParams = array();
     $jumpParams = array();
     $fieldlikeRoles = array();
     $nonfieldlikeRoles = array();
     $outRoles = array();
     $all = false;
     $allfieldlike = false;
     $tagDefs = array();
     if ($partials == 'all' || ($x = array_search('all', $partials)) !== false) {
         $all = true;
         $partials = array();
     } else {
         if (($x = array_search('fields', $partials)) !== false) {
             $allfieldlike = true;
             unset($partials[$x]);
         }
     }
     if ($restrictedPartials == 'all' || ($x = array_search('all', $restrictedPartials)) !== false) {
         return array();
     }
     $tagDefs = $originNodeRef->getElement()->getSchema()->getTagDefs();
     foreach ($originNodeRef->getElement()->getSchema()->getTagDefs() as $role => $tagDef) {
         if ($tagDef->isFieldlike() && strtolower($tagDef->Direction) == $direction) {
             $fieldlikeRoles[] = $role;
         }
         if ($tagDef->Direction == 'out') {
             $outRoles[] = $role;
         }
     }
     foreach ($partials as $x => $outPartial) {
         if ($outPartial['TagRole'] == false) {
             throw new TagException('Tag partials must specify a role when retrieving tags');
         }
         if (in_array($outPartial['TagRole'], $fieldlikeRoles)) {
             $fieldlikePartials[] = $outPartial;
             unset($partials[$x]);
         }
         if ($resolveLinkedRecords && $outPartial->hasChildPartials()) {
             $childexprPartials[$outPartial['TagRole']][] = $outPartial;
         }
     }
     // tags passed to us, no need to query database
     if (is_null($existingRows)) {
         if ($allfieldlike == true || !empty($fieldlikePartials)) {
             $cachedIds = array();
             // read from cache
             list($cachedIds, $rows) = $this->NodeCache->getTags($direction, $ids, $forceReadWrite);
             $remainingIds = array_diff($ids, $cachedIds);
             if (!empty($remainingIds)) {
                 $dbToCacheRows = array();
                 if (!empty($fieldlikeRoles)) {
                     $q = new Query();
                     $q->SELECT($tableid . ' as ID');
                     $q->SELECT($tagFields);
                     // Commented out on 2/1/2010 by Craig .. Mysql seems to be using the right indexes without this.
                     // $q->FROM($db->quoteIdentifier($table).' FORCE INDEX(RoleOnly)');
                     $q->FROM($db->quoteIdentifier($table));
                     $q->WHERE("{$tableid} IN ({$db->joinQuote((array) $remainingIds)})");
                     $q->WHERE("Role IN ({$db->joinQuote((array) $fieldlikeRoles)})");
                     $dbRows = $this->getConnectionForWrite($originNodeRef)->readAll($q);
                     foreach ($dbRows as $row) {
                         $dbToCacheRows[$row['ID']][] = $row;
                         $rows[] = $row;
                     }
                 }
                 $this->NodeCache->putTags($direction, $remainingIds, $dbToCacheRows, $forceReadWrite);
             }
         }
         if ($all) {
             $q = new Query();
             //                if($forceReadWrite)
             //                    $q->forUpdate();
             $q->SELECT($tableid . ' as ID');
             $q->SELECT($tagFields);
             $q->FROM($db->quoteIdentifier($table));
             $q->WHERE("{$tableid} IN ({$db->joinQuote((array) $ids)})");
             //                $q->WHERE("SectionID = 0");
             $rows = $db->readAll($q);
         } else {
             $runPartials = array();
             // perform a SQL statement per partial
             foreach ($partials as $outPartial) {
                 if (in_array($outPartial->toString(), $runPartials)) {
                     continue;
                 }
                 if ($outPartial['TagRole'] == false) {
                     throw new TagException('Tag partials must specify a role when retrieving tags');
                 }
                 if ($direction == 'out' && !in_array($outPartial['TagRole'], $outRoles)) {
                     continue;
                 }
                 $unions = array();
                 foreach ((array) $ids as $id) {
                     $q = new Query();
                     $q->SELECT($tableid . ' as ID');
                     $q->SELECT($tagFields);
                     $q->FROM($db->quoteIdentifier($table));
                     //                        $q->WHERE("$tableid IN ({$db->joinQuote((array)$ids)})");
                     $q->WHERE("{$tableid} = {$db->quote($id)}");
                     //                    $q->WHERE("SectionID = 0");
                     if ($direction == 'out') {
                         $q->WHERE($this->getOutTagPartialClause($outPartial, $db, $db->quoteIdentifier($table)));
                     } else {
                         $q->WHERE($this->getInTagPartialClause($outPartial, $originNodeRef->getElement(), $db, $db->quoteIdentifier($table)));
                     }
                     if (!$forceReadWrite && $this->nodeDatabaseTagMergeLimit > 0) {
                         $q->LIMIT($this->nodeDatabaseTagMergeLimit);
                     }
                     $unions[] = '(' . (string) $q . ')';
                 }
                 $sql = implode('
                      UNION ALL
                     ', $unions);
                 $rows = array_merge($rows, $db->readAll($sql));
                 $nonfieldlikeRoles[] = $outPartial['TagRole'];
                 $runPartials[] = $outPartial->toString();
             }
         }
     } else {
         $rows = $existingRows;
     }
     // if no rows, return empty array
     if (empty($rows)) {
         return $rows;
     }
     $sortKeys = array();
     foreach ($rows as $k => $row) {
         $sortKeys[$k] = $row['TagSortOrder'];
     }
     array_multisort($sortKeys, SORT_ASC, $rows);
     // gather linked NodeRefs
     $tagNodeRefs = array();
     //        $strTagNodeRefs = array();
     //        $this->Logger->debug('FIELD LIKE PARTIALS');
     //        $this->Logger->debug($fieldlikePartials);
     //        $this->Logger->debug('NON FIELD LIKE PARTIALS');
     //        $this->Logger->debug($partials);
     $existingTagsPerNode = array();
     $newrows = array();
     $deletedTags = array();
     // filter out bogus rows
     foreach ($rows as $k => $row) {
         //            $rowElement = $this->ElementService->getByID($row['TagElementID']);
         if (!empty($row['TagElement'])) {
             $rowElement = $this->ElementService->getBySlug($row['TagElement']);
         } else {
             $rowElement = $this->ElementService->getByID($row['TagElementID']);
         }
         // element doesn't exist anymore
         if (empty($rowElement)) {
             continue;
         }
         //            error_log($nodeRef);
         if (!array_key_exists($row['TagRole'], $tagDefs)) {
             if ($direction == 'in' && $rowElement->getSchema()->hasTagDef($row['TagRole'])) {
                 $row['TagDef'] = $rowElement->getSchema()->getTagDef($row['TagRole']);
             } else {
                 continue;
             }
             // tag definition does not exist
         } else {
             $row['TagDef'] = $tagDefs[$row['TagRole']];
         }
         $row['TagElement'] = $rowElement->getSlug();
         $row['TagRoleDisplay'] = $row['TagDef']['Title'];
         $row['TagDirection'] = $direction;
         //$row['TagLinkRefURL'] = $nodeRef->getRefURL();
         //            $row['TagSite'] = $nodeRef->getSite()->getSlug();
         if (!empty($restrictedPartials)) {
             foreach ($restrictedPartials as $partial) {
                 if ($this->TagsHelper->matchPartial($partial, $row)) {
                     continue 2;
                 }
             }
         }
         if ($all == false && $allfieldlike == false && !empty($fieldlikePartials) && in_array($row['TagRole'], $fieldlikeRoles)) {
             //                error_log('matching fieldlike');
             //                error_log(print_r($fieldlikePartials, true));
             $found = false;
             foreach ($fieldlikePartials as $partial) {
                 //                    error_log('test '.$partial->toString());
                 if ($this->TagsHelper->matchPartial($partial, $row)) {
                     //                        error_log('match');
                     $found = true;
                     break;
                 }
             }
             if (!$found) {
                 continue;
             }
         }
         if ($all == false && !empty($partials) && in_array($row['TagRole'], $nonfieldlikeRoles)) {
             //                error_log('matching fieldlike');
             $found = false;
             foreach ($partials as $partial) {
                 //                    error_log('test '.$partial->toString());
                 if ($this->TagsHelper->matchPartial($partial, $row)) {
                     //                        error_log('match');
                     $found = true;
                     break;
                 }
             }
             if (!$found) {
                 continue;
             }
         }
         $nodeRef = new NodeRef($rowElement, $row['TagSlug']);
         $row['TagLinkNodeRef'] = $nodeRef;
         $row['NoValidation'] = true;
         $tag = new Tag($row);
         if (isset($existingTagsPerNode[$row['ID']]) && array_key_exists($tag->toString(), $existingTagsPerNode[$row['ID']])) {
             $tagIDToDelete = $existingTagsPerNode[$row['ID']][$tag->toString()];
             if ($tagIDToDelete != $tag->TagID) {
                 if ($tag->TagID > $tagIDToDelete) {
                     $tagIDToDelete = $tag->TagID;
                     // If the current tag is being deleted, mark it as deleted so that we can skip the rest of
                     // the processing once it's deleted from the db.
                     $tag->Deleted = true;
                 } else {
                     // We're deleting a tag that was already added to the results array. Therefore just keep track of
                     // it so that we can remove it from the results array later.
                     if ($fixedId) {
                         $deletedTags[$fixedId][] = $tagIDToDelete;
                     } else {
                         $deletedTags[$row['ID']][] = $tagIDToDelete;
                     }
                 }
                 // read repair
                 $this->Logger->debug("Delete {$tag->getTagDirection()} tag: {$tag->toString()}");
                 $affectedRows = $this->getConnectionForWrite($originNodeRef)->write("DELETE FROM {$db->quoteIdentifier($table)} WHERE TagID = {$db->quote($tagIDToDelete)}");
                 if ($affectedRows > 0) {
                     $this->NodeEvents->fireTagEvents($direction . 'tags', 'remove', $originNodeRef, $nodeRef, $tag);
                 }
                 // If the current tag is the one that got deleted, we're done processing this tag and can move to
                 // the next. This tag will not get added to the results.
                 if ($tag->Deleted) {
                     continue;
                 }
             }
         }
         $existingTagsPerNode[$row['ID']][$tag->toString()] = $tag->TagID;
         if ($resolveLinkedRecords) {
             $tagNodeRefs[] = $nodeRef;
             //                $strTagNodeRefs[$k] = (string)$nodeRef;
             // if need to merge more tags in
             if (array_key_exists($row['TagRole'], $childexprPartials)) {
                 // TODO: check partial matches
                 $rowRefKey = $rowElement->getSlug();
                 $outPartials = $childexprPartials[$row['TagRole']];
                 foreach ($outPartials as $outPartial) {
                     $expressions = StringUtils::smartSplit($outPartial->getChildPartials(), ".", '"', '\\"', 2);
                     $firstExpression = array_shift($expressions);
                     if (strtolower($firstExpression) == 'meta') {
                         $addlParams[$rowRefKey]['Meta.select'][] = 'all';
                     } elseif (strtolower($firstExpression) == 'fields') {
                         $addlParams[$rowRefKey]['Meta.select'][] = 'all';
                         $addlParams[$rowRefKey]['OutTags.select'][] = 'fields';
                         $addlParams[$rowRefKey]['InTags.select'][] = 'fields';
                     } else {
                         unset($schemaDef);
                         $isTag = true;
                         try {
                             $jPartial = new TagPartial($firstExpression);
                             $role = $jPartial->getTagRole();
                             if ($nodeRef->getElement()->getSchema()->hasTagDef($role)) {
                                 $schemaDef = $nodeRef->getElement()->getSchema()->getTagDef($role);
                             } else {
                                 if ($nodeRef->getElement()->getSchema()->hasMetaDef($role)) {
                                     $jPartial = new MetaPartial($firstExpression);
                                     $schemaDef = $nodeRef->getElement()->getSchema()->getMetaDef($role);
                                     $isTag = false;
                                 }
                             }
                         } catch (Exception $e) {
                             $jPartial = new MetaPartial($firstExpression);
                             $role = $jPartial->getMetaName();
                             if ($nodeRef->getElement()->getSchema()->hasMetaDef($role)) {
                                 $schemaDef = $nodeRef->getElement()->getSchema()->getMetaDef($role);
                             }
                             $isTag = false;
                         }
                         if (empty($schemaDef)) {
                             continue;
                         }
                         //throw new NodeException('Cannot retrieve additional nodes for role ['.$role.'], no schema def found on element ['.$rowElement->getSlug().']');
                         if ($isTag) {
                             $newPartials = $schemaDef->getDirection() == 'out' ? 'OutTags.select' : 'InTags.select';
                             $jPartial = $jPartial->getTagRole();
                         } else {
                             $newPartials = 'Meta.select';
                             $jPartial = $jPartial->getMetaName();
                         }
                         $new = $firstExpression;
                         if (!empty($expressions[0])) {
                             $new .= '.' . $expressions[0];
                         }
                         $addlParams[$rowRefKey][$newPartials][] = $new;
                         $jumpParams[$row['TagRole']][$newPartials][] = $jPartial;
                     }
                 }
             }
             $newrows[] = $tag;
         } else {
             if ($fixedId) {
                 $results[$fixedId][] = $row;
             } else {
                 $results[$row['ID']][] = $tag;
             }
         }
     }
     if ($resolveLinkedRecords) {
         //            error_log('PRE NODE RETRIEVE');
         // find the corresponding records
         $nodeRows = array();
         $connectionCouplets = $this->getResolvedConnectionCouplets($tagNodeRefs, $forceReadWrite);
         foreach ($connectionCouplets as $connectionCouplet) {
             $db = $connectionCouplet->getConnection();
             $tableToSlugs = $connectionCouplet->getAttribute('tablesToSlugs');
             foreach ($tableToSlugs as $table => $tableInfo) {
                 extract($tableInfo);
                 $rowRefKey = $element->getSlug();
                 $partialJump = false;
                 $newNodePartials = null;
                 if (array_key_exists($rowRefKey, $addlParams)) {
                     $partialJump = true;
                     $addl = $addlParams[$rowRefKey];
                     $newNodePartials = new NodePartials();
                     if (array_key_exists('OutTags.select', $addl)) {
                         $newNodePartials->setOutPartials(implode(',', array_unique($addl['OutTags.select'])));
                     }
                     if (array_key_exists('InTags.select', $addl)) {
                         $newNodePartials->setInPartials(implode(',', array_unique($addl['InTags.select'])));
                     }
                     if (array_key_exists('Meta.select', $addl)) {
                         $newNodePartials->setMetaPartials(implode(',', array_unique($addl['Meta.select'])));
                     }
                 }
                 if ($checkJumpPermissions && !$this->NodePermissions->check('get', $tableNodeRef, $newNodePartials, true)) {
                     continue;
                 }
                 $foundRows = $this->multiGetFromDB($db, $tableid, $table, $tableNodeRef, $slugs, false, $forceReadWrite, false);
                 if ($partialJump && !empty($foundRows)) {
                     $this->Logger->debug('Partials jump on ' . $tableNodeRef->getElement()->getName());
                     $aoutTags = array();
                     $ainTags = array();
                     $ameta = array();
                     $this->Benchmark->start('partial-jump');
                     $idField = 'ID';
                     $pids = ArrayUtils::arrayMultiColumn($foundRows, $idField);
                     if ($newNodePartials->hasOutPartials()) {
                         $aoutTags = $this->findOutTags($db, $tableNodeRef, $pids, $newNodePartials->getOutPartials(), false, false, $checkJumpPermissions);
                     }
                     if ($newNodePartials->hasInPartials()) {
                         $ainTags = $this->findInTags($db, $tableNodeRef, $pids, $newNodePartials->getInPartials(), false, false, $checkJumpPermissions);
                     }
                     if ($newNodePartials->hasMetaPartials()) {
                         $ameta = $this->NodeMetaDAO->findMeta($db, $tableNodeRef, $pids, $newNodePartials->getMetaPartials(), false);
                     }
                     foreach ($foundRows as $nodeRefString => &$nrow) {
                         $nrow->setNodePartials($newNodePartials);
                         $nrow->setMetas(isset($ameta[$nrow[$idField]]) ? $ameta[$nrow[$idField]] : array());
                         $nrow->setOutTags(isset($aoutTags[$nrow[$idField]]) ? $aoutTags[$nrow[$idField]] : array());
                         $nrow->setInTags(isset($ainTags[$nrow[$idField]]) ? $ainTags[$nrow[$idField]] : array());
                     }
                     $this->Benchmark->end('partial-jump');
                 }
                 $nodeRows = array_merge($nodeRows, $foundRows);
             }
         }
         foreach ($newrows as $row) {
             //                $id = $row['ID'];
             //                unset($row['ID']);
             //                error_log(print_r($row, true));
             if ($resolveLinkedRecords) {
                 $nodeRef = $row['TagLinkNodeRef'];
                 if (!array_key_exists((string) $nodeRef, $nodeRows)) {
                     continue;
                 }
                 $tagNode = $nodeRows[(string) $nodeRef];
                 // if need to filter out jump partials
                 if (array_key_exists($row['TagRole'], $jumpParams)) {
                     $outPartials = $jumpParams[$row['TagRole']];
                     foreach ($outPartials as $key => $kPartials) {
                         if ($key == 'Meta.select') {
                             foreach ($tagNode->getMetas() as $meta) {
                                 if (!in_array($meta->MetaName, $kPartials)) {
                                     $tagNode->removeMeta($meta->MetaName);
                                 }
                             }
                         } else {
                             if ($key == 'InTags.select') {
                                 foreach ($tagNode->getInTags() as $tag) {
                                     if (!in_array($tag->TagRole, $kPartials)) {
                                         $tagNode->removeInTags($tag->TagRole);
                                     }
                                 }
                             } else {
                                 if ($key == 'OutTags.select') {
                                     foreach ($tagNode->getOutTags() as $tag) {
                                         if (!in_array($tag->TagRole, $kPartials)) {
                                             $tagNode->removeOutTags($tag->TagRole);
                                         }
                                     }
                                 }
                             }
                         }
                     }
                 }
                 // ignore deleted records
                 //if($tagNode['Status'] == 'deleted')
                 //    continue;
                 $row['TagLinkNode'] = $tagNode;
                 $row['TagLinkTitle'] = $tagNode['Title'];
                 $row['TagLinkID'] = $tagNode['ID'];
                 $row['TagLinkStatus'] = $tagNode['Status'];
                 $row['TagLinkActiveDate'] = $tagNode['ActiveDate'];
                 $row['TagLinkSortOrder'] = $tagNode['SortOrder'];
                 // only populate TagLinkURL if the record is active
                 if ($tagNode['Status'] == 'published' && $tagNode['ActiveDateUnix'] < $now->toUnix()) {
                     $row['TagLinkIsActive'] = true;
                     $row['TagLinkURL'] = $nodeRef->getRecordLink();
                     $row['TagLinkURI'] = $nodeRef->getRecordLinkURI();
                 } else {
                     $row['TagLinkURL'] = '';
                 }
                 $row['TagLinkURI'] = '';
             }
             if ($fixedId) {
                 $results[$fixedId][] = $row;
             } else {
                 $results[$row['ID']][] = $row;
             }
         }
     }
     // If tags were deleted during the 'read repair' they need to be removed from the results array
     // Go through the nodes that have had tags deleted. If those nodes exist in the results array, go
     // through the tags being returned. If the tag exists in the 'deleted' array for the node, remove it from
     // the result set.
     if (!empty($deletedTags)) {
         foreach ($deletedTags as $rowId => $rowDeletedTags) {
             if (isset($results[$rowId]) && !empty($results[$rowId])) {
                 foreach ($results[$rowId] as $resultKey => $rowResults) {
                     if (in_array($rowResults->TagID, $rowDeletedTags)) {
                         unset($results[$rowId][$resultKey]);
                     }
                 }
             }
         }
     }
     if ($returnOne) {
         return isset($results[$returnOne]) ? $results[$returnOne] : array();
     }
     return $results;
 }
예제 #4
0
 /**
  * @throws NodeException
  * @param NodeQuery $nodeQuery
  * @param bool $forceReadWrite
  * @return NodeQuery
  */
 public function findAll(NodeQuery $nodeQuery, $forceReadWrite = false)
 {
     $this->Benchmark->start('findall');
     //        $this->Logger->debug($nodeQuery);
     $this->Events->trigger('Node.findAll', $nodeQuery);
     if ($nodeQuery->getResults() !== null) {
         return $nodeQuery;
     }
     // NODEREFS
     //list($nodeRefs, $nodePartials, $allFullyQualified) = $this->NodeRefService->parseFromNodeQuery($nodeQuery);
     $this->NodeRefService->normalizeNodeQuery($nodeQuery);
     $nodeRefs = $nodeQuery->getParameter('NodeRefs.normalized');
     $nodePartials = $nodeQuery->getParameter('NodePartials.eq');
     $allFullyQualified = $nodeQuery->getParameter('NodeRefs.fullyQualified');
     if (empty($nodeRefs)) {
         return $nodeQuery;
     }
     //        foreach((array)$nodeRefs as $k => $nodeRef)
     //            $this->NodeEvents->fireNodeEvents('find', '', $nodeRef, $nodePartials, $nodeQuery);
     $orderObjects = $this->NodesHelper->getOrderObjects($nodeQuery);
     //        $this->currentOrderingObjects = $orderObjects;
     $co = false;
     if ($nodeQuery->hasParameter('Count.only') && ($co = $nodeQuery->getParameter('Count.only')) != true) {
         throw new NodeException('Count.only parameter must be equal to true');
     }
     $checkPermissions = $nodeQuery->hasParameter('Permissions.check') && $nodeQuery->getParameter('Permissions.check') == true;
     $doCounts = $nodeQuery->isRetrieveTotalRecords() || $co;
     $offset = $nodeQuery->getOffset() != null ? $nodeQuery->getOffset() : 0;
     $limit = $nodeQuery->getLimit();
     $allowDeleted = $nodeQuery->getParameter('Status.all') != null || $nodeQuery->getParameter('Status.eq') == 'deleted';
     if ($allFullyQualified) {
         $this->Logger->debug('RETRIEVING, SORTING, AND FILTERING IN PHP');
         // TODO: limit this to 50 nodes, PHP can't handle more
         $existsNodePartials = $this->NodesHelper->createNodePartialsFromExistsClauses($nodeQuery);
         // RETRIEVAL PHASE
         $resultingRows = $this->NodeMultiGetDAO->multiGet($nodeRefs, $existsNodePartials, $forceReadWrite, $checkPermissions, $allowDeleted);
         // FILTER PHASE
         $resultingRows = $this->NodesHelper->filterNodes($resultingRows, $nodeQuery);
         if ($doCounts) {
             $totalCount = count($resultingRows);
         }
         if (!empty($resultingRows)) {
             // SORTING PHASE
             $resultingRows = $this->NodesHelper->sortNodes($resultingRows, $orderObjects, true);
             // LIMIT/OFFSET PHASE
             $resultingRows = $this->NodesHelper->sliceNodes($resultingRows, $limit, $offset);
         }
     } else {
         $this->Logger->debug('RETRIEVING, SORTING, AND FILTERING IN MySQL');
         $moreThan1Table = false;
         $connectionCouplets = $this->getResolvedConnectionCouplets($nodeRefs, $forceReadWrite);
         $resultingRows = array();
         $queries = array();
         $elements = array();
         $c = 0;
         $totalCount = 0;
         //$query = null;
         //$firstTable = null;
         //$firstTableID = null;
         foreach ($connectionCouplets as $connectionCouplet) {
             $db = $connectionCouplet->getConnection();
             $tableToSlugs = $connectionCouplet->getAttribute('tablesToSlugs');
             //if(is_null($limit) && count($tableToSlugs) > 1)
             //    throw new Exception('Cannot have limitless query across multiple tables');
             foreach ($tableToSlugs as $table => $tableInfo) {
                 extract($tableInfo);
                 //if(!$query)
                 $query = $this->buildMySQLQuery($db, $tableNodeRef, $table, $tableid, $nodeQuery, $orderObjects, $slugs);
                 //if(!$firstTable)
                 //    $firstTable = $table;
                 //if(!$firstTableID)
                 //    $firstTableID = $tableid;
                 $elementid = $element->getElementID();
                 $elements[$elementid] = $element;
                 $queries[] = array('query' => $query, 'elementid' => $elementid, 'tableid' => $tableid, 'table' => $table, 'db' => $db);
                 $tableInfo = null;
             }
             $tableToSlugs = null;
             $connectionCouplet = null;
         }
         $connectionCouplets = null;
         $moreThan1Table = count($queries) > 1;
         $qcount = 1;
         foreach ($queries as $qArgs) {
             extract($qArgs);
             $q = clone $query;
             if ($doCounts) {
                 $cq = clone $q;
                 $cq->clearSelect();
                 $cq->ORDERBY(null);
                 //$cq->select("COUNT({$db->quoteIdentifier($firstTable)}.$firstTableID)");
                 $cq->select("COUNT(DISTINCT {$db->quoteIdentifier($table)}.{$tableid})");
                 $s = (string) $cq;
                 //$s = str_replace($firstTable, $table, $s);
                 //$s = str_replace($firstTableID, $tableid, $s);
                 $totalCount += (int) $db->readField($s);
                 if ($co) {
                     // Counts.only
                     continue;
                 }
             }
             $batchOffset = $moreThan1Table ? 0 : $offset;
             $batchLimit = $moreThan1Table ? $this->nodeDatabaseBatchLimit : $limit;
             while ($batchOffset > -1) {
                 $rows = null;
                 $reorderOnce = false;
                 $q->LIMIT($moreThan1Table && $batchLimit > 1 ? $batchLimit + 1 : $batchLimit);
                 $q->OFFSET($batchOffset);
                 $s = (string) $q;
                 //$s = str_replace($firstTable, $table, $s);
                 //$s = str_replace($firstTableID, $tableid, $s);
                 $rows = $db->readAll($s);
                 if (empty($rows)) {
                     $batchOffset = -1;
                     break;
                 }
                 //                    $this->Benchmark->start('pushrows');
                 foreach ($rows as $k => $row) {
                     if ($batchLimit > 1 && $k > $batchLimit - 1) {
                         break;
                     }
                     $row['ElementID'] = $elementid;
                     // if there is no limit, push all rows
                     // if there is only 1 table to aggregate, push all rows
                     // if the index of the current result set is less than the total needed rows, push
                     if (is_null($limit) || !$moreThan1Table || $c < $limit + $offset) {
                         $row['NodeRef'] = new NodeRef($elements[$row['ElementID']], $row['Slug']);
                         $resultingRows[] = $row;
                         ++$c;
                     } else {
                         if ($k >= $limit + $offset) {
                             // done with this table (element)
                             $batchOffset = -1;
                             break 2;
                         }
                         if (!$reorderOnce) {
                             $reorderOnce = true;
                             $resultingRows = $this->NodesHelper->sortNodes($resultingRows, $orderObjects);
                         }
                         $lastRow = $resultingRows[$c - 1];
                         // if this row is before the last row in the order, add it in
                         if (!$this->NodesHelper->compareNodes($lastRow, $row, $orderObjects)) {
                             $row['NodeRef'] = new NodeRef($elements[$row['ElementID']], $row['Slug']);
                             $resultingRows[] = $row;
                             //++$c;
                             $lastRow = null;
                             // else break, we're done with this table (element)
                         } else {
                             //        error_log('stopped at last: '.$lastRow['Slug'].' '.$lastRow['ActiveDate']);
                             //        error_log('stopped at: '.$row['Slug'].' '.$row['ActiveDate']);
                             $batchOffset = -1;
                             $lastRow = null;
                             break 2;
                         }
                     }
                 }
                 //                    $this->Benchmark->end('pushrows');
                 if (!$moreThan1Table && $offset == 0 || count($rows) < $batchLimit + 1) {
                     $batchOffset = -1;
                 } else {
                     $batchOffset = $batchOffset + $batchLimit;
                 }
             }
             $rows = null;
             if ($qcount > 1 && $offset > 0 && $moreThan1Table && !empty($resultingRows)) {
                 //                    error_log('resorting');
                 //                    error_log('needed total: '.($limit+$offset));
                 $resultingRows = $this->NodesHelper->sortNodes($resultingRows, $orderObjects);
                 $resultingRows = $this->NodesHelper->sliceNodes($resultingRows, $limit + $offset, 0);
                 //                    $resultingRows = array_slice($resultingRows, 0, ($limit+$offset));
                 $c = count($resultingRows);
             }
             ++$qcount;
             $qArgs = null;
         }
         $queries = null;
         if (!empty($resultingRows)) {
             if ($offset == 0 && $moreThan1Table) {
                 $resultingRows = $this->NodesHelper->sortNodes($resultingRows, $orderObjects);
             }
             $resultingRows = $this->NodesHelper->sliceNodes($resultingRows, $limit, $offset, $moreThan1Table && $offset > 0);
         }
     }
     if (!empty($resultingRows)) {
         $resultingNodeRefs = ArrayUtils::arrayMultiColumn($resultingRows, 'NodeRef');
         if ($nodeQuery->hasParameter('NodeRefs.only') && StringUtils::strToBool($nodeQuery->getParameter('NodeRefs.only')) == true) {
             $nodeQuery->setResults($resultingNodeRefs);
         } else {
             $results = $this->NodeMultiGetDAO->multiGet($resultingNodeRefs, $nodePartials, $forceReadWrite, $checkPermissions, true);
             $keys = array_map('strval', $resultingNodeRefs);
             $results = ArrayUtils::arraySortUsingKeys($results, $keys);
             $keys = null;
             $resultingNodeRefs = null;
             $nodeQuery->setResults($results);
         }
     }
     if ($doCounts) {
         $nodeQuery->setTotalRecords($totalCount);
     }
     $this->Benchmark->end('findall');
     return $nodeQuery;
 }