Class Utilization

[[deleted]]

Am I missing something about classes?

I want to totally seperate my project into modules, for which a set of standard classes apply for general routines.

NOTE:each class also has its own include..

database class contains:
custom database function: DBQuery($sql)

error class contains:
function for database errors: errorDB($diedata)

within DBQuery I perform the execution of $sql and return the result set to the user, and if a bad query (or connection) call errorDB and pass the appropriate data for errorDB to deal with.

now do I:
1. define a new class 'error', and define a new class 'database' and pass each classes object via the function call (poor modular approach.)
2. define a new class 'database' and within the function errorDB define a new class error to be called? (I want some functions such as errorDB within lots of functions, executing an include for the error class on each query will create a large load overhead).
3. a method I have not found yet, and would love to know.. any ideas?

cheers in advance.

[laserlight]

Actually, why not make errorDB part of the DBQuery class?
Effectively, every instance of the DBQuery class needs 1 errorDB object to work with it.
At the same time, errorDB doesnt seem intended to provide any other error handling functionality, does it?

[[deleted]]

and that involves extends?

If that is the case i pressume database extends error ?
if you could drop me a few simple lines on how this would work I would appreciate it (doesn't need to be syntax, just methodogy would be great).

ta!

[ahundiak]

You really don't want the database class to extend the error class since a database is not an error.

So you have two classes.

CDatabaseError
{
  /* All kinds of wonderful logging and error processing routines */
}

CDatabase
{
  var $dbError = null;

  function query($sql)
  {
    /* Execute the query */
    $result = mysql_query($sql);
    if (!mysql_errno()) return $result;

/* An error */
return $this->error($sql);
  }
  function error($sql)
  {
    /* Get the error object */
    if ($this->dbError === null) $this->dbError =& new CDatabaseError();

/* Pass it the problem info */
$dbError->logError($sql);

/* I usually just die but I suppose you could try to recover from the error */
die();
  }
}

I would not worry about the overhead of including the CDatabaseError class. Use require_once to ensure all classes only get loaded once. You could try to include the CDatabaseError file from inside of the CDatabase.error method but I think you may run into scope issues.

[laserlight]

There is no need to use inheritance here.

The thing is, unless your error class is truly a generic one, creating 2 classes doesnt make sense.
An error from a database query is a property of the database handling mechanism.
You can thus create a class that has a function that deals with errors from the DB along with other functions to handle the DB.

On the other hand, if you have a class that deals with all sorts of errors on your site, be it from databases, from file handling, etc, then it makes more sense to use it alongside the DB handling class, like what ahundiak suggests.

[[deleted]]

Cheers for the help, i've been working on other things and not had chance to give this a go yet.