Best way to query DB across class?

delaware

Hi,

I'm developing a bunch of classes, most of which interact with a database using ADOdb. I've written a simple query wrapper that basically does some error-checking and stuff, and this is what all the other classes actually use.

I'd like to call SQL::connect() in the constructor of the main classes (which include the SQL wrapper) so one connection is available to all of their methods, but that means I have to pass the DB type, hostname, username, password and database name on each instantiation of the main class.

There must be a better way. Any ideas?

Thanks,
Chris

_SuperString

why not make you db connection class extend an other class called something like db_config (which stores db connection information - username, password, etc). That way you only need declare these variables once on the db_conf class. I think this should work.. let me know if this sound right (or wrong).

ahundiak

Unless you need multiple database connections then the "best" way is to simply have one global $db connection variable.

class Whatever
{
function need_some_data()
{
global $db;
// whatever
}
}
I come from a C/C++ background where globals are frowned upon. But because php requires you to explicitly state that a variable is global, I find that they work ok when used in moderation.

But maybe you need multiple connections. In that case, I would assume that each of your classes derives from a base class. The base class constructor is where the connection would be opened.

I would suggest that the base class constructor load in default values for dbhost,username etc. from a config file. The base constructor would have an argument for an array which could be used to override the default values if necessary.

Thus, the individual classes would only need to set those values which need to be overridden.

poseidix

Extending is not the best solution in this situation, globals aren't either cause you should never use global variables like this.

Objects that use your database connection object, should be passed that object on construction like this:

class MyClass
{
  var $db;

  function MyClass(&$db)
  {
     $this->db =& $db;
   }
}

$db = new YourDBConnection;
$db->connect($host, $username, $password, $etc);

$obj = new MyClass($db);

delaware

poseidix - that's basically the way I did it before I used classes, except I globalized $db in each function. But it seems kind of messy to rely on outside resources instead of having classes and methods create their own as they need them.

There are a few other ways I could do it, but I guess I'm looking for the "right" way. The main classes are going to be reused many times, all with different configuration settings, so my concern is ensuring the classes don't break when I try to use them in another project.

Regards,
Chris

poseidix

Well, there is another solution: the Singleton pattern. Using that pattern, you can ensure that there is one globally accessible instance of a class, your db class for example. It works like this:

class DB
{
	function &getInstance()
	{
		static $instance = null;
		if ($instance === null)
		{
			$instance = new DB;
		}

	return $instance;
}	
}

$db =& DB::getInstance();

ahundiak

For the first moderate sized php project I stored $db as an instance variable as poseidix suggests. It works fine though you have to be careful with the & operator. It's easy to forget and you can end up making copies of it without realizing it.

But I only needed one database connection and I didn't really see the use of keeping it as an instance variable. In my opinion, there really is not much difference between using

$this->db->query(); and

global $db;
$db->query();

And I found that I often needed to access $db even when not in an instance class, especially for report generation when multiple tables/classes needed to be combined.

For subsequent projects, I have just used a single global and have not seen any real disadvantages. And remember that while php has some object features, it's not really object oriented.

delaware

That's kind of what I was thinking of, poseidix. I just couldn't work out the details... I think it came from reading about Ruby. Anyway, for simplicity's sake I think I'll use the method you initially described and ahundiak recommends. That's all I really need, and there's no sense in complicating things for the sole reason of doing it "right." As long as it works.

Thanks all, I appreciate the help.