PHP SelectInterface::execute方法代码示例

 /**
  * Executes the query and returns the result.
  *
  * @return int|array
  *   Returns the query result as entity IDs.
  */
 protected function result()
 {
     if ($this->count) {
         return $this->sqlQuery->countQuery()->execute()->fetchField();
     }
     // Return a keyed array of results. The key is either the revision_id or
     // the entity_id depending on whether the entity type supports revisions.
     // The value is always the entity id.
     return $this->sqlQuery->execute()->fetchAllKeyed();
 }

 public function execute()
 {
     // By calling preExecute() here, we force it to preprocess the extender
     // object rather than just the base query object.  That means
     // hook_query_alter() gets access to the extended object.
     if (!$this->preExecute($this)) {
         return NULL;
     }
     return $this->query->execute();
 }

 /**
  * Implementation of MigrateSource::performRewind().
  *
  * We could simply execute the query and be functionally correct, but
  * we will take advantage of the PDO-based API to optimize the query up-front.
  */
 protected function initializeIterator()
 {
     $this->prepareQuery();
     $high_water_property = $this->migration->get('highWaterProperty');
     // Get the key values, for potential use in joining to the map table.
     $keys = array();
     // The rules for determining what conditions to add to the query are as
     // follows (applying first applicable rule)
     // 1. If the map is joinable, join it. We will want to accept all rows
     //    which are either not in the map, or marked in the map as NEEDS_UPDATE.
     //    Note that if high water fields are in play, we want to accept all rows
     //    above the high water mark in addition to those selected by the map
     //    conditions, so we need to OR them together (but AND with any existing
     //    conditions in the query). So, ultimately the SQL condition will look
     //    like (original conditions) AND (map IS NULL OR map needs update
     //      OR above high water).
     $conditions = $this->query->orConditionGroup();
     $condition_added = FALSE;
     if (empty($this->configuration['ignore_map']) && $this->mapJoinable()) {
         // Build the join to the map table. Because the source key could have
         // multiple fields, we need to build things up.
         $count = 1;
         $map_join = '';
         $delimiter = '';
         foreach ($this->getIds() as $field_name => $field_schema) {
             if (isset($field_schema['alias'])) {
                 $field_name = $field_schema['alias'] . '.' . $field_name;
             }
             $map_join .= "{$delimiter}{$field_name} = map.sourceid" . $count++;
             $delimiter = ' AND ';
         }
         $alias = $this->query->leftJoin($this->migration->getIdMap()->getQualifiedMapTableName(), 'map', $map_join);
         $conditions->isNull($alias . '.sourceid1');
         $conditions->condition($alias . '.source_row_status', MigrateIdMapInterface::STATUS_NEEDS_UPDATE);
         $condition_added = TRUE;
         // And as long as we have the map table, add its data to the row.
         $n = count($this->getIds());
         for ($count = 1; $count <= $n; $count++) {
             $map_key = 'sourceid' . $count;
             $this->query->addField($alias, $map_key, "migrate_map_{$map_key}");
         }
         if ($n = count($this->migration->get('destinationIds'))) {
             for ($count = 1; $count <= $n; $count++) {
                 $map_key = 'destid' . $count++;
                 $this->query->addField($alias, $map_key, "migrate_map_{$map_key}");
             }
         }
         $this->query->addField($alias, 'source_row_status', 'migrate_map_source_row_status');
     }
     // 2. If we are using high water marks, also include rows above the mark.
     //    But, include all rows if the high water mark is not set.
     if (isset($high_water_property['name']) && ($high_water = $this->migration->getHighWater()) !== '') {
         if (isset($high_water_property['alias'])) {
             $high_water = $high_water_property['alias'] . '.' . $high_water_property['name'];
         } else {
             $high_water = $high_water_property['name'];
         }
         $conditions->condition($high_water, $high_water, '>');
         $condition_added = TRUE;
     }
     if ($condition_added) {
         $this->query->condition($conditions);
     }
     return new \IteratorIterator($this->query->execute());
 }

 /**
  * Executes a select query while making sure the database table exists.
  *
  * @param \Drupal\Core\Database\Query\SelectInterface $query
  *   The select object to be executed.
  *
  * @return \Drupal\Core\Database\StatementInterface|null
  *   A prepared statement, or NULL if the query is not valid.
  *
  * @throws \Exception
  *   Thrown if the table could not be created or the database connection
  *   failed.
  */
 protected function safeExecuteSelect(SelectInterface $query)
 {
     try {
         return $query->execute();
     } catch (\Exception $e) {
         // If there was an exception, try to create the table.
         if ($this->ensureTableExists()) {
             return $query->execute();
         }
         // Some other failure that we can not recover from.
         throw $e;
     }
 }