Singleton v Single Instance DB Connection in PHP

KISS

Don't make things more complex than they are, of course this is just my opinion, but as I see it you are building a complex solution for a problem that someone else says might exist is some cases. Php is not multi threaded so there goes one of the biggest arguments overboard. (in very rare-occasions it might be)

I'm using singletons for my database connections for about 15 years now and never ever had a problem with them, I do play around with different connections having one singleton handle several connection instances, but whatever... it works great and everyone that looks at the code.. understands it directly. I'm not using globals because they can be overwritten and are kind of hard to predict (when it holds the correct object, and when/why they don't)

Use OOP to make your code cleaner, easier to work with and more flexible. Don't use it to fix problems that aren't there and make your code more complex because others tell you to.

An very simple example of a db-connection singleton class handling several different connections.

class singleton{
  private static $_instances=array();

  public static function getInstance($connectionName){
     if(!isset(self::$_instance[$connectionName]){
        self::$_instance[$connectionName]=self::_getConnection($connectionName);
     }
     return self::$_instance[$connectionName];
  }

}

just my 2 cents

Why do you have a factory if you have a singleton? This is needless.

This is a never-ending debate, but I'm advocate of do not use singletons for database connections.

As far as in most applications, you have only one data channel, you can consider your database connection unique, but this might not be always true.

In deed, the effort made to create a singleton database connection is even bigger than just create a regular one.

Also, your class DB is not configurable, therefore, you need to change it when your connection parameters change. And I think DB is a very bad name for this.

I'd rather call this Storage and do something like:

inteface Storage {
    public function insert($container, array $data);
    public function update($container, array $data, $where);
    public function delete($container, $where);
    public function getAll($container);
    public function getOne($identifier);
}

final class PdoStorage implements Storage {
    private $dbh;
    private $dsn;
    private $user;
    private $pswd;

    public function __construct($dsn, $user, $pswd) {
        $this->dsn = $dsn;
        $this->user = $user;
        $this->pswd = $pswd;
    }

    // Lazy Initialization
    private function connect() {
        if ($this->dbh === null) 
            $this->dbh = new PDO($this->dsn, $this->user, $this->pswd);
    }

    public function insert($container, array $data) {
        $this->connect();

        // ... omitted for brevity
    }
}

Now, when you need a database storage, you do:

$someObj = new SomeClass(new PdoStorage(...));

Now you might be wondering if you will need to create an PdoStorage for each single object that depends on it.

The answer is: no!

Now you can use a factory to simplify your life.

class SomeFactory {
    private $defaultStorage;

    public function __construct(Storage $storage) {
        $this->defaultStorage = $storage;
    }

    public function create($type) {
        // Somehow fetches the correct class to instantiate and put it into $class variable , for example... and then

        return new $class($this->defaultStorage); // Or you'd better do this with reflection
    }
}

$factory = new SomeFactory(new PdoStorage(...));
$factory->create('SomeClass');

This way, you can have just one database connector or more if you need.