PHP Query::find方法代码示例

 /**
  * @param \Cake\Event\Event $event
  * @param \Cake\ORM\Query $query
  * @param \ArrayObject $options
  * @param bool $primary
  * @return void
  */
 public function beforeFind(Event $event, Query $query, ArrayObject $options, $primary)
 {
     if (!$primary && !$this->_config['recursive']) {
         return;
     }
     $field = $this->_config['field'];
     if (!$field) {
         return;
     }
     $query->find('hashed');
     $idField = $this->_primaryKey;
     if ($primary && $field === $idField) {
         $query->traverseExpressions(function ($expression) {
             if (method_exists($expression, 'getField') && ($expression->getField() === $this->_primaryKey || $expression->getField() === $this->_table->alias() . '.' . $this->_primaryKey)) {
                 $expression->setValue($this->decodeHashid($expression->getValue()));
             }
             return $expression;
         });
     }
     if (!$this->_config['recursive']) {
         return;
     }
     foreach ($this->_table->associations() as $association) {
         if ($association->target()->hasBehavior('Hashid') && $association->finder() === 'all') {
             $association->finder('hashed');
         }
     }
 }

 /**
  * Find Matches
  *
  * Assemble a query containing one or more MATCH() AGAINST() clauses
  * @param \Cake\ORM\Query $query Query to modify
  * @param array $options Options for the query
  * @throws SearchableException If keys 'match' or 'against' are not set
  * @throws SearchableException If columns are invalid
  * @return \Cake\ORM\Query
  */
 public function findMatches(Query $query, array $options)
 {
     $conditions = [];
     $options = array_values($options);
     //assemble MATCH() AGAINST() clauses
     foreach ($options as $key => $option) {
         if (!isset($option['match']) || !isset($option['against'])) {
             throw new SearchableException("Keys 'match' and 'against' must be set");
         }
         if ($this->_validateColumns($option['match'])) {
             $conditions[$key] = "MATCH({$option['match']}) AGAINST (:match{$key} ";
             if (isset($option['mode'])) {
                 if (in_array($option['mode'], $this->_modesWhitelist)) {
                     $conditions[$key] .= $option['mode'] . ' ';
                 }
             }
             $conditions[$key] .= ")";
         }
     }
     $query->find('all', ['conditions' => $conditions]);
     //bind params
     foreach ($options as $key => $option) {
         $query->bind(":match{$key}", $option['against']);
     }
     return $query;
 }

 /**
  * Find By Distance using spherical cosine law
  *
  * @param \Cake\ORM\Query $query Query to modify
  * @param array $options Options for the query
  * @throws GeoDistanceInvalidArgumentException If parameters are missing or invalid
  * @return \Cake\ORM\Query
  */
 public function findByDistance(Query $query, array $options)
 {
     // set up parameters
     $this->_validateOptions($options);
     $latitude = $options['latitude'];
     $longitude = $options['longitude'];
     $radius = $options['radius'];
     if (isset($options['units']) && !empty($options['units'])) {
         $units = $options['units'];
     } else {
         $units = $this->_config['units'];
     }
     $earthRadius = $this->_getEarthRadius($units);
     // construct query
     $sphericalCosineSql = "(:earth_radius * ACOS(\n            COS(RADIANS(:latitude)) *\n            COS(RADIANS({$this->_config['latitudeColumn']})) *\n            COS( RADIANS({$this->_config['longitudeColumn']}) - RADIANS(:longitude) ) +\n            SIN(RADIANS(:latitude)) *\n            SIN(RADIANS({$this->_config['latitudeColumn']}))\n        ) )";
     $connection = $query->connection();
     if ($connection->driver() instanceof Mysql) {
         $distance = "ROUND({$sphericalCosineSql}, 3)";
     } elseif ($connection->driver() instanceof Postgres) {
         $distance = "ROUND( CAST({$sphericalCosineSql} AS numeric), 3)";
     }
     $queryOptions = ['fields' => ['distance' => $distance], 'order' => ['distance ASC'], 'conditions' => ["{$distance} <= :radius"]];
     $query->find('all', $queryOptions)->autoFields(true)->bind(':earth_radius', $earthRadius, 'integer')->bind(':latitude', $latitude, 'float')->bind(':longitude', $longitude, 'float')->bind(':radius', $radius, 'float');
     return $query;
 }

 /**
  * Find all tasks grouped by project
  * 
  * @param Query $query
  * @param type $options
  * @return Query
  */
 public function findTasksByProject(Query $query, $options = [])
 {
     $options += ['where' => NULL];
     $query->find('list', ['groupField' => 'project_id']);
     $query->where($options['where']);
     return $query;
 }

 public function init()
 {
     parent::init();
     // 1. Not all fixtures want to use the dev db.
     if (is_null($this->tableName)) {
         return;
     }
     // 2. We need to do this to ensure that the tables really do use the connection to the
     // dev db.
     TableRegistry::remove($this->tableName);
     $table = TableRegistry::get($this->tableName, ['connection' => ConnectionManager::get('dev')]);
     //if(!is_null($this->joinTableName)) {
     //TableRegistry::remove($this->joinTableName);
     //$n=TableRegistry::get($this->joinTableName, ['connection' => ConnectionManager::get('fixture')]);
     //}
     // 3. Now build the query to retrieve the source records
     $query = new Query(ConnectionManager::get('dev'), $table);
     $query->find('all');
     //if(!is_null($this->order)) $query->order($this->order);
     //if(!is_null($this->joinTableName)) $query->leftJoin($this->joinTableName,'semesters.id = sections.semester_id');
     //$c=$query->count();
     // 4. Copy the records
     /* @var \Cake\ORM\Entity $record */
     foreach ($query as $record) {
         $this->records[] = $record->toArray();
     }
     // 5. Do this again to ensure that the table uses the 'test' connection.
     TableRegistry::remove($this->tableName);
     TableRegistry::get($this->tableName, ['connection' => ConnectionManager::get('test')]);
     //if(!is_null($this->joinTableName)) {
     //TableRegistry::remove($this->joinTableName);
     //TableRegistry::get($this->joinTableName, ['connection' => ConnectionManager::get('test')]);
     //}
 }

 /**
  * FindOptions method
  *
  * @param Query $query   query
  * @param array $options options
  *
  * @return array
  */
 public function findOptions(Query $query, array $options)
 {
     $typeMissions = $query->find('all')->toArray();
     $typeOptions = [];
     foreach ($typeMissions as $typeMission) {
         $typeOptions[$typeMission->id] = $typeMission->getName();
     }
     return $typeOptions;
 }

 /**
  * {@inheritdoc}
  *
  * @param \Cake\ORM\Query $query Query.
  * @param array $options Options.
  * @return \Cake\ORM\Query
  */
 public function findKv(Query $query, array $options)
 {
     return $query->find('list', ['keyField' => 'path', 'valueField' => 'value', 'groupField' => 'namespace'])->formatResults(function ($results) {
         $resultSet = $results->toArray();
         if (isset($resultSet[''])) {
             $resultSet += $resultSet[''];
             unset($resultSet['']);
         }
         return $resultSet;
     });
 }

 /**
  * Attaches comments to each entity on find operation.
  *
  * @param \Cake\Event\Event $event The event that was triggered
  * @param \Cake\ORM\Query $query The query object
  * @param array $options Additional options as an array
  * @param bool $primary Whether is find is a primary query or not
  * @return void
  */
 public function beforeFind(Event $event, $query, $options, $primary)
 {
     if ($this->_enabled && $query->count() > 0) {
         $pk = $this->_table->primaryKey();
         $tableAlias = Inflector::underscore($this->_table->alias());
         $query->contain(['Comments' => function ($query) {
             return $query->find('threaded')->contain(['Users'])->order($this->config('order'));
         }]);
         if ($this->config('count') || isset($options['comments_count']) && $options['comments_count'] === true) {
             $query->formatResults(function ($results) use($pk, $tableAlias) {
                 return $results->map(function ($entity) use($pk, $tableAlias) {
                     $entityId = $entity->{$pk};
                     $count = TableRegistry::get('Comment.Comments')->find()->where(['entity_id' => $entityId, 'table_alias' => $tableAlias])->count();
                     $entity->set('comments_count', $count);
                     return $entity;
                 });
             });
         }
     }
 }

 /**
  * Login and submit a PUT request to a $url that is expected to update
  * a given record. Then redirect to a given $redirect_url, read the updated record
  * from the $table and return it to the caller.
  *
  * @param int $user_id The user to login as.
  * @param String $url The url to send the request to.
  * @param array $post_data
  * @param String $redirect_url The url to redirect to, after the update.
  * @param \Cake\ORM\Table $table The table to receive the new record.
  * @return \Cake\ORM\Entity The newly added record, as read from the db.
  */
 protected function genericEditPutProlog($user_id, $url, $post_data, $redirect_url, $table)
 {
     $connection = ConnectionManager::get('test');
     $query = new Query($connection, $table);
     // Retrieve the record with the lowest id.
     $originalRecord = $query->find('all')->order(['id' => 'ASC'])->first();
     $edit_id = $originalRecord['id'];
     $this->fakeLogin($user_id);
     $this->put($url . '/' . $edit_id, $post_data);
     $this->assertResponseSuccess();
     // 2xx, 3xx
     $this->assertRedirect($redirect_url);
     // Now retrieve that 1 record and send it back.
     $query = new Query($connection, $table);
     return $query->find('all')->where(['id' => $edit_id])->first();
 }

 /**
  * Find all comments related to a specific content
  * @param string $ref Model linked with comments
  * @param int $ref_id ID of the content linked with the comments
  * @param array $options
  * @return \Cake\ORM\Query
  * @todo  Supprimer les commentaires inline : si le code est suffisamment clair cela se lit tout seul, sinon séparer en sous méthodes protected
  */
 public function findRelated(Query $query, array $options)
 {
     // We had the conditions to find linked comments only
     // We need to retrieve User information
     if (!isset($options['contain']['Users'])) {
         $select = Configure::read('Plugin.Comments.users');
         unset($select['className']);
         $select[] = 'Users.id';
         $select = array_values($select);
         $options['contain'][] = 'Users';
         $options['select'][] = $select;
         $options['select'] = current($options['select']);
     }
     if (Configure::read('Plugin.Comments.subcomments')) {
         $options['select'][] = 'Comments.parent_id';
         $comments = $query->find('threaded')->select($options['select'])->contain($options['contain']);
         return $comments;
     }
     $comments = $query->find('all')->select($options['select'])->contain($options['contain'])->orderDesc('Comments.id');
     return $comments;
 }

 /**
  * Formats entities to set hidden fields
  *
  * @param Event $event
  * @param Query $query
  * @return Query
  */
 public function beforeFind(Event $event, Query $query)
 {
     if (!$this->_buildAuthorization()) {
         return $query;
     }
     /**
      * Apply field visibility and accessibility
      */
     $notVisible = $this->_getNotVisibleFields();
     $query->formatResults(function ($results) use($notVisible) {
         return $results->map(function ($row) use($notVisible) {
             if (isset($row) && $row instanceof Entity) {
                 $row->hiddenProperties(array_merge($row->hiddenProperties(), $notVisible));
             }
             return $row;
         });
     });
     /**
      * Apply finders
      */
     $finders = array_diff($this->_getFinders(), $this->_getUnauthorizedFinders());
     foreach ($finders as $finder) {
         $query->find($finder);
     }
     return $query;
 }

 /**
  * Decrypts value after every find operation ONLY IF it was added to the
  * implemented events.
  *
  * @param \Cake\Event\Event $event Event.
  * @param \Cake\ORM\Query $query Query.
  * @param \ArrayObject $options Options.
  * @param bool $primary Whether or not this is the root query or an associated query.
  * @return void
  */
 public function beforeFind(Event $event, Query $query, ArrayObject $options, $primary)
 {
     $query->find('decrypted');
 }

 /**
  * Allows you to do a $table->find('sluggedList') and get an array of [slug]=>name instead of id=>name
  * @param Query $query
  * @param array $options
  * @return Query
  */
 public function findSluggedList(Query $query, array $options)
 {
     $config = $this->config();
     return $query->find('list', ['keyField' => $config['field']]);
 }

 public function findFemaleRatio(Query $query, $options = [])
 {
     $allManagers = $this->find()->select($query->func()->count('*'));
     return $query->find('female')->select(['female_ratio' => $query->newExpr($query->func()->count('*'))->add($allManagers)->type('/')]);
 }

 public function findInRegionalGroups(Query $query)
 {
     $query->find('inContinentGroups')->formatResults(function ($results) {
         return $results->map(function ($continent) {
             return collection($continent)->groupBy('region');
         });
     });
     return $query;
 }