PHP QueryBuilder::getType方法代码示例

 /**
  * @test
  */
 public function getSQLDelegatesToConcreteQueryBuilder()
 {
     $this->concreteQueryBuilder->getSQL()->shouldBeCalled()->willReturn('UPDATE aTable SET pid = 7');
     $this->concreteQueryBuilder->getType()->willReturn(2);
     // Update Type
     $this->subject->getSQL();
 }

 /**
  * Constructor.
  *
  * @param QueryBuilder $queryBuilder              A DBAL query builder.
  * @param callable     $countQueryBuilderModifier A callable to modifier the query builder to count.
  */
 public function __construct(QueryBuilder $queryBuilder, $countQueryBuilderModifier)
 {
     if ($queryBuilder->getType() !== QueryBuilder::SELECT) {
         throw new InvalidArgumentException('Only SELECT queries can be paginated.');
     }
     if (!is_callable($countQueryBuilderModifier)) {
         throw new InvalidArgumentException('The count query builder modifier must be a callable.');
     }
     $this->queryBuilder = clone $queryBuilder;
     $this->countQueryBuilderModifier = $countQueryBuilderModifier;
 }

 /**
  * Constructor.
  *
  * @param QueryBuilder $queryBuilder A DBAL query builder.
  * @param string $countField Primary key for the table in query. Used in count expression. Must include table alias
  * @param boolean $useDistinct When set to true it'll count the countfield with a distinct in front of it.
  *
  * @api
  */
 public function __construct(QueryBuilder $queryBuilder, $countField, $useDistinct = true)
 {
     if (strpos($countField, '.') === false) {
         throw new LogicException('The $countField must contain a table alias in the string.');
     }
     if (QueryBuilder::SELECT !== $queryBuilder->getType()) {
         throw new LogicException('Only SELECT queries can be paginated.');
     }
     $this->queryBuilder = $queryBuilder;
     $this->countField = $countField;
     $this->useDistinct = $useDistinct;
 }

 public function testEmptyDelete()
 {
     $qb = new QueryBuilder($this->conn);
     $qb2 = $qb->delete();
     $this->assertEquals(QueryBuilder::DELETE, $qb->getType());
     $this->assertSame($qb2, $qb);
 }

 public function testEmptyInsert()
 {
     $qb = new QueryBuilder($this->conn);
     $qb2 = $qb->insert();
     $this->assertEquals(QueryBuilder::INSERT, $qb->getType());
     $this->assertSame($qb2, $qb);
 }

 /**
  * Gets the type of the currently built query.
  *
  * @return integer
  */
 public function getType()
 {
     return $this->queryBuilder->getType();
 }

 /**
  * Gets the type of the currently built query.
  *
  * @return integer
  */
 public function getType()
 {
     return $this->qb->getType();
 }

 /**
  * Counts the number of results that would be returned by the select query provided
  *
  * @param QueryBuilder $qb
  * @return int
  */
 public function getCount(QueryBuilder $qb)
 {
     if ($qb->getType() != QueryBuilder::SELECT) {
         throw new \InvalidArgumentException('Query builder must be a select query');
     }
     $select = $qb->getQueryPart('select');
     $count = (int) $qb->select('COUNT(main.id)')->execute()->fetchColumn();
     $qb->select($select);
     return $count;
 }

 /**
  * Generator for SELECT queries.
  *
  * @param \Doctrine\DBAL\Query\QueryBuilder $qb
  *
  * @return \Iterator
  */
 protected function generator(QueryBuilder $qb)
 {
     if ($qb->getType() !== QueryBuilder::SELECT) {
         self::raise('Generator should be used only with SELECT queries.');
     }
     $stmt = $this->preprocess($qb);
     while ($row = $stmt->fetch(\PDO::FETCH_ASSOC)) {
         $from = $join = [];
         foreach ($row as $key => $value) {
             // if column was preprocessed
             if (false !== ($pos = strpos($key, self::UNIQUE))) {
                 $table = substr($key, 0, $pos);
                 $column = substr($key, $pos + 6);
                 if ($table === $this->table) {
                     $from[$column] = $value;
                 } else {
                     $join[$table][$column] = $value;
                 }
             } else {
                 $from[$key] = $value;
             }
         }
         $class = $this->entity;
         $entity = new $class($from);
         foreach ($join as $table => $data) {
             // every JOIN will be set as a sub-entity
             $class = $this->app['arm'][$this->prefix . $table]->getEntity();
             $entity[$table] = new $class($data);
         }
         (yield $entity);
     }
 }