Edit Report a Bug

    Connections and Connection management

    Connections are established by creating instances of the PDO base class. It doesn't matter which driver you want to use; you always use the PDO class name. The constructor accepts parameters for specifying the database source (known as the DSN) and optionally for the username and password (if any).

    Example #1 Connecting to MySQL

    <?php
    $dbh     = new PDO('mysql:host=localhost;dbname=test', $user, $pass);
    ?>

    If there are any connection errors, a PDOException object will be thrown. You may catch the exception if you want to handle the error condition, or you may opt to leave it for an application global exception handler that you set up via set_exception_handler().

    Example #2 Handling connection errors

    <?php
    try {
    $dbh = new PDO('mysql:host=localhost;dbname=test', $user, $pass);
    } catch (    PDOException $e) {
    // attempt to retry the connection after some timeout for example
    }

    Warning

    Just like any other exception, PDOException could be caught either explicitly, via a catch statement, or implicitly via set_exception_handler(). Otherwise, the default behaviour of converting an uncaught exception to a E_FATAL_ERROR will occur. The fatal error will contain a backtrace that can leak connection details. As such, the php.ini option display_errors should be set to 0 on a production server.

    Upon successful connection to the database, an instance of the PDO class is returned to your script. The connection remains active for the lifetime of that PDO object. To close the connection, you need to destroy the object by ensuring that all remaining references to it are deleted—you do this by assigning null to the variable that holds the object. If you don't do this explicitly, PHP will automatically close the connection when your script ends.

    Note: If there are still other references to this PDO instance (such as from a PDOStatement instance, or from other variables referencing the same PDO instance), these have to be removed also (for instance, by assigning null to the variable that references the PDOStatement).

    Example #3 Closing a connection

    <?php
    $dbh     = new PDO('mysql:host=localhost;dbname=test', $user, $pass);
    // use the connection here
    $sth = $dbh->query('SELECT * FROM foo');

    // and now we're done; close it
    $sth = null;
    $dbh = null;
    ?>

    Many web applications will benefit from making persistent connections to database servers. Persistent connections are not closed at the end of the script, but are cached and re-used when another script requests a connection using the same credentials. The persistent connection cache allows you to avoid the overhead of establishing a new connection every time a script needs to talk to a database, resulting in a faster web application.

    Example #4 Persistent connections

    <?php
    $dbh     = new PDO('mysql:host=localhost;dbname=test', $user, $pass, array(
    PDO::ATTR_PERSISTENT => true
    ));
    ?>

    The value of the PDO::ATTR_PERSISTENT option is converted to bool (enable/disable persistent connections), unless it is a non-numeric string, in which case it allows to use multiple persistent connection pools. This is useful if different connections use incompatible settings, for instance, different values of PDO::MYSQL_ATTR_USE_BUFFERED_QUERY.

    Note:

    If you wish to use persistent connections, you must set PDO::ATTR_PERSISTENT in the array of driver options passed to the PDO constructor. If setting this attribute with PDO::setAttribute() after instantiation of the object, the driver will not use persistent connections.

    Note:

    If you're using the PDO ODBC driver and your ODBC libraries support ODBC Connection Pooling (unixODBC and Windows are two that do; there may be more), then it's recommended that you don't use persistent PDO connections, and instead leave the connection caching to the ODBC Connection Pooling layer. The ODBC Connection Pool is shared with other modules in the process; if PDO is told to cache the connection, then that connection would never be returned to the ODBC connection pool, resulting in additional connections being created to service those other modules.

    add a note add a note

    User Contributed Notes 13 notes

    up
    178
    cappytoi at yahoo dot com
    10 years ago
    Using PHP 5.4.26, pdo_pgsql with libpg 9.2.8 (self compiled). As usual PHP never explains some critical stuff in documentation. You shouldn't expect that your connection is closed when you set $dbh = null unless all you do is just instantiating PDO class. Try following:

    <?php
    $pdo     = new PDO('pgsql:host=192.168.137.1;port=5432;dbname=anydb', 'anyuser', 'pw');
    sleep(5);
    $stmt = $pdo->prepare('SELECT * FROM sometable');
    $stmt->execute();
    $pdo = null;
    sleep(60);
    ?>

    Now check your database. And what a surprise! Your connection hangs for another 60 seconds. Now that might be expectable because you haven't cleared the resultset.

    <?php
    $pdo     = new PDO('pgsql:host=192.168.137.160;port=5432;dbname=platin', 'cappytoi', '1111');
    sleep(5);
    $stmt = $pdo->prepare('SELECT * FROM admin');
    $stmt->execute();
    $stmt->closeCursor();
    $pdo = null;
    sleep(60);
    ?>

    What teh heck you say at this point? Still same? Here is what you need to do to close that connection:

    <?php
    $pdo     = new PDO('pgsql:host=192.168.137.160;port=5432;dbname=platin', 'cappytoi', '1111');
    sleep(5);
    $stmt = $pdo->prepare('SELECT * FROM admin');
    $stmt->execute();
    $stmt->closeCursor(); // this is not even required
    $stmt = null; // doing this is mandatory for connection to get closed
    $pdo = null;
    sleep(60);
    ?>

    PDO is just one of a kind because it saves you to depend on 3rd party abstraction layers. But it becomes annoying to see there is no implementation of a "disconnect" method even though there is a request for it for 2 years. Developers underestimate the requirement of such a method. First of all, doing $stmt = null  everywhere is annoying and what is most annoying is you cannot forcibly disconnect even when you set $pdo = null. It might get cleared on script's termination but this is not always possible because script termination may delayed due to slow client connection etc.

    Anyway here is how to disconnect forcibly using postgresql:

    <?php
    $pdo     = new PDO('pgsql:host=192.168.137.160;port=5432;dbname=platin', 'cappytoi', '1111');
    sleep(5);
    $stmt = $pdo->prepare('SELECT * FROM admin');
    $stmt->execute();
    $pdo->query('SELECT pg_terminate_backend(pg_backend_pid());');
    $pdo = null;
    sleep(60);
    ?>

    Following may be used for MYSQL: (not guaranteed)
    KILL CONNECTION_ID()
    up
    9
    d dot bergloev at gmail dot com
    7 years ago
    I would please advice people who talk about database port in reference with socket files to please read up about what a socket file is. TCP/IP uses ports, a socket file however is a direct pipe line to your database. So no, you should not replace localhost with local ip if you use a different port on your database server, because the socket file has nothing to do with your TCP/IP setup. And whenever possible, using the local socket file is much faster than establishing new TCP/IP connections on each request which is only meant for remote database servers.
    up
    17
    jak dot spalding at gmail dot com
    13 years ago
    Just thought I'd add in and give an explanation as to why you need to use 127.0.0.1 if you have a different port number.

    The mysql libraries will automatically use Unix sockets if the host of "localhost" is used. To force TCP/IP you need to set an IP address.
    up
    11
    ogierschelvis at gmail dot com
    8 years ago
    As http://stackoverflow.com/questions/17630772/pdo-cannot-connect-remote-mysql-server points out; sometimes when you want to connect to an external server like this:

    <?php
    $conn     = new PDO('mysql:host=123.4.5.6;dbname=test_db;port=3306','username','password');
    ?>

    it will fail no matter what. However if you put a space between mysql: and host like this:

    <?php
    $conn     = new PDO('mysql: host=123.4.5.6;dbname=test_db;port=3306','username','password');
    ?>

    it will magically work. I'm not sure if this applies in all cases or server setups. But I think it's worth mentioning in the docs.
    up
    3
    Moshe Dolev
    6 years ago
    Please note that you cannot use persistent connections to create temporary tables in mysql/mariadb.
    Tables you create using a statement like "create temporary table TABLE1 ..." are destroyed only when the mysql session ends (not php session !). This never happens if you use a persistent connection.
    If you create a temporary table on a persistent connection, the table will live even after the php script ends. The next php script that will try to issue the same create temporary table statement, will receive an error.
    IMHO, this fact makes persistent connections quite useless.
    up
    16
    neville at whitespacers dot com
    15 years ago
    To avoid exposing your connection details should you fail to remember to catch any exception thrown by the PDO constructor you can use the following class to implicitly change the exception handler temporarily.

    <?php

    Class SafePDO extends PDO {

            public static function     exception_handler($exception) {
                    // Output the exception details
                    die('Uncaught exception: ', $exception->getMessage());
            }

            public function     __construct($dsn, $username='', $password='', $driver_options=array()) {

                    // Temporarily change the PHP exception handler while we . . .
                    set_exception_handler(array(__CLASS__, 'exception_handler'));

                    // . . . create a PDO object
                    parent::__construct($dsn, $username, $password, $driver_options);

                    // Change the exception handler back to whatever it was before
                    restore_exception_handler();
            }

    }

    // Connect to the database with defined constants
    $dbh = new SafePDO(PDO_DSN, PDO_USER, PDO_PASSWORD);

    ?>
    up
    9
    dan dot franklin at pearson dot com
    16 years ago
    Note that you can specify a port number with "port=####", but this port number will be ignored if the host is localhost.  If you want to connect to a local port other than the default, use host=127.0.0.1 instead of localhost.
    up
    5
    edsanhu at gmail dot com
    9 years ago
    For being able to retrieve information from the db in utf-8 the connection assignment has to add to the dsn `charset=utf8`:

    <?php
    $dbh     = new PDO('mysql:host=localhost;dbname=test;charset=utf8', $user, $pass);
    ?>
    up
    0
    antony at harrisretail dot co dot uk
    4 years ago
    It's not possible to use a persistent connection and to extend the PDOStatement class to add methods to the standard class. This means that you cannot do:

    <?php
      $dbh     = new PDO('mysql:host=localhost;dbname=test', $user, $pass, array(PDO::ATTR_PERSISTENT => true));
          $dbh->setAttribute(PDO::ATTR_STATEMENT_CLASS, array('MyPDOStatement', array($this)));
    ?>

    This results in an error:

    Fatal error: Uncaught exception 'PDOException' with message 'SQLSTATE[HY000]: General error: PDO::ATTR_STATEMENT_CLASS cannot be used with persistent PDO instances
    up
    1
    thz at plista dot com
    11 years ago
    If you are using PHP 5.4 and later, you can no longer use persistent connections when you have your own database class that derives from the native PDO object. If you do, you will get segmentation faults during the PHP process shutdown.

    Please see this bug report for more information: https://bugs.php.net/bug.php?id=63176
    up
    -3
    me+nospam at tati dot pro
    7 years ago
    If you want to keep connection after fork exit, you can kill with SIGKILL forked process.

    <?php
    $dbh     = new PDO('pgsql:host=localhost;dbname=test', $user, $pass);
    $pid = pcntl_fork();
    if(    $pid == 0){
                // forked process 'll exit immediately
                exit;
    }
    sleep(1);
    $statement = $dbh->query('select 1');
    var_dump($statement);
    ?>
    Result: false

    <?php
    $dbh     = new PDO('pgsql:host=localhost;dbname=test', $user, $pass);
    $pid = pcntl_fork();
    if(    $pid == 0){
                // use sigkill to close process
                register_shutdown_function(function(){
                        posix_kill(getmypid(), SIGKILL);
            });
                // forked process 'll exit immediately
                exit;
    }
    sleep(1);
    $statement = $dbh->query('select 1');
    var_dump($statement);
    ?>
    Result: object(PDOStatement)#3 (1) {
      ["queryString"]=>
      string(8) "select 1"
    }
    up
    -5
    alvaro at demogracia dot com
    13 years ago
    On connection errors, the PDO constructor seems to do two things no matter your PDO::ATTR_ERRMODE setting:

    1. Trigger a warning
    2. Throw a PDOException

    If you set the PDO::ATTR_ERRMODE parameter, it will only take effect on further operations.
    up
    -63
    paulo dot sistema at gmail dot com
    7 years ago
    Hello guys!
    Has anyone used the ORACLE WALLET feature in PHP or Java?

    https://docs.oracle.com/middleware/1213/wls/JDBCA/oraclewallet.htm#JDBCA596

    I would like to know how to implement it because I can not implement. We use PDO + PHP in all applications and now there is this demand of the DBA.

    Thank you
    add a note add a note
    To Top