PHP PDO-MYSQL : How to use database connection across different classes

Question

I'm kinda new to PDO with MYSQL, here are my two files:

I have a connection class that I use to connect to the database:

class connection{

private $host = 'localhost';
private $dbname = 'devac';
private $username = 'root';
private $password ='';  

public $con = '';

function __construct(){

    $this->connect();   

}

function connect(){

    try{

        $this->con = new PDO("mysql:host=$this->host;dbname=$this->dbname",$this->username, $this->password);
        $this->con->setAttribute(PDO::ATTR_ERRMODE,PDO::ERRMODE_EXCEPTION);


    }catch(PDOException $e){

        echo 'We\'re sorry but there was an error while trying to connect to the database';
        file_put_contents('connection.errors.txt', $e->getMessage().PHP_EOL,FILE_APPEND);

    }
}   
}

I have an account_info class that i use to query the data from the database:

class account_info{


function getAccountInfo(){

    $acc_info = $this->con->prepare("SELECT * FROM account_info");
    $acc_info->execute();

    $results = $acc_info->fetchAll(PDO::FETCH_OBJ);

    foreach ($results as $key) {
        $results->owner_firstname;

    }
}       


}

I include both these files in my index.php page:

include_once 'classes/connection.class.php';
include_once 'classes/accountinfo.class.php';

$con = new connection();
$info = new account_info();
$info->getAccountInfo();

I just cant get it to work I'm not getting any output, I think it has something to do with the scope, but I don't know the correct why to fix it as I'm new to this PDO and OOP stuff. Thanks in advance.

Answer 1

Solution 1

Replace class account_info { with class account_info extends connection {

Replace

$con = new connection();
$info = new account_info();

with

$info = new account_info();

and it should work.

Solution 2 (suggested)

I highly suggest you to solve your problem with dependency injection in this case. Just replace your account class with:

class account_info {

    private $con;

    public function __construct(connection $con) {
        $this->con = $con->con;
    }

    public function getAccountInfo(){

        $acc_info = $this->con->prepare("SELECT * FROM account_info");
        $acc_info->execute();

        $results = $acc_info->fetchAll(PDO::FETCH_OBJ);

        foreach ($results as $key) {
            $results->owner_firstname;
        }
    }       

}

and use it in index.php like this:

include_once 'classes/connection.class.php';
include_once 'classes/accountinfo.class.php';

$con = new connection();
$info = new account_info($con);
$info->getAccountInfo();

Explanation

As a general good rule: always specify the scope keyword for functions (public, protected or private).

The first solution is called inheritance and what we basically did was extending the account class with the connection class in order to inherit all the methods and properties from the connection class and easily use them. In this case you have to watch out for naming conflicts. I suggest you to take a look at the class inheritance in the PHP manual.

The second solution is called dependency injection and it is a wildly encouraged design pattern that makes your classes accept other classes in their constructor in order to explicitly define the class dependency tree (in this case account depend from connection and without the connection we can't make account work).

Another, of thousands of possible solution, would be the one that someone posted below which is a design pattern called Singleton. However that patter has been reevaluated recently as anti-pattern and should not be used.

Answer 2

A common method is to use a singleton pattern in your database class.

Something like this:

class connection {

   private static $hInstance;

   public static function getInstance() {
     if (!(self::$hInstance instanceof self)) {
         self::$hInstance = new self();
     }

     return self::$hInstance;
   }

   /* your code */
}

Then, you can simply use

$database = connection::getInstance(); 
$database->con->prepare(....)

etc