PHP ConnectionManager类代码示例

 function truncate()
 {
     $ConnectionManager = new ConnectionManager();
     $conn = $ConnectionManager->getConnection();
     $stmt = $conn->prepare("TRUNCATE TABLE free_delivery_price");
     $stmt->execute();
     $ConnectionManager->closeConnection($stmt, $conn);
 }

 public function insertarTareaUsuario($tareaUsuario)
 {
     $manager = new ConnectionManager();
     $tareaUsuarioDAO = $manager->getTareaUsuarioDAO();
     try {
         return $tareaUsuarioDAO->insertar($tareaUsuario);
     } finally {
         $manager->close();
     }
 }

 public function buscarTarea($buscar)
 {
     $manager = new ConnectionManager();
     $tareaDAO = $manager->getTareaDAO();
     try {
         $list = $tareaDAO->buscarTareas($buscar);
         return $list;
     } finally {
         $manager->close();
     }
 }

 function getPostalCode($customer_id, $address_no)
 {
     $ConnectionManager = new ConnectionManager();
     $conn = $ConnectionManager->getConnection();
     $stmt = $conn->prepare("SELECT postal_code FROM address WHERE customer_id=? AND address_no=?");
     $stmt->bind_param("si", $customer_id, $address_no);
     $stmt->execute();
     $stmt->bind_result($postal_code);
     $postalcode = '';
     while ($stmt->fetch()) {
         $postalcode = $postal_code;
     }
     $ConnectionManager->closeConnection($stmt, $conn);
     return $postalcode;
 }

 /**
  * Run
  *
  * @return void
  */
 public function run()
 {
     $null = null;
     $this->db = ConnectionManager::getDataSource($this->connection);
     $this->db->cacheSources = false;
     $this->db->begin($null);
     if (!isset($this->args[0]) || !in_array($this->args[0], array('insert', 'remove'))) {
         $this->out(__d('SoftDelete', 'Invalid option'));
         return $this->_displayHelp(null);
     }
     if (!isset($this->args[1])) {
         $this->out(__d('SoftDelete', 'You missed field name.'));
         return $this->_displayHelp(null);
     }
     try {
         $this->_run($this->args[0], $this->args[1]);
         $this->_clearCache();
     } catch (Exception $e) {
         $this->db->rollback($null);
         throw $e;
     }
     $this->out(__d('SoftDelete', 'All tables are updated.'));
     $this->out('');
     return $this->db->commit($null);
 }

 /**
  * Get current connection
  *
  * @return \Doctrine\DBAL\Driver\Connection|\Doctrine\DBAL\Connection|\Blast\Orm\Connection
  */
 public function getConnection()
 {
     if (null === $this->connection) {
         $this->connection = ConnectionManager::getInstance()->get();
     }
     return $this->connection;
 }

 public function load()
 {
     if (Cache::read('qe.dbconfig_' . hash("md5", "qe_dbconfig"), QEResp::QUICK_EMAILER_CACHE)) {
         return true;
     }
     if (Configure::check('qe.dbconfig')) {
         if (!file_exists(APP . 'Config' . DS . 'database.php')) {
             return QEResp::RESPOND(QEResp::ERROR, QuickEmailerErrorDefinitions::NO_DATABASE_CONFIGURED());
         }
         try {
             $datasource = ConnectionManager::getDataSource(Configure::read('qe.dbconfig'));
             if ($datasource->connected) {
                 $this->CheckTables($datasource);
                 Cache::write('qe.dbconfig_' . hash("md5", "qe_dbconfig"), true, QEResp::QUICK_EMAILER_CACHE);
                 return true;
             }
             return QEResp::RESPOND(QEResp::ERROR, QuickEmailerErrorDefinitions::NO_DATABASE_CONFIGURED());
         } catch (Exception $e) {
             $excep_message = QuickEmailerResponseHandler::AddExceptionInfo(QuickEmailerErrorDefinitions::NO_DATABASE_CONFIGURED(), $e);
             //TODO: Log errors
             return QEResp::RESPOND(QEResp::ERROR, $excep_message);
         }
     } else {
         return QEResp::RESPOND(QEResp::ERROR, QuickEmailerErrorDefinitions::NO_DATABASE_CONFIGURED());
     }
 }

 /**
  * Override Model::delete, because it would block deleting when
  * useTable = false and no records exists
  *
  * @param <type> $id
  * @param <type> $cascade
  * @return <type>
  */
 function delete($id = null, $cascade = true)
 {
     if (!empty($id)) {
         $this->id = $id;
     }
     $id = $this->id;
     if ($this->beforeDelete($cascade)) {
         $db =& ConnectionManager::getDataSource($this->useDbConfig);
         if (!$this->Behaviors->trigger($this, 'beforeDelete', array($cascade), array('break' => true, 'breakOn' => false))) {
             return false;
         }
         $this->_deleteDependent($id, $cascade);
         $this->_deleteLinks($id);
         $this->id = $id;
         if (!empty($this->belongsTo)) {
             $keys = $this->find('first', array('fields' => $this->__collectForeignKeys()));
         }
         if ($db->delete($this)) {
             if (!empty($this->belongsTo)) {
                 $this->updateCounterCache($keys[$this->alias]);
             }
             $this->Behaviors->trigger($this, 'afterDelete');
             $this->afterDelete();
             $this->_clearCache();
             $this->id = false;
             $this->__exists = null;
             return true;
         }
     }
     return false;
 }

 /**
  * Constructor.
  *
  * @access public
  */
 public function __construct()
 {
     parent::__construct();
     // Setup Search Engine Connection
     $this->db = ConnectionManager::connectToIndex();
     $_SESSION['no_store'] = true;
 }

 public function execute()
 {
     if (empty($this->connection)) {
         $this->connection = $this->DbConfig->getConfig();
     }
     $this->out('Generating Proxy classes');
     $dm = ConnectionManager::getDataSource($this->connection)->getDocumentManager();
     $metadatas = $dm->getMetadataFactory()->getAllMetadata();
     $metadatas = MetadataFilter::filter($metadatas, isset($this->params['filter']) ? $this->params['filter'] : null);
     // Process destination directory
     $destPath = empty($this->params['destPath']) ? $dm->getConfiguration()->getHydratorDir() : $this->params['destPath'];
     if (!is_dir($destPath)) {
         mkdir($destPath, 0777, true);
     }
     $destPath = realpath($destPath);
     if (!file_exists($destPath)) {
         throw new \InvalidArgumentException(sprintf("Proxies destination directory '<info>%s</info>' does not exist.", $destPath));
     } else {
         if (!is_writable($destPath)) {
             throw new \InvalidArgumentException(sprintf("Proxies destination directory '<info>%s</info>' does not have write permissions.", $destPath));
         }
     }
     if (count($metadatas)) {
         foreach ($metadatas as $metadata) {
             $this->out(sprintf('Processing document "<info>%s</info>"', $metadata->name));
         }
         // Generating Proxies
         $dm->getHydratorFactory()->generateHydratorClasses($metadatas, $destPath);
         // Outputting information message
         $this->out(sprintf('Hydrator classes generated to "<info>%s</info>"', $destPath));
     } else {
         $this->out('No Metadata Classes to process.');
     }
 }

 static function configure()
 {
     if (empty($_COOKIE['selenium'])) {
         return;
     }
     $cookie = $_COOKIE['selenium'];
     App::import('Model', 'ConnectionManager', false);
     ClassRegistry::flush();
     Configure::write('Cache.disable', true);
     $testDbAvailable = in_array('test', array_keys(ConnectionManager::enumConnectionObjects()));
     $_prefix = null;
     if ($testDbAvailable) {
         // Try for test DB
         restore_error_handler();
         @($db =& ConnectionManager::getDataSource('test'));
         set_error_handler('simpleTestErrorHandler');
         $testDbAvailable = $db->isConnected();
     }
     // Try for default DB
     if (!$testDbAvailable) {
         $db =& ConnectionManager::getDataSource('default');
     }
     $_prefix = $db->config['prefix'];
     $db->config['prefix'] = $cookie . '_';
     ConnectionManager::create('test_suite', $db->config);
     $db->config['prefix'] = $_prefix;
     // Get db connection
     $db =& ConnectionManager::getDataSource('test_suite');
     $db->cacheSources = false;
     ClassRegistry::config(array('ds' => 'test_suite'));
 }

 /**
  * Truncates all tables and loads fixtures into db
  *
  * @return void
  * @access public
  */
 function main()
 {
     if (!empty($this->args)) {
         if ($this->args[0] == 'chmod') {
             return $this->chmod();
         }
         $fixtures = $this->args;
         foreach ($fixtures as $i => $fixture) {
             $fixtures[$i] = APP . 'tests/fixtures/' . $fixture . '_fixture.php';
         }
     } else {
         App::import('Folder');
         $Folder = new Folder(APP . 'tests/fixtures');
         $fixtures = $Folder->findRecursive('.+_fixture\\.php');
     }
     $db = ConnectionManager::getDataSource('default');
     $records = 0;
     foreach ($fixtures as $path) {
         require_once $path;
         $name = str_replace('_fixture.php', '', basename($path));
         $class = Inflector::camelize($name) . 'Fixture';
         $Fixture =& new $class($db);
         $this->out('-> Truncating table "' . $Fixture->table . '"');
         $db->truncate($Fixture->table);
         $Fixture->insert($db);
         $fixtureRecords = count($Fixture->records);
         $records += $fixtureRecords;
         $this->out('-> Inserting ' . $fixtureRecords . ' records for "' . $Fixture->table . '"');
     }
     $this->out(sprintf('-> Done inserting %d records for %d tables', $records, count($fixtures)));
 }

 public function truncateModel($name)
 {
     $model = ClassRegistry::init(array('class' => $name, 'ds' => 'test'));
     $table = $model->table;
     $db = ConnectionManager::getDataSource('test_suite');
     $db->truncate($table);
 }

 public function setUp()
 {
     $this->Model = ClassRegistry::init('Country');
     $this->db = ConnectionManager::getDataSource('test');
     $this->skipIf(!$this->db instanceof Mysql, 'The subquery test is only compatible with Mysql.');
     parent::setUp();
 }

 public function health()
 {
     App::Import('ConnectionManager');
     $MPSearch = ConnectionManager::getDataSource('MPSearch');
     $elasticSearch = $MPSearch->API->cluster()->health();
     $this->set(array('elasticSearch' => $elasticSearch, '_serialize' => array('elasticSearch')));
 }