/** * @param string $identity * @return EventDescriptor[] */ public function find(string $identity) : array { $cursor = $this->collection->find([$this->identityField => $identity]); return array_map(function (BSONDocument $eventData) : EventDescriptor { return EventDescriptor::reconstructFromArray($eventData->getArrayCopy()); }, $cursor->toArray()); }
/** * @param QueryInterface $query * @param ModelInterface $model * @return ModelListInterface * @throws NotSupportedFilterException */ public function find(QueryInterface $query, ModelInterface $model) { $queryArray = array(); foreach ($query->getFilters() as $filter) { if (!in_array(get_class($filter), self::$supportedFilters)) { throw new NotSupportedFilterException(sprintf('%s filter is not supported or unknown.', get_class($filter))); } $queryArray[$filter->getFieldName()] = $filter->getValue(); } $options = array(); if ($query->getLimit() !== null) { $options['limit'] = $query->getLimit(); } if ($query->getOffset() !== null) { $options['skip'] = $query->getOffset(); } $list = new ModelList(); $cursor = $this->collection->find($queryArray, $options); /** @var \MongoDB\Model\BSONDocument $doc */ foreach ($cursor as $doc) { $docArray = (array) $doc; unset($docArray['_id']); /** @var ModelInterface $item */ $item = new $model(); $item->loadData($docArray); if ($item instanceof SavableModelInterface) { $item->markAsStored(); } $list->addListItem($item); } return $list; }
/** * @param string $sagaType * @param array $associationValue * @return string[] */ public function find(string $sagaType, array $associationValue) : array { $sagas = $this->collection->find(['type' => $sagaType, 'associations' => $associationValue]); return array_map(function (BSONDocument $sagaData) : string { $sagaDataArray = $sagaData->getArrayCopy(); return $sagaDataArray['identity']; }, $sagas->toArray()); }
public function getItems($offset, $itemCountPerPage) { $cursor = $this->collection->find([], ['skip' => $offset, 'limit' => $itemCountPerPage]); $items = []; foreach ($cursor as $item) { $items[] = $this->convertItemToArray($item); } return $items; }
public function find($filter = [], $options = []) { $collectionName = $this->collection->getCollectionName(); $serialisedQuery = json_encode(['$query' => $filter, '$options' => $options]); Yii::trace("Executing find: {$serialisedQuery}", 'mongoyii\\Collection'); if ($this->client->enableProfiling) { $token = "mongoyii\\{$collectionName}.find({$serialisedQuery})"; Yii::beginProfile($token, 'mongoyii\\Collection.find'); } $res = $this->collection->find($filter, $options); if ($this->client->enableProfiling) { Yii::endProfile($token, 'mongoyii\\Collection.find'); } return $res; }
public function readList($model, $query, $fields = array(), $sortFields = array(), $limit = 0, $skip = 0) { $projection = array(); foreach ($fields as $field) { $projection[$field] = true; } $options = array('projection' => $projection); if (count($sortFields) > 0) { $options['sort'] = $sortFields; } if ($limit > 0) { $options['limit'] = $limit; } if ($skip > 0) { $options['skip'] = $skip; } $cursor = $this->_collection->find($query, $options); $model->totalCount = $this->_collection->count($query); $model->entries = array(); $ctr = 0; foreach ($cursor as $item) { $id = strval($item['_id']); $item[$this->_idKey] = $id; unset($item['_id']); $model->entries[] = $item; $ctr++; } $model->count = $ctr; }
/** * {@inheritdoc} */ public function find($filter = [], array $options = []) { $event = $this->startQueryLogging(__FUNCTION__, $filter, null, $options); $result = parent::find($filter, $options); $this->logger->logQuery($event); return $result; }
/** * @param array $filter * @param array $options * * @return \Traversable */ public function find(array $filter = [], array $options = []) { $cursor = $this->collection->find($filter, $options); $cursor->setTypeMap(['root' => 'array', 'document' => 'array', 'array' => 'array']); foreach ($cursor as $values) { (yield $this->hydrator->hydrate($values)); } }
/** * Find ONe or several documents */ public function find($filter = [], array $options = [], $multiple = true) { if ($multiple === true) { return parent::find($filter, $options); } else { return parent::findOne($filter, $options); } }
/** * @param array $criteria * @param int $offset * @param int $limit * @return Document[] */ public function findBy(array $criteria, int $offset = 0, int $limit = 500) : array { $cursor = $this->collection->find($criteria, ['skip' => $offset, 'limit' => $limit]); return array_map(function (BSONDocument $document) : Document { $data = $document->getArrayCopy(); unset($data['_id']); return $this->converter->arrayToObject($data, $this->documentClass); }, $cursor->toArray()); }
/** * @see DataModelInterface::listBooks */ public function listBooks($limit = 10, $cursor = null) { if ($cursor) { $q = $this->db->find(array('_id' => array('$gt' => new ObjectId($cursor))), array('sort' => array('_id' => 1))); } else { $q = $this->db->find(array(), array('sort' => array('_id' => 1))); } $rows = array(); $last_row = null; $new_cursor = null; foreach ($q as $row) { if (count($rows) == $limit) { $new_cursor = (string) $last_row->_id; break; } array_push($rows, $this->bookToArray($row)); $last_row = $row; } return array('books' => $rows, 'cursor' => $new_cursor); }
/** * {@inheritdoc} */ public function keys() { try { $cursor = $this->collection->find(array(), array('projection' => array('_id' => 1))); $keys = array(); foreach ($cursor as $document) { $keys[] = $document['_id']; } } catch (Exception $e) { throw ReadException::forException($e); } return $keys; }
/** * * @return array */ public function getDatasetRaces() { return $this->cacheGet('pie/races/', function () { $data = [Character::RACE_ASURA => ['y' => 0, 'name' => $this->trans('race.' . Character::RACE_ASURA)], Character::RACE_CHARR => ['y' => 0, 'name' => $this->trans('race.' . Character::RACE_CHARR)], Character::RACE_HUMAN => ['y' => 0, 'name' => $this->trans('race.' . Character::RACE_HUMAN)], Character::RACE_NORN => ['y' => 0, 'name' => $this->trans('race.' . Character::RACE_NORN)], Character::RACE_SYLVARI => ['y' => 0, 'name' => $this->trans('race.' . Character::RACE_SYLVARI)]]; foreach ($this->collection->find() as $row) { if (isset($row['race'])) { foreach ($row['race'] as $key => $value) { $data[$key]['y'] += $value; } } } return array_values($data); }, 4 * 3600); }
public function testAggregateWithOut() { $server = $this->manager->selectServer(new ReadPreference(ReadPreference::RP_PRIMARY)); if (!\MongoDB\server_supports_feature($server, self::$wireVersionForOutOperator)) { $this->markTestSkipped('$out aggregation pipeline operator is not supported'); } $outputCollection = new Collection($this->manager, $this->getDatabaseName(), $this->getCollectionName() . '_output'); $operation = new DropCollection($this->getDatabaseName(), $outputCollection->getCollectionName()); $operation->execute($this->getPrimaryServer()); $this->collection->aggregate([['$sort' => ['x' => 1]], ['$match' => ['_id' => ['$gt' => 1]]], ['$out' => $outputCollection->getCollectionName()]]); $expected = [['_id' => 2, 'x' => 22], ['_id' => 3, 'x' => 33]]; $this->assertSameDocuments($expected, $outputCollection->find()); // Manually clean up our output collection $operation = new DropCollection($this->getDatabaseName(), $outputCollection->getCollectionName()); $operation->execute($this->getPrimaryServer()); }
public function fetch(CriteriaManager $criteriaManager, Collection $collection) : array { $order = 1; $filter = []; $options = ['limit' => self::DEFAULT_LIMIT]; $criteriaManager->doWith(SortCriteria::class, function (SortCriteria $criteria) use(&$options, &$order) { $order = strtolower($criteria->getOrder()) === 'asc' ? 1 : -1; $options['sort'] = []; $options['sort'][$criteria->getField()] = $order; }); $criteriaManager->doWith(SeekCriteria::class, function (SeekCriteria $criteria) use(&$options, &$filter, $order) { $options['limit'] = $criteria->getLimit(); $options['skip'] = 0; if ($criteria->getLastId()) { $lastId = new ObjectID($criteria->getLastId()); if ($order === 1) { $filter['_id'] = ['$gt' => $lastId]; } else { $filter['_id'] = ['$lt' => $lastId]; } } }); $criteriaManager->doWith(ThemeIdCriteria::class, function (ThemeIdCriteria $criteria) use(&$filter) { $filter[sprintf('theme_ids.%s', (string) $criteria->getThemeId())] = ['$exists' => true]; }); $criteriaManager->doWith(QueryStringCriteria::class, function (QueryStringCriteria $criteria) use(&$filter) { if ($criteria->isAvailable()) { $filter['$text'] = ['$search' => $criteria->getQuery()]; } }); $cursor = $collection->find($filter, $options)->toArray(); if (count($cursor)) { $this->profileService->loadProfilesByIds(array_map(function (BSONDocument $document) { return (int) $document['id']; }, $cursor)); return $this->cleanResults(array_map(function (BSONDocument $document) { try { $profile = $this->profileService->getProfileById((int) $document['id']); return array_merge(['_id' => (string) $document['_id']], $profile->toJSON()); } catch (ProfileNotFoundException $e) { return null; } }, $cursor)); } else { return []; } }
/** * Assert that the collections contain equivalent documents. * * This method will resolve references within the expected collection's * documents before comparing documents. Occurrences of "*result" in the * expected collection's documents will be replaced with the actual result. * Occurrences of "*actual" in the expected collection's documents will be * replaced with the corresponding value in the actual collection's document * being compared. * * @param Collection $expectedCollection * @param Collection $actualCollection * @param mixed $actualResult */ private function assertEquivalentCollections($expectedCollection, $actualCollection, $actualResult) { $mi = new MultipleIterator(); $mi->attachIterator(new IteratorIterator($expectedCollection->find())); $mi->attachIterator(new IteratorIterator($actualCollection->find())); foreach ($mi as $documents) { list($expectedDocument, $actualDocument) = $documents; array_walk($expectedDocument, function (&$value) use($actualResult) { if ($value === '*result') { $value = $actualResult; } }); array_walk($expectedDocument, function (&$value, $key) use($actualDocument) { if (!is_string($value)) { return; } if (!strncmp($value, '*actual_', 8)) { $value = $actualDocument[$key]; } }); $this->assertSameDocument($expectedDocument, $actualDocument); } }
/** * @return \MongoDB\Driver\Cursor */ public function getCondensedList() : \MongoDB\Driver\Cursor { return $this->collection->find([], ['projection' => ['feed.publicId' => true, 'feed.title' => true, 'feed.link' => true, 'feed.lastModified' => true, 'url' => true]]); }
public function find($filter = [], array $options = [], $fillModels = true) { return $this->getQueryResult(parent::find($filter, $options), $fillModels); }
public function find(array $query = []) { return $this->collection->find($query); }
/** * @param array $filter * @param array $options * * @return Iterator */ public function find(array $filter = [], array $options = []) { $cursor = $this->collection->find($filter, $options); $cursor->setTypeMap(['root' => 'array', 'document' => 'array', 'array' => 'array']); return new Iterator($cursor, $this->hydrator); }
/** * Execute the query as a fresh "select" statement. * * @param array $columns * @return array|static[] */ public function getFresh($columns = []) { // If no columns have been specified for the select statement, we will set them // here to either the passed columns, or the standard default of retrieving // all of the columns on the table using the "wildcard" column character. if (is_null($this->columns)) { $this->columns = $columns; } // Drop all columns if * is present, MongoDB does not work this way. if (in_array('*', $this->columns)) { $this->columns = []; } // Compile wheres $wheres = $this->compileWheres(); // Use MongoDB's aggregation framework when using grouping or aggregation functions. if ($this->groups or $this->aggregate or $this->paginating) { $group = []; // Add grouping columns to the $group part of the aggregation pipeline. if ($this->groups) { foreach ($this->groups as $column) { $group['_id'][$column] = '$' . $column; // When grouping, also add the $last operator to each grouped field, // this mimics MySQL's behaviour a bit. $group[$column] = ['$last' => '$' . $column]; } // Do the same for other columns that are selected. foreach ($this->columns as $column) { $key = str_replace('.', '_', $column); $group[$key] = ['$last' => '$' . $column]; } } // Add aggregation functions to the $group part of the aggregation pipeline, // these may override previous aggregations. if ($this->aggregate) { $function = $this->aggregate['function']; foreach ($this->aggregate['columns'] as $column) { // Translate count into sum. if ($function == 'count') { $group['aggregate'] = ['$sum' => 1]; } else { $group['aggregate'] = ['$' . $function => '$' . $column]; } } } // When using pagination, we limit the number of returned columns // by adding a projection. if ($this->paginating) { foreach ($this->columns as $column) { $this->projections[$column] = 1; } } // The _id field is mandatory when using grouping. if ($group and empty($group['_id'])) { $group['_id'] = null; } // Build the aggregation pipeline. $pipeline = []; if ($wheres) { $pipeline[] = ['$match' => $wheres]; } if ($group) { $pipeline[] = ['$group' => $group]; } // Apply order and limit if ($this->orders) { $pipeline[] = ['$sort' => $this->orders]; } if ($this->offset) { $pipeline[] = ['$skip' => $this->offset]; } if ($this->limit) { $pipeline[] = ['$limit' => $this->limit]; } if ($this->projections) { $pipeline[] = ['$project' => $this->projections]; } // Execute aggregation return $this->collection->aggregate($pipeline)->toArray(); } elseif ($this->distinct) { // Return distinct results directly $column = isset($this->columns[0]) ? $this->columns[0] : '_id'; // Execute distinct if ($wheres) { $result = $this->collection->distinct($column, $wheres); } else { $result = $this->collection->distinct($column); } return $result; } else { $columns = []; // Convert select columns to simple projections. foreach ($this->columns as $column) { $columns[$column] = true; } // Add custom projections. if ($this->projections) { $columns = array_merge($columns, $this->projections); } $options = []; if ($columns) { $options = ['projection' => $columns]; } // Apply order, offset, limit and hint if ($this->orders) { $options['sort'] = $this->orders; } if ($this->offset) { $options['skip'] = $this->offset; } if ($this->limit) { $options['limit'] = $this->limit; } // Execute query and get $cursor = $this->collection->find($wheres, $options); // Return results as an array with numeric keys return iterator_to_array($cursor, false); } }