Can class DBQuery be merged with or extend class DBConnection?

Question

This is question about class relationships not class functionality.

Currently my DBConnection and DBQuery classes are two separate objects

class DBConnection {
    public $dbh;

    __construct() {
       $this->dbh = ... //Establish Connection to db
    }
}

class DBQuery {
    private $dbh;

    __construct(PDO $dbh) {
       $this->dbh= $dbh;
    }

    public runSQLQuery($query) {
       $result = $this->dbh->execute($query);
       $return $result;
    }

}

$dbh = new DBConnection();
$DBQuery = new DBQuery($dbh);
$DBQuery->executeSQLQuery("SELECT * FROM mytable");

So i injecting DBConnection to DBQuery.

1st Question - can i have them merged as one object instead as $dbh is unlikely to be used in any other class than DBQuery. Is this bad practice to group them, why?

class DBQuery {
    private $dbh;

    __construct() {
       $this->dbh = ... //Establish Connection to db
    }


    public runSQLQuery($query) {
       $result = $this->dbh->execute($query);
       $return $result;
    }

}


$DBQuery = new DBQuery();
$DBQuery->executeSQLQuery("SELECT * FROM mytable");

2nd Question - If merging is No-No then, how about extending, it keeps DBConnection class separate so it can be used by another class if needed, class DBQuery simply extends class DBConnection. They seem to be logically related so is this bad practice also, why?

class DBConnection {
    public $dbh;

    __construct() {
       $this->dbh = ... //Establish Connection to db
    }
}

class DBQuery extends DBConnection {

    __construct() {
       parent::__construct()
    }

    public runSQLQuery($query) {
       $result = $this->dbh->execute($query);
       $return $result;
    }

}

$DBQuery = new DBQuery();
$DBQuery->executeSQLQuery("SELECT * FROM mytable");

Bottom line is i am trying to find a solution in which i dont have to instantiate extra objects (it uses too many lines of code) as well as write unneeded lines of code inside classes just to pass one to another for no obvious reason.

P.S. I am familiar with SOLID OOD and Separation of Concerns however i still see no forecast for keeping this two classes separate.

Answer 1

The (correct) decision to separate these two classes has more to do with the Single Responsibility Principal:

Wikipedia:

The single responsibility principle states that every module or class should have responsibility over a single part of the functionality provided by the software, and that responsibility should be entirely encapsulated by the class. All its services should be narrowly aligned with that responsibility. Robert C. Martin expresses the principle as follows:

"A class should have only one reason to change."

Emphasis, mine.

If the way you establish a database connection changes, how should that have any affect on executing a command?

If the way a command is executed against an already established connection, how should that have any affect on the way a connection is opened?

Separating the two allows you to refactor how connections are managed without impacting code already in use for executing queries, and vice-versa.

---

As an addendum, your DbQuery class really should require a DBConnection object in its constructor. This allows for looser coupling between the two classes, as your query object doesn't have to know how to get and open a connection. Something else does that for it.