working on it ...

Filters

Explore Public Snippets

Sort by

Found 393 snippets matching: pdo

    public by DaveMorton modified Apr 2, 2018  623  2  5  1

    connect.php - Database Abstraction Functions

    <?php
    /* 
     *  %[Filename]=[connect.php]%
     * This is a complete set of PDO abstraction functions
     * to make connecting, reading from and writing to a
     * MySQL database faster and easier. It's meant to be
     * used as a snippet in RapidPHP/WeBuilder from Karlis
     * Bluementals, but can easily be used in many other
     * web development IDEs. Items with %[something]% or
     * %[something]=[value]% are replaceable parameters
     * in RapidPHP/WeBuilder and can be swapped out with
     * whatever you like
     */
    
    /* DB Credentials */
    
    $dbh    = '%[Hostname]=[localhost]%';
    $dbn    = '%[DB Name]%';
    $dbu    = '%[Username]=[username]%';
    $dbp    = '%[Password]=[password]%';
    $dbPort = '%[DB Port]=[3306]%';
    
    $db = db_open($dbh, $dbu, $dbp, $dbn, $dbPort);
    
    /**
     * function db_open()
     * Connect to the database
     *
     * @internal param string $dbh    - db host
     * @internal param string $dbu    - db user
     * @internal param string $dbp    - db password
     * @internal param string $dbn    - db name
     * @internal param string $dbPort - db port
     * @return resource $dbConn - the database connection resource
     */
    function db_open($dbh, $dbu, $dbp, $dbn, $dbPort=3306)
    {
        try {
            $dbConn = new PDO("mysql:host=$dbh;dbname=$dbn;charset=utf8", $dbu, $dbp);
            $dbConn->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);
            $dbConn->setAttribute(PDO::ATTR_DEFAULT_FETCH_MODE, PDO::FETCH_ASSOC);
            $dbConn->setAttribute(PDO::MYSQL_ATTR_USE_BUFFERED_QUERY, true);
        }
        catch (Exception $e)
        {
            exit('The application has encountered a problem with connecting to the database. With any luck, the following message will help: ' . $e->getMessage());
        }
        return $dbConn;
    }
    
    /**
     * function db_close()
     * Close the connection to the database
     *
     * @internal param resource $dbConn - the open connection
     *
     * @return null
     */
    function db_close()
    {
        return null;
    }
    
    /*
     * function db_fetch_all
     * Fetches all matching rows of data from the database
     *
     * @param (string) $sql - The SQL query to execute
     * @param (mixed) $params - either an array of placeholder/value pairs, or null, for no parameters
     * @param (string) $file - the path/filename of the file that the function call originated in
     * @param (string) $function - the name of the function that the function call originated in
     * @param (string) $line - the line number of the originating function call
     *
     * @return (mixed) $out - Either the row of data from the DB query, or false, if the query fails
     */
    
    function db_fetch_all($sql, $params = null, $file = 'unknown', $function = 'unknown', $line = 'unknown')
    {
        global $dbConn;
        try
        {
            $sth = $dbConn->prepare($sql);
            ($params === null) ? $sth->execute() : $sth->execute($params);
            return $sth->fetchAll();
        }
        catch (Exception $e)
        {
            //error_log("bad SQL encountered in file $file, line #$line. SQL:\n$sql\n", 3, _LOG_PATH_ . 'badSQL.txt');
            $pdoError = print_r($dbConn->errorInfo(), true);
            $psError  = print_r($sth->errorInfo(), true);
            return false;
        }
    }
    
    /*
     * function db_fetch_row
     * Fetches a single row of data from the database
     *
     * @param (string) $sql - The SQL query to execute
     * @param (mixed) $params - either an array of placeholder/value pairs, or null, for no parameters
     * @param (string) $file - the path/filename of the file that the function call originated in
     * @param (string) $function - the name of the function that the function call originated in
     * @param (string) $line - the line number of the originating function call
     *
     * @return (mixed) $out - Either the row of data from the DB query, or false, if the query fails
     */
    function db_fetch_row($sql, $params = null, $file = 'unknown', $function = 'unknown', $line = 'unknown')
    {
        global $dbConn;
        //error_log(print_r($dbConn, true), 3, _LOG_PATH_ . 'dbConn.txt');
        try
        {
            $sth = $dbConn->prepare($sql);
            ($params === null) ? $sth->execute() : $sth->execute($params);
            $out = $sth->fetch();
            return $out;
        }
        catch (Exception $e)
        {
            //error_log("bad SQL encountered in file $file, line #$line. SQL:\n$sql\n", 3, _LOG_PATH_ . 'badSQL.txt');
            $pdoError = print_r($dbConn->errorInfo(), true);
            $psError  = print_r($sth->errorInfo(), true);
            return false;
        }
    }
    
    /*
     * function db_write
     * Writes and/or updates data to the database
     *
     * @param (string) $sql - The SQL query to execute
     * @param (mixed) $params - either an array of placeholder/value pairs, or null, for no parameters
     * @param (string) $file - the path/filename of the file that the function call originated in
     * @param (string) $function - the name of the function that the function call originated in
     * @param (string) $line - the line number of the originating function call
     *
     * @return (mixed) $out - Either the number of rows affected from the DB query, or false, if the query fails
     */
    
    function db_write($sql, $params = null, $multi = false, $file = 'unknown', $function = 'unknown', $line = 'unknown')
    {
        global $dbConn;
        try
        {
            $sth = $dbConn->prepare($sql);
            switch (true)
            {
                case ($params === null):
                    $sth->execute();
                    break;
                case ($multi === true):
                    foreach ($params as $row)
                    {
                        $sth->execute($row);
                    }
                    break;
                default:
                    $sth->execute($params);
            }
            return $sth->rowCount();
        }
        catch (Exception $e)
        {
            $pdoError = print_r($dbConn->errorInfo(), true);
            $psError  = print_r($sth->errorInfo(), true);
            error_log("bad SQL encountered in file $file, line #$line. SQL:\n$sql\nPDO Error:\n$pdoError\nSTH Error:\n$psError\nEsception Message:\n" . $e->getMessage(), 3, _LOG_PATH_ . 'db_write.txt');
            return false;
        }
    }

    external by NerdmindDE modified Feb 13, 2016  286  0  3  0

    PHP: Eine Einführung in PDO und Prepared Statements

    PHP: Eine Einführung in PDO und Prepared Statements: php-eine-einfuehrung-in-pdo-und-prepared-statements.md
    Die PDO-Klasse ist eine tolle Klasse um Datenbankabfragen gleich viel sicherer zu machen. Wer bisher nur die prozedurale MySQL-Funktion oder objektorientierte MySQLi-Klasse verwendet hat, der muss sich ein kleines bisschen umstellen. PDO hört sich aber komplizierter an als es ist. Ich versuche hier nun mal die PDO-Klasse so gut es geht verständlich zu erklären. PDO ist die Profi-Klasse für sichere Datenbankabfragen. Mit PDO kann man wie mit den anderen beiden Funktionen auf herkömmliche Weise Datenbankabfragen an einen SQL-Server schicken. Der Unterschied ist nur die Syntax des Codes. Damit die Datenbankabfragen auch wirklich sicher und vor SQL-Injections geschützt sind, reicht es nicht aus, die normale `query()`-Methode zu benutzen. Diese eignet sich hervorragend für Abfragen, bei denen **keine** fremden Eingaben in die Abfrage geschrieben werden. Für Abfragen mit fremden Inhalten sollte immer die `prepare()`-Methode verwendet werden.
    
    ## PDO-Verbindung zum SQL-Server herstellen
    Bevor wir Abfragen an den Datenbankserver schicken können, muss natürlich zuerst eine Verbindung aufgebaut werden. Also alles schön der Reihe nach damit auch nichts ausbleibt. PDO kann übrigens nicht wie bei MySQLi objektorientiert und prozedural verwendet werden sondern nur objektorientiert. Deshalb ist es sehr von Vorteil von wenn man bereits Erfahrung mit der Syntax der objektorientierten Programmierung hat. Im folgenden schreiben wir das Konfigurationsarray, bauen die Datenbankverbindung auf und fangen die Exception falls es einen Fehler beim Verbindungsaufbau gab. Im nächsten Abschnitt folgt dann die erste Abfrage an den Datenbankserver.
    
    ~~~
    $dbconfig['host'] = 'localhost';
    $dbconfig['user'] = 'username';
    $dbconfig['base'] = 'database';
    $dbconfig['pass'] = 'password';
    $dbconfig['char'] = 'utf8';
    
    try {
        $pdo = new PDO('mysql:host='.$dbconfig['host'].';dbname='.$dbconfig['base'].';charset='.$dbconfig['char'].';', $dbconfig['user'], $dbconfig['pass']);
    }
    catch(PDOException $e) {
        exit('Unable to connect Database.');
    }
    ~~~
    
    ## PDO-Abfrage mit query() an den SQL-Server
    Da die Datenbankverbindung aufgebaut und das PDO-Objekt instanziert wurde, kann es auch schon mit der ersten simplen Abfrage an die Datenbank los gehen. Im Beispiel frage ich einfach einen Wert von einer fiktiven Tabelle ab und lasse ihn ausgeben. Vorher müssen die Daten natürlich noch gefetcht werden. Beim fetchen kann man sich ein normales Array, ein assoziatives Array, ein Objekt und noch ein paar weitere zurückgeben lassen. Ich verwende jetzt im gesamten Artikel zur Übersichtlichkeit die normale `fetch()`-Methode.
    
    ~~~
    // Wenn ein einziger Datensatz erwartet wird
    $stmt = $pdo->query('SELECT foo FROM bar WHERE id = 1');
    $row = $stmt->fetch();
    echo $row['foo'];
    ~~~
    
    ~~~
    // Wenn mehrere Datensätze erwartet werden
    $stmt = $pdo->query('SELECT foo FROM bar');
    while($row = $stmt->fetch()) {
        echo $row['foo'].'<br />';
    }
    ~~~
    
    Im vorherigen Beispiel wurde eine simple Abfrage einmal mit einem einzigen Datensatz und einmal mit mehreren Datensätzen die zurückgegeben werden, ausgeführt. Allerdings ist diese Methode nicht sicher vor fremden Benutzereingaben. Würde man beispielsweise dort einen Get-Parameter hart reinschreiben, dann wäre dort auf jeden Fall eine SQL-Injection möglich. Diese Abfrageart eigenet sich also nur für Abfragen, bei denen wirklich keine Eingaben von außen in den Query gelangen können.
    
    ## PDO Prepared Statements
    Um zu verhindern das böse Jungs SQL-Injections ausführen, können wir Prepared Statements benutzen. Die `prepare()`-Methode sollte man auch immer dann nutzen, wenn fremde Eingaben mit in den Query geschrieben werden. Bei Prepared Statements wird anstatt der Variable eine *Kennzeichnung* an die entsprechende Stelle des Querys geschrieben. Die SQL-Abfrage wird danach über eine spezielle Methode namens `execute()` an den Server geschickt an die dann ein Array mit den Kennzeichnungen und den tatsächlichen Werten übergeben wird.
    
    ~~~
    $stmt = $pdo->prepare('SELECT foo, bla FROM bar WHERE id = :paramEins AND bla = :paramZwei');
    $array = array(
        ':paramEins' => $_GET['id'],
        ':paramZwei' => $_GET['bla']
    );
    $stmt->execute($array);
    
    while($row = $stmt->fetch()) {
        echo $row['foo'].'<br />';
        echo $row['bla'].'<br />';
    }
    ~~~
    
    Meiner Meinung nach sollte das Beispiel schon verständlich genug sein. Es wird lediglich die Prepare-Methode anstatt der Query-Methode genutzt und um den SQL-Befehl an die Datenbank zu schicken wird Execute benutzt. An `execute()` wird dann ein Array übergeben, das die Kennzeichnungen und die dazugehörigen originalen Daten enthält. Der Rest funktioniert genau so wie ganz oben bereits erklärt.
    
    ## PDO Prepared Statements mit bindParam()
    Ähnlich wie im vorherigen Abschnitt lassen sich mit der `bindParam()`-Methode ebenfalls sichere SQL-Abfragen ausführen. Allerdings ist diese Methode etwas komplizierter. Man kann hier ebenfalls Platzhalter setzen, **muss** aber als zweiten Parameter eine Variable übergeben. Man darf keine Werte direkt als zweiten Parameter übergeben da dies sonst einen **Fatal Error** hervorruft. Als dritten Parameter kann man optional noch einen Datentyp angeben. Und wenn man will auch noch einen vierten vom Typ Integer der die Länge enthält.
    
    ~~~
    $stmt = $pdo->prepare('SELECT * FROM foo WHERE bar = :eins AND bla = :zwei');
    $stmt->bindParam(':eins', $_GET['bar']);
    $stmt->bindParam(':zwei', $_GET['bla']);
    $stmt->execute();
    ~~~
    
    Das gleiche funktioniert aber nicht nur mit selbstdefinierten Platzhaltern sondern auch mit Fragezeichen. Welche Methode man benutzt, bleibt jedem selber überlassen. Aber mit den Fragezeichen wird es ein bisschen übersichtlicher als mit selbstdefinierten Platzhaltern.
    
    ~~~
    $stmt = $pdo->prepare('SELECT * FROM foo WHERE bar = ? AND bla = ?');
    $stmt->bindParam(1, $_GET['bar']);
    $stmt->bindParam(2, $_GET['bla']);
    $stmt->execute();
    ~~~
    
    ## PDO Prepared Statements mit bindValue()
    Diese Methode funktioniert genau so wie die `bindParam()`-Methode. Nur ist man bei der `bindValue()`-Methode nicht gezwungen eine Variable (also eine Referenz) als zweiten Parameter zu übegeben. Man kann hier also einen String oder einen beliebigen anderen Datentyp direkt **hart** als zweiten Parameter übergeben. Außerdem kann man hier keinen vierten Parameter wie bei `bindParam()` übergeben.
    
    ~~~
    $stmt = $pdo->prepare('SELECT * FROM foo WHERE bar = ? AND bla = ?');
    $stmt->bindValue(1, $_GET['bar']);
    $stmt->bindValue(2, $_GET['bla']);
    $stmt->execute();
    ~~~
    
    ## Weiterführende Links
    1. [PHP-Manual | Die PDO-Klasse im Überblick](https://secure.php.net/manual/de/book.pdo.php)
    
    

    external by weierophinney modified Aug 5, 2014  347  0  3  0

    Example of pulling a PDO connection from an existing ZF2 DB adapter in order to seed a ZF\OAuth2\Adapter\PdoAdapter instance.

    Example of pulling a PDO connection from an existing ZF2 DB adapter in order to seed a ZF\OAuth2\Adapter\PdoAdapter instance.: OAuth2PdoAdapterFactory.php
    PHP
    <?php
    
    use ZF\OAuth2\Adapter\PdoAdapter;
    
    class OAuth2PdoAdapterFactory
    {
        public function __invoke($services)
        {
            $db = $services->get('DB\MyDbName');
            if (! $db instanceof Adapter) {
                throw new DomainException('DB\MyDbname is not a Zend\\Db adapter; cannot be used with OAuth2');
            }
    
            $pdo = $db->getDriver()->getConnection()->getResource();
    
            if (! $pdo instanceof Pdo) {
                throw new DomainException('DB\MyDbname is not a PDO-based adapter; cannot be used with OAuth2');
            }
    
            $config = $services->get('Config');
            $oauth2ServerConfig = array();
            if (isset($config['zf-oauth2']['storage_settings']) && is_array($config['zf-oauth2']['storage_settings'])) {
                $oauth2ServerConfig = $config['zf-oauth2']['storage_settings'];
            }
    
            return new OAuth2PdoAdapter($pdo, $oauth2ServerConfig);
        }
    }
    
    

    external by gavrya modified Oct 30, 2016  128  0  2  0

    Our User repository, version 2.0. From the article: PDO for Elegant PHP Database Access, http://www.modernphpbook.com/articles/pdo-for-elegant-php-database-access - Fig 12

    Our User repository, version 2.0. From the article: PDO for Elegant PHP Database Access, http://www.modernphpbook.com/articles/pdo-for-elegant-php-database-access - Fig 12: UserRepository.php
    <?php 
    
    namespace Repository;
    
    use \PDO;
    
    class UserRepository
    {
        private $connection;
        
        public function __construct(PDO $connection = null)
        {
            $this->connection = $connection;
            if ($this->connection === null) {
                $this->connection = new PDO(
                        'mysql:host=localhost;dbname=pdo_example', 
                        'root', 
                        'root'
                    );
                $this->connection->setAttribute(
                    PDO::ATTR_ERRMODE, 
                    PDO::ERRMODE_EXCEPTION
                );
            }
        }
    
        public function find($id)
        {
            $stmt = $this->connection->prepare('
                SELECT "User", users.* 
                 FROM users 
                 WHERE id = :id
            ');
            $stmt->bindParam(':id', $id);
            $stmt->execute();
            
            // Set the fetchmode to populate an instance of 'User'
            // This enables us to use the following:
            //     $user = $repository->find(1234);
            //     echo $user->firstname;
            $stmt->setFetchMode(PDO::FETCH_CLASS, 'User');
            return $stmt->fetch();
        }
    
        public function findAll()
        {
            $stmt = $this->connection->prepare('
                SELECT * FROM users
            ');
            $stmt->execute();
            $stmt->setFetchMode(PDO::FETCH_CLASS, 'User');
            
            // fetchAll() will do the same as above, but we'll have an array. ie:
            //    $users = $repository->findAll();
            //    echo $users[0]->firstname;
            return $stmt->fetchAll();
        }
    
        public function save(\User $user)
        {
            // If the ID is set, we're updating an existing record
            if (isset($user->id)) {
                return $this->update($user);
            }
    
            $stmt = $this->connection->prepare('
                INSERT INTO users 
                    (username, firstname, lastname, email) 
                VALUES 
                    (:username, :firstname , :lastname, :email)
            ');
            $stmt->bindParam(':username', $user->username);
            $stmt->bindParam(':firstname', $user->firstname);
            $stmt->bindParam(':lastname', $user->lastname);
            $stmt->bindParam(':email', $user->email);
            return $stmt->execute();
        }
    
        public function update(\User $user)
        {
            if (!isset($user->id)) {
                // We can't update a record unless it exists...
                throw new \LogicException(
                    'Cannot update user that does not yet exist in the database.'
                );
            }
            $stmt = $this->connection->prepare('
                UPDATE users
                SET username = :username,
                    firstname = :firstname,
                    lastname = :lastname,
                    email = :email
                WHERE id = :id
            ');
            $stmt->bindParam(':username', $user->username);
            $stmt->bindParam(':firstname', $user->firstname);
            $stmt->bindParam(':lastname', $user->lastname);
            $stmt->bindParam(':email', $user->email);
            $stmt->bindParam(':id', $user->id);
            return $stmt->execute();
        }
    }
    
    

    external by yano3 modified Jul 2, 2017  8  0  2  0

    [php: PDO] PDO - PHP Data Objects note. #php

    [php: PDO] PDO - PHP Data Objects note. #php: pdo.md
    ## Overview
    生PHP(5以降)でのDB接続はPDO (php data objects) での接続が推奨される。どんなデータベースを利用していても同じクラスが使えるので、パラメータの変更だけでDB変更に耐えられる。mysql や mysqli は将来的に非推奨となる。
    
    ### mysql_*** 系との違い
    - クラスである
    - エラー時例外を投げる:PDOException
    
    ### まずはこれを読む
    http://qiita.com/mpyw/items/b00b72c5c95aac573b71
    
    ### 実際に使うのはこのあたり
    コメントのつっこみ含め見る
    http://qiita.com/tabo_purify/items/2575a58c54e43cd59630
    
    
    -----------------------------------------------
    
    
    ## Feature ##
    
    ### プリペアドステートメント
    SQLインジェクション対策として有効。(要出典)
    
    ### 返り値のカスタマイズ
    全体を連想配列で → fetch_assoc
    1レコードをオブジェクト(ユーザ定義クラス)で → fetch_class
    
    ### レコードクラス(Entity)の考え方
    テーブル全体をモデルクラスが扱うとき、レコード一行を一オブジェクトとして捉えてメソッドやらプロパティやらもたせたいときがある。そんなときに使うレコードクラスをエンティティクラスと呼ぶ(cake)。PDOでは返り値にユーザ定義暮らすを割り当てられるので有効な考え方。
    
    
    ------------------------------------------------
    
    
    ## Methods for pdo-wrapper
    
    ### BaseModel
    ````````````````````````````````````
    <?php 
    namespace App\Base;
    use App\Component\AccessorReadOnly;
    
    class Model {
      
      use AccessorReadOnly;
      private static $connInfo = null;
      protected $pdo = null;  // pdo-connection instance
      protected $name = null; // class name (or table name)
      protected $entity = null; // row obj name
      private $Config = null;
      private $Controller = null;
      private $Request = null;
      
      public function __construct($objController){
        $this->Controller = $objController;
        $this->Config = $this->Controller->Config;
        $this->Request = $this->Controller->Request;
        if(self::$connInfo){
          $this->initDb();
        }//if
        if(is_null($this->name)){
          // specify) protected $name = 'users_posts';
          // set tablename from classname, 
          // when $name not specify at extended class.
          $this->setDefaultTableName();
        }//if
      }//construct
      
      
      /**
       * Set DataResource Info
       * @param array $connInfo
       */
      public static function setConnectionInfo($connInfo){
        self::$connInfo = $connInfo;
      }//setConnectionInfo
      
    
      /**
       * Initialize PDO
       * @param static self::$connInfo
       * @return $this->pdo = new PDO()
       */
      public function initDb(){
        $dsn = sprintf(
          'mysql:host=%s;dbname=%s;charset=%s',
          self::$connInfo['host'],
          self::$connInfo['dbname'],
          self::$connInfo['charset']
        );
        try{
          $this->pdo = new \PDO($dsn, self::$connInfo['dbuser'], self::$connInfo['password']);
          $this->pdo->setAttribute(\PDO::ATTR_ERRMODE,\PDO::ERRMODE_EXCEPTION);
          $this->pdo->setAttribute(\PDO::ATTR_EMULATE_PREPARES,false);
          $this->pdo->setAttribute(\PDO::ATTR_DEFAULT_FETCH_MODE, \PDO::FETCH_OBJ);
        }catch(PDOException $e){
          $this->pdo = false;
        }//trycatch
      }//initDb
    
    
    
      /**
       * set default table name
       * ex) class -> table
       *   - BlogsModel -> blogs 
       *   - UsersAccountsModel -> users_accounts
       * @link http://qiita.com/genzouw/items/35022fa96c120e67c637
       */
      public function setDefaultTableName(){
        $path = explode('\\', get_class($this));
        $className = array_pop($path);
        $len = strlen($className);
        $tableName = '';
        for($i=0;$i<$len;$i++){
          $char = substr($className, $i, 1);
          $lower = strtolower($char);
          if ($i>0&&$char!=$lower){
            $tableName .= '_';
          }//if
          $tableName .= $lower;
        }//for
        $this->name  = $tableName;
      }//setDefaultTableName
    
    
    
      /**
       * PDO wrapper - find(select)
       * @param str $selector, str $sql, array $binds
       * @return rows
       */  
      public function find($selector,$sql,$binds=[]){
        if(!$this->pdo){ return false; }
        $query = sprintf("SELECT %s FROM %s ", $selector, $this->name);
        $query .= $sql;
        $stmt = $this->pdo->prepare($query);
        foreach((array)$binds as $key => $val){
          $stmt->bindValue(':' . $key, $val);
        }//foreach
        $stmt->execute();
        $stmt->setFetchMode(\PDO::FETCH_CLASS | \PDO::FETCH_PROPS_LATE,"\App\\Model\\Entity\\".ucfirst($this->entity));
        $rows = $stmt->fetchAll();
        return $rows;
      }//find
    
    
      /**
       * PDO-wrapper - insert
       * @param array $binds
       * @return bool $response
       */
      public function insert($binds){
        if(!$this->pdo){ return false; }
        $fields = [];
        $values = [];
        foreach($binds as $key => $val){
          $fields[] = $key;
          $values[] = ':'.$key;
        }//foreach
        $sql = sprintf(
          "INSERT INTO %s (%s) VALUES (%s)", 
          $this->name,
          implode(',', $fields),
          implode(',', $values)
        );
        $stmt = $this->pdo->prepare($sql);
        foreach((array)$binds as $key => $val){
          $stmt->bindValue(':'.$key, $val);
        }//foreach
        $response  = $stmt->execute();
        return $response;        
      }//insert
    
    
      /**
       * PDO-wrapper - update
       * @param str $sql, array $binds
       * @return bool $response
       */
      public function update($sql, $binds=[]){
        if(!$this->pdo){ return false; }
        $query = sprintf(
          "UPDATE %s SET %s", 
          $this->name,
          $sql
        );
        $stmt = $this->pdo->prepare($query);
        foreach((array)$binds as $key => $val){
          $stmt->bindValue(':'.$key, $val);
        }//foreach
        $response  = $stmt->execute();
        return $response;        
      }//update
    
    
      /**
       * PDO-wrapper - delete
       * @param str $sql, array $binds
       * @return bool $response
       */
      public function delete($sql,$binds=[]){
        if(!$this->pdo){ return false; }
        $query = sprintf("DELETE FROM %s %s", $this->name, $sql);
        $stmt = $this->pdo->prepare($query);
        foreach((array)$binds as $key => $val){
          $stmt->bindValue(':' . $key, $val);
        }//foreach
        $response = $stmt->execute();
        return $response;
      }//delete  
    `````````````````````````````````````
    
    
    ### Model 
    ```````````````````````````````````````````````
    <?php 
    namespace App\Model;
    use App\Base\Model;
    
    class Items extends Model {
      
      protected $name = 'items'; // setoff -> running 'setDefaultTableName();'
      protected $entity = 'item'; // entity name
    
    }//class
    ```````````````````````````````````````````````
    
    
    
    
    ### Entity
    `````````````````````````````````````````````````
    <?php 
    namespace App\Model\Entity;
    use App\Base\Entity;
    
    class Item extends Entity {
    
    
      /**
       * numer_format
       */
      public function price() {
        if($this->price){
          return number_format($this->price);
        }else{
          return "";
        }//if
      }//price
      
    }//class
    `````````````````````````````````````````````````
    
    
    ### Controller & View
    ``````````````````````````````````````````````````
    // controller
      public function index(){
        $this->Items = new Items($this);
        $results = $this->Items->find('*','WHERE price > :price LIMIT :limit',[
          'price'=>1000,
          'limit'=>10,
        ]);
        if($results){
          $this->View->setVars('results',$results);
        }//if
      }//function indexAction
      
    // view
          <div class="c-paper">
            <?php foreach((array)$this->getVars('results') as $key => $value): ?>
            <dl class="c-dlist">
              <dt><?php echo "({$key}) {$value->name}" ?></dt>
              <dd>
                <span class="t-color--gray"><?php echo $value->description ?></span><br>
                ¥<?php echo $value->price() ?>-
              </dd>
            </dl>
            <?php endforeach ?>
          </div>
    ``````````````````````````````````````````````````
    
    --------
    
    
    ## TIPS ##
    
    ### Select の 行数 count
    ````````````````
    $sql = 'select count(*) from table where name = :name';
    $stmt = $pdo -> prepare($sql);
    $stmt -> execute(['name' => 'おなまえ']);
    $count = $stmt -> fetchColumn();
    echo $count;
    // fetchAll()の[0][0]と同じ。
    ``````````````````
    
    ### 直前createのid
    create系のexecute()のあとで ```$pdo->lastInsertId()``` で返り値もらってください。
    
    ### 直前executeの作用行数
    ```$pdo->execute()``` のあとに ```$pdo->rowCount()``` でとれます。
    
    ### 基本スニペット
    ````
    public function transaction(){
      $stmt = $this->pdo->prepare(" sql ");
      $stmt->bindValue(
        ":fuga", $fuga, \PDO::PARAM_INT
      );
      $stmt->bindValue(
        ":hoge", $hoge, \PDO::PARAM_STR
      );
      $this->pdo->beginTransaction();
      try {
        $stmt->execute();
        $results = $stmt->fetchAll(); //select
        $this->pdo->commit();
        if($results){
          return $results;
        }else{
          throw new \Exception("Error.", 500);
        }
      } catch (\PDOException $e) {
        $this->pdo->rollback();
        return false;
      }
    }
    ````
    
    
    -------------------------
    
    

    external by Leonir modified Sep 12, 2017  4  0  1  0

    pdo connection example for firebird driver http://www.php.net/manual/en/ref.pdo-firebird.connection.php

    pdo connection example for firebird driver http://www.php.net/manual/en/ref.pdo-firebird.connection.php: pdo_example_firebird.php
    <?php
    $str_conn="firebird:host=localhost;dbname=/var/lib/firebird/2.5/data/employee.fdb;charset=UTF8";
    $dbh = new PDO($str_conn, "sysdba", "masterkey");
    ?>
    
    
    

    external by Niño Roldan modified Aug 31, 2015  160  0  2  0

    Simple and straightforward class to create a PDO connection.

    Simple and straightforward class to create a PDO connection.: Database.php
    <?php
    class Database {           
        private static $datasource='mysql:host=localhost; dbname=db_name';
        private static $username='root';
        private static $password='root';
        private static $db;      
    
        public static function getDB(){ 
          if(!isset(self::$db)){ 
              self::$db=new PDO(self::$datasource,self::$username,self::$password); 
          }
          return self::$db;      
        }
    }
    
    //we can call this class by : 
    //$db = Database::getDB();
    
    

    external by aMadReason modified Jun 26, 2015  148  0  3  0

    Small PHP PDO Connection

    Small PHP PDO Connection : Small PHP PDO Connection
    class DbCon {
        protected $dbname = 'test';
        protected $host = 'localhost';
        protected $user = 'root';
        protected $driver = 'mysql';
        protected $pass = 'root';
    
        public function __construct($dbname, $user = 'root', $pass = '', $host ='localhost', $driver = 'mysql', $charset = 'utf8') {
    
            $this->dbname = $dbname;
            $this->user = $user;
            $this->pass = $user;
            $this->host = $host;
            $this->driver = $driver;
            $this->charset = $charset;
    
       }
    
        public function open() {
            try {
                $con = new \PDO($this->driver.':host='. $this->host.';dbname='.$this->dbname, $this->user, $this->pass,
                array(\PDO::MYSQL_ATTR_INIT_COMMAND => "SET NAMES " . $this->charset));
    
                $con->setAttribute( \PDO::ATTR_ERRMODE, \PDO::ERRMODE_EXCEPTION );
    
                return $con; // returns created instance of PDO
    
            } catch (\PDOException $e) {
                //Output error - would normally log this to error file rather than output to user.
                exit("SQL Connection Error: " . $e->getMessage());
                //echo 'Database connection could not be established';
                die();
            }
        }
    }//end class
    
    

    external by mcywinski modified Jul 22, 2014  102  0  2  0

    CodeIgniter model modified to use PDO Library

    CodeIgniter model modified to use PDO Library: Model.php
    PHP
    class CI_Model {
    
    	/**
    	 * Constructor
    	 *
    	 * @access public
    	 */
    
    	private $pdo = null;
    
    	function __construct()
    	{
    		try
    		{
    	    	$pdo = new PDO('mysql:host=' . MYSQL_LOCALE . ';dbname=' . MYSQL_DB, MYSQL_USER, MYSQL_PASS, 
    			array(PDO::MYSQL_ATTR_INIT_COMMAND => "SET NAMES utf8"));
    		}
    		catch(PDOException $e)
    		{
    			die ('DATABASE CONNECTION ERROR: ' . $e->getMessage());
    		}
    		log_message('debug', "Model Class Initialized");
    	}
    
    	/**
    	 * __get
    	 *
    	 * Allows models to access CI's loaded classes using the same
    	 * syntax as controllers.
    	 *
    	 * @param	string
    	 * @access private
    	 */
    	function __get($key)
    	{
    		$CI =& get_instance();
    		return $CI->$key;
    	}
    }
    
    

    external by Matt Danskine modified Nov 30, 2015  80  0  1  0

    PDO - Create .sql file using PHP and PDO

    PDO - Create .sql file using PHP and PDO: db_backup.php
    <?php
    
    /* 
    	PDO - create .sql file with PHP using PDO.
    	
    	Either include the common.php file (which includes the db connection info), or connect to the db here.
    	
    	Check the first dozen or so following lines for options.
    */
    	include("../common.php");
    
    	//$db = new PDO("mysql:host=$db_hostname;dbname=$db_database; charset=utf8", $db_username, $db_password);
    
    
    
    	//put table names you want backed up in this array.
    	//leave empty to do all
    	$tables = array();
    
    	backup_tables($db, $tables);
    
    
    
    	function backup_tables($db, $tables) {
    
    	$db->setAttribute(PDO::ATTR_ORACLE_NULLS, PDO::NULL_NATURAL );
    
    	//Script Variables
    	$compression = true;
    	$BACKUP_PATH = "db_backups/";
    	$nowtimename = date('Y-m-d H.i.s',time());
    
    
    	//create/open files
    	if ($compression) {
    	$zp = gzopen($BACKUP_PATH.$nowtimename.'.sql.gz', "a9");
    	} else {
    	$handle = fopen($BACKUP_PATH.$nowtimename.'.sql','a+');
    	}
    
    
    	//array of all database field types which just take numbers
    	$numtypes=array('tinyint','smallint','mediumint','int','bigint','float','double','decimal','real');
    
    	//get all of the tables
    	if(empty($tables)) {
    	$pstm1 = $db->query('SHOW TABLES');
    	while ($row = $pstm1->fetch(PDO::FETCH_NUM)) {
    	$tables[] = $row[0];
    	}
    	} else {
    	$tables = is_array($tables) ? $tables : explode(',',$tables);
    	}
    
    	//cycle through the table(s)
    
    	foreach($tables as $table) {
    	$result = $db->query("SELECT * FROM $table");
    	$num_fields = $result->columnCount();
    	$num_rows = $result->rowCount();
    
    	$return="";
    	//uncomment below if you want 'DROP TABLE IF EXISTS' displayed
    	$return.= 'DROP TABLE IF EXISTS `'.$table.'`;';
    
    
    	//table structure
    	$pstm2 = $db->query("SHOW CREATE TABLE $table");
    	$row2 = $pstm2->fetch(PDO::FETCH_NUM);
    	$ifnotexists = str_replace('CREATE TABLE', 'CREATE TABLE IF NOT EXISTS', $row2[1]);
    	$return.= "\n\n".$ifnotexists.";\n\n";
    
    
    	if ($compression) {
    	gzwrite($zp, $return);
    	} else {
    	fwrite($handle,$return);
    	}
    	$return = "";
    
    	//insert values
    	if ($num_rows){
    	$return= 'INSERT INTO `'."$table"."` (";
    	$pstm3 = $db->query("SHOW COLUMNS FROM $table");
    	$count = 0;
    	$type = array();
    
    	while ($rows = $pstm3->fetch(PDO::FETCH_NUM)) {
    
    	if (stripos($rows[1], '(')) {$type[$table][] = stristr($rows[1], '(', true);
    	} else $type[$table][] = $rows[1];
    
    	$return.= "`".$rows[0]."`";
    	$count++;
    	if ($count < ($pstm3->rowCount())) {
    	$return.= ", ";
    	}
    	}
    
    	$return.= ")".' VALUES';
    
    	if ($compression) {
    	gzwrite($zp, $return);
    	} else {
    	fwrite($handle,$return);
    	}
    	$return = "";
    	}
    	$count =0;
    	while($row = $result->fetch(PDO::FETCH_NUM)) {
    	$return= "\n\t(";
    
    	for($j=0; $j<$num_fields; $j++) {
    
    	//$row[$j] = preg_replace("\n","\\n",$row[$j]);
    
    
    	if (isset($row[$j])) {
    
    	//if number, take away "". else leave as string
    	if ((in_array($type[$table][$j], $numtypes)) && (!empty($row[$j]))) $return.= $row[$j] ; else $return.= $db->quote($row[$j]);
    
    	} else {
    	$return.= 'NULL';
    	}
    	if ($j<($num_fields-1)) {
    	$return.= ',';
    	}
    	}
    	$count++;
    	if ($count < ($result->rowCount())) {
    	$return.= "),";
    	} else {
    	$return.= ");";
    
    	}
    	if ($compression) {
    	gzwrite($zp, $return);
    	} else {
    	fwrite($handle,$return);
    	}
    	$return = "";
    	}
    	$return="\n\n-- ------------------------------------------------ \n\n";
    	if ($compression) {
    	gzwrite($zp, $return);
    	} else {
    	fwrite($handle,$return);
    	}
    	$return = "";
    	}
    
    
    
    	$error1= $pstm2->errorInfo();
    	$error2= $pstm3->errorInfo();
    	$error3= $result->errorInfo();
    	echo $error1[2];
    	echo $error2[2];
    	echo $error3[2];
    
    	if ($compression) {
    	gzclose($zp);
    	} else {
    	fclose($handle);
    	}
    	}
    ?>
    
    
    • Public Snippets
    • Channels Snippets