PHP TableGateway::getResultSetPrototype方法代码示例

 /**
  * {@inheritDoc}
  */
 protected function doUpdateModel($model)
 {
     if ($id = $this->getModelId($model)) {
         $this->tableGateway->update($this->tableGateway->getResultSetPrototype()->getHydrator()->extract($model), array("{$this->idField} = ?" => $id));
     } else {
         $this->tableGateway->insert($this->tableGateway->getResultSetPrototype()->getHydrator()->extract($model));
     }
 }

 /**
  * @param  Select             $select
  * @param  array              $options   Paginator options
  * @param  ResultSetInterface $resultSet
  * @return array|Paginator
  */
 public function selectMany(Select $select, array $options = array(), ResultSetInterface $resultSet = null)
 {
     if (!$resultSet) {
         $resultSet = $this->tableGateway->getResultSetPrototype();
     }
     if ($options) {
         return $this->initPaginator($select, $options, $resultSet);
     }
     return $this->tableGateway->selectWith($select, $resultSet);
 }

 /**
  * Constructs instance.
  *
  * @param TableGateway                $tableGateway
  * @param Where|\Closure|string|array $where
  * @param null                        $order
  */
 public function __construct(TableGateway $tableGateway, $where = null, $order = null)
 {
     $select = $tableGateway->getSql()->select();
     if ($where) {
         $select->where($where);
     }
     if ($order) {
         $select->order($order);
     }
     $dbAdapter = $tableGateway->getAdapter();
     $resultSetPrototype = $tableGateway->getResultSetPrototype();
     parent::__construct($select, $dbAdapter, $resultSetPrototype);
 }

 /**
  * Constructs instance.
  *
  * @param TableGateway                      $tableGateway
  * @param null|Where|\Closure|string|array  $where
  * @param null|string|array                 $order
  * @param null|string|array                 $group
  * @param null|Having|\Closure|string|array $having
  */
 public function __construct(TableGateway $tableGateway, $where = null, $order = null, $group = null, $having = null)
 {
     $sql = $tableGateway->getSql();
     $select = $sql->select();
     if ($where) {
         $select->where($where);
     }
     if ($order) {
         $select->order($order);
     }
     if ($group) {
         $select->group($group);
     }
     if ($having) {
         $select->having($having);
     }
     $resultSetPrototype = $tableGateway->getResultSetPrototype();
     parent::__construct($select, $sql, $resultSetPrototype);
 }

 public function test__construct()
 {
     // constructor with only required args
     $table = new TableGateway('foo', $this->mockAdapter);
     $this->assertEquals('foo', $table->getTable());
     $this->assertSame($this->mockAdapter, $table->getAdapter());
     $this->assertInstanceOf('Zend\\Db\\TableGateway\\Feature\\FeatureSet', $table->getFeatureSet());
     $this->assertInstanceOf('Zend\\Db\\ResultSet\\ResultSet', $table->getResultSetPrototype());
     $this->assertInstanceOf('Zend\\Db\\Sql\\Sql', $table->getSql());
     // injecting all args
     $table = new TableGateway('foo', $this->mockAdapter, $featureSet = new Feature\FeatureSet(), $resultSet = new ResultSet(), $sql = new Sql($this->mockAdapter, 'foo'));
     $this->assertEquals('foo', $table->getTable());
     $this->assertSame($this->mockAdapter, $table->getAdapter());
     $this->assertSame($featureSet, $table->getFeatureSet());
     $this->assertSame($resultSet, $table->getResultSetPrototype());
     $this->assertSame($sql, $table->getSql());
     // constructor expects exception
     $this->setExpectedException('Zend\\Db\\TableGateway\\Exception\\InvalidArgumentException', 'Table name must be a string or an instance of Zend\\Db\\Sql\\TableIdentifier');
     new TableGateway(null, $this->mockAdapter);
 }

 /**
  * {@inheritdoc}
  */
 public function __invoke(ContainerInterface $container, $requestedName, array $options = null)
 {
     $config = $this->config[$requestedName];
     $dbAdapter = $container->get(isset($config['adapter']) ? $config['adapter'] : 'db');
     if (isset($config['schema'])) {
         $config['table'] = new TableIdentifier($config['table'], $config['schema']);
     }
     $featureSet = new FeatureSet();
     $featureSet->addFeature(new CommonCallFeature($config['primary']));
     if (isset($config['invokable'])) {
         $config['class'] = $config['invokable'];
     }
     if (isset($config['class'])) {
         if (!class_exists($config['class'])) {
             throw new \RuntimeException("Class '{$config['class']}' not found ");
         }
         /** @var \Zend\Db\TableGateway\TableGateway $table */
         $table = new $config['class']($config['table'], $dbAdapter, $featureSet);
     } else {
         $table = new TableGateway($config['table'], $dbAdapter, $featureSet);
     }
     if (isset($config['row'])) {
         if ($config['row'] === true) {
             $config['row'] = 'Zend\\Db\\RowGateway\\RowGateway';
         }
         if (is_string($config['row'])) {
             if (!class_exists($config['row'])) {
                 throw new \RuntimeException("Class '{$config['row']}' not found ");
             }
             $rowGatewayPrototype = new $config['row']($config['primary'], $config['table'], $dbAdapter, $table->getSql());
         } elseif (is_object($config['row'])) {
             $rowGatewayPrototype = $config['row'];
         } else {
             throw new \InvalidArgumentException('Error row argument');
         }
         $table->getResultSetPrototype()->setArrayObjectPrototype($rowGatewayPrototype);
     }
     return $table;
 }

 public function fetchRawSql($sql)
 {
     return $this->tableGateway->getResultSetPrototype()->set($this->executeRawSql($sql));
 }

 /**
  *
  * @return TableEntitySetInterface
  */
 public function getItemSetProto()
 {
     return $this->tableGateway->getResultSetPrototype();
 }