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; }
/** * {@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()); }
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; }
/** * @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; }