PHP Connection::close方法代碼示例

 public function shutdown()
 {
     if ($this->connection->isTransactionActive()) {
         $this->rollback();
     }
     $this->connection->close();
 }

 /**
  * @return Connection
  */
 public function getConnection()
 {
     if (false === $this->connection->ping()) {
         $this->connection->close();
         $this->connection->connect();
     }
     return $this->connection;
 }

 private function singleImport($config, OutputInterface &$output, $entity_key = null)
 {
     $this->connection = $this->connectionFactory->createConnection($config['database']);
     $this->connection->getConfiguration()->getSQLLogger(null);
     if ($entity_key) {
         if (!isset($config['maps'][$entity_key])) {
             throw new \Exception("Entity alias not found: " . $entity_key);
         }
         $map = $config['maps'][$entity_key];
         if (!$this->container->has($map['old_data']['service_id'])) {
             throw new \Exception("Service not exists: " . $map['old_data']['service_id']);
         }
         $result = $this->importEntity($map);
         $output->writeln("<info>Total " . count($result) . " {$entity_key} imported </info>");
     } else {
         foreach ((array) $config['maps'] as $key => $map) {
             if (!$this->container->has($map['old_data']['service_id'])) {
                 throw new \Exception("Service not exists: " . $map['old_data']['service_id']);
             }
             $offset = 0;
             do {
                 $result = $this->importEntity($map);
                 $output->writeln("<info>Total " . count($result) . " {$key} imported </info>");
                 if (!$result) {
                     break;
                 }
                 $offset++;
                 $this->setOffset($offset);
             } while (true);
         }
     }
     $this->connection->close();
 }

 protected function pingIt(Connection $con)
 {
     if ($con->ping() === false) {
         $con->close();
         $con->connect();
     }
     return $con;
 }

 /**
  * Retrieves hte index database.
  *
  * @return Connection
  */
 public function getConnection()
 {
     if (!$this->connection) {
         $isNewDatabase = !file_exists($this->databasePath);
         $configuration = new Configuration();
         $this->connection = DriverManager::getConnection(['driver' => 'pdo_sqlite', 'path' => $this->databasePath], $configuration);
         $outOfDate = null;
         if ($isNewDatabase) {
             $this->createDatabaseTables($this->connection);
             // NOTE: This causes a database write and will cause locking problems if multiple PHP processes are
             // spawned and another one is also writing (e.g. indexing).
             $this->connection->executeQuery('PRAGMA user_version=' . $this->databaseVersion);
         } else {
             $version = $this->connection->executeQuery('PRAGMA user_version')->fetchColumn();
             if ($version < $this->databaseVersion) {
                 $this->connection->close();
                 $this->connection = null;
                 @unlink($this->databasePath);
                 return $this->getConnection();
                 // Do it again.
             }
         }
     }
     // Have to be a douche about this as these PRAGMA's seem to reset, even though the connection is not closed.
     $this->connection->executeQuery('PRAGMA foreign_keys=ON');
     // Data could become corrupted if the operating system were to crash during synchronization, but this
     // matters very little as we will just reindex the project next time. In the meantime, this majorly reduces
     // hard disk I/O during indexing and increases indexing speed dramatically (dropped from over a minute to a
     // couple of seconds for a very small (!) project).
     $this->connection->executeQuery('PRAGMA synchronous=OFF');
     return $this->connection;
 }

 protected function resetSharedConn()
 {
     if (self::$_sharedConn) {
         self::$_sharedConn->close();
         self::$_sharedConn = null;
     }
 }

 /**
  * This method checks whether the connection is still open or reconnects otherwise.
  *
  * The connection might drop in some scenarios, where the server has a configured timeout and the handling
  * of the result set takes longer. To prevent failures of the dumper, the connection will be opened again.
  */
 public function reconnectIfNecessary()
 {
     if (!$this->connection->ping()) {
         $this->connection->close();
         $this->connect();
     }
 }

 public function tearDown()
 {
     $this->connection->close();
     $this->eventStore = null;
     $this->eventNameResolver = null;
     $this->serializer = null;
     $this->connection = null;
 }

 /**
  * @return Job[]
  */
 public function getAll()
 {
     $this->conn->connect();
     $stmt = $this->conn->query("select * from {$this->table_name}");
     $stmt->setFetchMode(\PDO::FETCH_CLASS, '\\ebussola\\job\\job\\Job');
     $stmt->execute();
     $jobs = $stmt->fetchAll();
     $this->conn->close();
     return $jobs;
 }

 /**
  * close Doctrine Dbal and ORM connection and reset everything to default.
  */
 public function close()
 {
     $this->Conn->close();
     if (is_object($this->EntityManager) && method_exists($this->EntityManager, 'close')) {
         $this->EntityManager->close();
     }
     if (function_exists('gc_collect_cycles')) {
         gc_collect_cycles();
     }
     $this->Conn = '';
     $this->EntityManager = '';
     $this->table_prefix = '';
     $this->table_siteid_prefix = '';
 }

 /**
  * {@inheritDoc}
  */
 public function close($force = false)
 {
     if ($force) {
         parent::close();
         $this->unsetPersistedConnection();
     }
 }

 /**
  * {@inheritDoc}
  */
 public function logout()
 {
     if ($this->loggedIn) {
         $this->loggedIn = false;
         $this->conn->close();
         $this->conn = null;
     }
 }

 public function preTask(Worker $worker, array $options = null)
 {
     if ($worker instanceof DoctrineAwareWorker) {
         if ($this->connection) {
             try {
                 $this->connection->executeQuery('SELECT 1');
             } catch (DBALException $e) {
                 if ($e->getPrevious()->getCode() == "HY000") {
                     $this->logger->info('Reconnecting doctrine', ['e' => $e]);
                     $this->connection->close();
                 } else {
                     throw $e;
                 }
             }
         }
     }
 }

 public function testHeartBeatException()
 {
     $this->setExpectedException('\\RuntimeException', 'Counld not connect to database');
     $this->getDatabaseTester()->getConnection();
     $config1 = new DoctrineConfig($this->connection);
     $this->assertEquals(0, $config1->getMachine());
     $this->connection->close();
     $config1->heartbeat();
 }

 private static final function initializeDatabase()
 {
     if (!self::$dbReused) {
         self::runCommand('doctrine:database:drop', array('--force' => true));
         self::runCommand('doctrine:database:create');
         self::$conn->close();
         self::$conn->connect();
         foreach (self::$dbInitializer->getMigrationFiles() as $file) {
             self::runCommand('dbal:import', array('file' => $file));
         }
     }
 }