keeping queries out of classes

[coo_t2]

My problem is that I assumed that using the Eclipse "Database" and
"QueryResult" classes was essentially the same as implementing a Dao.
I've seen a lot of discussions on Dao here but thought, "Ah, that's
what I'm doing with eclipse". So I didn't bother to read the Dao stuff
throughly.
I should know by now that assuming things like that is not a good idea.

I don't understand all the code that's been posted above, but I guess
it will eventually sink in. :)

I *do* think I understand the general idea though.


===================

Question regarding codezilla's code:


Do you think it would be ok to change the Dao class a bit to work
with an Eclipse "Database" object.

The Dao constructor might look like:

class Dao {
    
    function Dao(&$dbObj) 
    {    
    // $this->dbObj will replace $this->conn
    // I'll have to go through code that uses $this->conn
    // to work with my Eclipse object.
        $this->dbObj =& $dbObj; 
    } 
}


class BidderDao extends Dao {
    
    function BidderDao(&$dbObj)
    {   parent::Dao($dbObj);
    }
}


-------

$dbObj =& new MyDatabase('dbName', 'hostName');
$dbObj->connect('userName', 'passWord')
$daoObj =& new BidderDao($dbObj); 

thanks,
--ed

[sweatje]

Not sure if your implying '$this->SuperClass();' won't work in my example

Not at all, your method works find for any inherited method (or methods of the child class itself), just wanted to point out the parent:: operator must be available to access overridden methods.

[codezilla]

Ok, cool, then we're saying the same thing.

[codezilla]

Do you think it would be ok to change the Dao class a bit to work with an Eclipse "Database" object.

Absolutely! You'll need to change all the database interaction code in my example since it's quite different from the ECLIPSE classes. Good luck!

[Dr Livingston]

Confused ? I am now But thanks folks, I'll have a read over this thread off-line later and try to remember the number of ways how to use :: Codezilla - Thanks for reminding me about the post I have above on creating an object instance of a class and actually using a class method Oppss ?

[Gilles]

Would it be possible to post DataSource.class.php and ArrayList.class.php so we can run the example ?

[coo_t2]

Would it be possible to post DataSource.class.php and ArrayList.class.php so we can run the example ?

He attached part of his library here:
http://sitepointforums.com/showpost....9&postcount=45

But ArrayList.class.php isn't part of it.
DataSource.class.php is though.

I think that's just the DB portion of his library.

--ed

[Taoism]

For a static method to work, you can not have any references to $this in the method (because there is no instance). Other than that, they work the same (i.e. take parameters, return results, must have the class included before use, etc.).

HTH

<?php
class Foo{
  var $x=1;
  
  echo_x(){
    echo $this->x;
  }
  
  increment(){
    Bar::increment();
  }
}
class Bar{
  increment(){
    $this->x++;
  }
}
$demo=&new Foo();
$demo->echo_x(); //echos 1
$demo->increment();
$demo->echo_x(); //echos 2
?>

The $this reference in the static call above works fine

I know, I know, I am being nitpicky... but I just wanted to point out that it can be used like above.

Cheers,
Keith.

[sweatje]

Appearantly only because the static call is embeded within another classes method where the variable $this is in scope.

Try:

<?php 
error_reporting(E_ALL);

class Foo{
  var $x=1;
  
  function echo_x(){
    echo $this->x;
  }
  
  function increment(){
    Bar::increment();
  }
}
class Bar{
  function increment(){
    $this->x++;
  }
}
$demo=&new Foo();
$demo->echo_x(); //echos 1
$demo->increment();
$demo->echo_x(); //echos 2
Bar::increment();

[Taoism]

Well, I know that... I was just trying to bug you a bit

Cheers,
Keith.

[sweatje]

Actually seems like a PHP bug to me. I don't think the Foo $this should be in scope for the Bar static call oh well, chalk it up to another nuance of my favorite interpreted language

[gzhlon]

Can you post the DataSource and ArrayList classes referenced below so I can get a complete picture of what's happening here.

Thanks

Sounds like you're ready for a Data Access Object (DAO). DAOs are great because you can keep all the SQL necessary for a domain model class isolated in a single DAO class. Generally speaking, you have one DAO class per database table.

Here's some extensive example code for a hypothetical Bidder class that I adapted from my own class library/framework.


Dao.class.php:

require_once('DaoRegistry.class.php');
require_once('DataSource.class.php');
require_once('ArrayList.class.php');

class Dao
{

    var $conn;
    
    function Dao($dsn)
    {
        $this->conn =& DataSource::getConnection($dsn);
    }
    
    function &abstractFind($id)
    {
        $obj =& DaoRegistry::get($this, $id);
        if (is_null($obj))
        {
            $stmt =& $this->conn->prepareStatement($this->findStatement());
            $stmt->setInt(1, $id);
            $rs =& $stmt->executeQuery();
            $rs->next();
            $obj =& $this->load($rs);
        }
        return $obj;
    }
    
    function delete(&$obj)
    {
        if (! is_null($obj))
        {
            $this->doDelete($obj);
        }    
    }
    
    function doDelete(&$obj)
    {
    }
    
    function doInsert(&$obj)
    {
    }
    
    function &doLoad($id, &$rs)
    {
    }
    
    function doUpdate(&$obj)
    {
    }
    
    function find()
    {
    }
    
    function findStatement()
    {
    }
    
    function insert(&$obj)
    {
        if (! is_null($obj))
        {
            $obj->setId($this->doInsert($obj));
            DaoRegistry::put($this, $obj->getId(), $obj);
            return $obj->getId();
        }
    }
    
    function &load(&$rs)
    {
        $id = $rs->getInt('id');
        $obj =& DaoRegistry::get($this, $id);
        if (is_null($obj))
        {
            $obj =& $this->doLoad($id, $rs);
            DaoRegistry::put($this, $obj->getId(), $obj);
        }
        return $obj;
    }
    
    function &loadAll(&$rs)
    {
        $objList =& new ArrayList();
        while ($rs->next())
        {
            $objList->append($this->load($rs));
        }
        return $objList;
    }
    
    function update(&$obj)
    {
        if (! is_null($obj))
        {
            $this->doUpdate($obj);
        }
    }
    
} 

Since this post is already really long I won't inlcude the source for DaoRegistry.class.php, DataSource.class.php, ArrayList.class.php

Usage example:

$dao =& new BidderDao();
$list =& $dao->findForAuctionId($_GET['auction_id']);
$i =& $list->iterator();
while ($i->hasNext())
{
    $bidder =& $i->next();
    // do stuff with $bidder
} 

[Dr Livingston]

...so I can get a complete picture of what's happening here.

I would be interested also to see the complete classes

Many Thanks

[codezilla]

No problem.

class DataSource
{

    var $connections = array();

    function DataSource()
    {
    }


    function &getConnection($dsn)
    {
        $this =& DataSource::_getInstance();
        if (! isset($this->connections[$dsn]))
        {
            include_once('Connection.class.php');
            $url = parse_url($dsn);
            $this->connections[$dsn] =& new Connection(
                (isset($url['scheme']) ? $url['scheme'] : ''),
                (isset($url['host'])   ? $url['host'] : 'localhost') . 
                    (isset($url['port']) ? ':' . $url['port'] : ''),
                (isset($url['path'])   ? substr($url['path'], 1) : ''),
                (isset($url['user'])   ? $url['user'] : ''),
                (isset($url['pass'])   ? $url['pass'] : ''));
        }
        return $this->connections[$dsn];
    }
    

    function &_getInstance()
    {
        static $instance;
        if (is_null($instance))
        {
            $instance = new DataSource();
        }
        return $instance;
    }
    
} 

I don't use ArrayList anymore (in favor of regular ol' arrays), and I've refactored out all references to it, but here it is anyway:

class ArrayList
{

    var $arr;

    function ArrayList()
    {
        if (func_num_args() == 1)
        {
            $this->arr = ArrayList::valueOf(func_get_arg(0));
        }
    }

    function add($index, &$element)
    {
        $this->arr = array_splice($this->arr, $index, 0, array($element));
    }
    
    function addAll($index, &$list)
    {
        $this->arr = array_splice($this->arr, $index, 0, $list->toArray());
    }
    
    function append(&$element)
    {
        $this->arr[] =& $element;
    }
    
    function appendAll(&$list)
    {
        $this->arr = array_merge($this->arr, $list->toArray()); 
    }
    
    function clear()
    {
        unset($this->arr);
        $this->arr = array();
    }
    
    function contains(&$element)
    {
        return in_array($element, $this->arr, TRUE);
    }
    
    function containsAll(&$list)
    {
        foreach ($list->toArray() as $element)
        {
            if (! in_array($element, $this->arr, TRUE))
            {
                return FALSE;
            }
        }
        return TRUE;
    }
    
    function &get($index)
    {
        return $this->arr[$index];
    }
    
    function &getFirst()
    {
        return $this->arr[0];
    }
    
    function &getLast()
    {
        return $this->arr[count($this->arr) - 1];
    }
    
    function indexOf(&$element)
    {
        $index = array_search($element, $this->arr);
        if ($index !== FALSE)
        {
            return $index;
        }
        return -1;
    }
    
    function isEmpty()
    {
        return (count($this->arr) == 0);
    }
    
    function &iterator()
    {
        return $this->listIterator(0);
    }
    
    function lastIndexOf(&$element)
    {
        $pos = array_search($element, array_reverse($this->arr));
        if ($pos !== FALSE)
        {
            return count($this->arr) - 1 - $pos;
        }
        return -1;
    }
    
    function &listIterator($fromIndex = 0)
    {
        include_once('ArrayListIterator.class.php');
        return new ArrayListIterator($this, $fromIndex);
    }
    
    function prepend(&$element)
    {
        array_unshift($this->arr, array($element));
    }
    
    function prependAll(&$list)
    {
        array_unshift($this->arr, $list->toArray());
    }
    
    function &remove($index)
    {
        $element =& $this->arr[$index];
        array_splice($this->arr, $index, 1);
        return $element;
    }
    
    function removeAll(&$list)
    {
        $size = count($this->arr);
        $list = $list->toArray();
        $this->arr = array_diff($this->arr, $list);
        return (count($this->arr) != $size);
    }
    
    function &removeFirst()
    {
        $element =& $this->arr[0];
        array_shift($this->arr);
        return $element;
    }
    
    function &removeLast()
    {
        $element =& $this->arr[$this->size() - 1];
        array_pop($this->arr);
        return $element;
    }
    
    function removeRange($fromIndex, $toIndex)
    {
        array_splice($this->arr, $fromIndex, $toIndex - $fromIndex);
    }
    
    function retainAll(&$list)
    {
        $size = count($this->arr);
        $list = $list->toArray();
        $this->arr = array_intersect($this->arr, $list);
        return (count($this->arr) != $size);
    }
    
    function &set($index, &$element)
    {
        $oldElement =& $this->get($index);
        $this->arr[$index] =& $element;
        return $oldElement;
    }
    
    function size()
    {
        return count($this->arr);
    }
    
    function &subList($fromIndex, $toIndex)
    {
        $fromIndex = (int) $fromIndex;
        $toIndex = (int) $toIndex;
        if ($toIndex < $fromIndex)
        {
            return NULL;
        }
        return new ArrayList(array_slice($this->arr, $fromIndex, $toIndex - $fromIndex));
    }

    function &toArray()
    {
        return $this->arr;
    }

    function valueOf($arg)
    {
        if (is_object($arg) && method_exists($arg, 'toArray'))
        {
            return array_values($arg->toArray());
        }
        return array_values((array) $arg);
    }

} 

[ghurtado]

Just out of curiosity, and even though I suspect that I know the answer, why did you stop using it?

[Dr Livingston]

Also where is the OBJECT class that the ArrayList extends ? Umm...

[codezilla]

Just out of curiosity, and even though I suspect that I know the answer, why did you stop using it?

I actually had classes for all the native data types, but I was persuaded that they introduced too much overhead and are simply not worth the trouble. Or, more concisely, PHP != Java.

[codezilla]

Also where is the OBJECT class that the ArrayList extends ? Umm...

Oops, removed that extends stuff. That's partially why I didn't want to post them, because many classes introduce further dependencies. My base Object class doesn't have much going on, and isn't worth mentioning. Every time I refactor it, it becomes smaller and will probably disappear completely eventually.

[Dr Livingston]

PHP != Java

Maybe... PHP > Java ?

[ghurtado]

Thank you Codezilla, very much the answer I was looking for

You are exactly right, Java might need a properly powerful Array class, since the language itself does not provide as many facilities to work with arrays. PHP is way ahead of the game there.

[gzhlon]

Following the excellent DAO examples from Codezilla in this thread I wondered if I can provoke similar thoughts on the best way to introduce a Factory/Abstract Factory class (not really sure which one or even if it's the right pattern) to allow different databases to be plugged in and out transparently.

I see PEAR and other database abstractions use different 'driver' files for each supported database, but it's very messy, and cleary not object-oriented. I guess users of PEAR DB don't care what's under the hood if it works but I have a real mental block with that approach.

The otherwise excellent Eclipse classes from Vincent Oostind also seem to be missing this capability unless you put a switch statement over the top which seems just as bad as PEAR DB.

I'm guessing the Connection object is the right place to introduce the Factory(?) object. The Factory then returns the correct 'driver' based on the scheme portion of the original DSN. But then again, I am possibly taking completely the wrong approach.

Any thoughts very welcome.

[Dr Livingston]

...to allow different databases to be plugged in and out transparently.

Wouldn't the Adapter Design Pattern be far, far more appropriate for this no ?

Sure Harry covered this over at his site not so long ago in fact... Had a look myself and it's well smart in fact

Have a look at Harry's site for the Adapter Pattern and you'll proberly understand my point yes ?

--EDIT--

For the correct use of a Factory class have a look over at www.javaworld.com for their design patterns. I was looking at this pattern yersterday and from what I can tell this wouldn't be the pattern your looking for imho...

[coo_t2]

Following the excellent DAO examples from Codezilla in this thread I wondered if I can provoke similar thoughts on the best way to introduce a Factory/Abstract Factory class (not really sure which one or even if it's the right pattern) to allow different databases to be plugged in and out transparently.

I see PEAR and other database abstractions use different 'driver' files for each supported database, but it's very messy, and cleary not object-oriented. I guess users of PEAR DB don't care what's under the hood if it works but I have a real mental block with that approach.

The otherwise excellent Eclipse classes from Vincent Oostind also seem to be missing this capability unless you put a switch statement over the top which seems just as bad as PEAR DB.

I'm guessing the Connection object is the right place to introduce the Factory(?) object. The Factory then returns the correct 'driver' based on the scheme portion of the original DSN. But then again, I am possibly taking completely the wrong approach.

Any thoughts very welcome.

As you know to get a DB object with eclipse, you'd do something like
the following:

$dbObj =& MySqlDatabase(..info...);

if I want to change the DB, I just make a change to which object is instantiated:

$dbObj =& OracleDatabase(...info...);

So what would be the benefit of creating an abstract layer on top of this?
If you make a connection through another abstract layer, you still have to send
the type of DB being used as a parameter, don't you? So why not just change
the object name that's being instantiated?

THe only way I see a benefit is if you want people to be able to create a connection to a DB without ever knowing which db.
Maybe like so:

// don't care which type of DB is being used under the hood.
$dbObj =& DbConnection(..non-specific DB type info..);

Other than that, I could be missing something. If so, please enlighten me


--ed

[gzhlon]

coo t2, you're dead right! I was having trouble seeing this clearly, probably a result of reading too many ill conceived articles on the subject elsewhere.

In fact, codezilla's classes use ADOdb which provide the type of abstraction I was looking for in the first place. The scheme portion of the DSN in codezilla's classes provide ADOdb with which 'type' of underlying database technology to use.

Forgive my ignorance and thanks for the responses.

[gzhlon]

Hi Codezilla!

I have gone a long way to getting your classes to work on my own system and I am very pleased with the results.

But in the usage example below I cannot see where the iterator comes from. It's not defined as a method/property of the DAO class or derived classes.

Please could you explain this?

TIA

Usage example:

$dao =& new BidderDao();
$list =& $dao->findForAuctionId($_GET['auction_id']);
$i =& $list->iterator();
while ($i->hasNext())
{
    $bidder =& $i->next();
    // do stuff with $bidder
} 

ps. Any idea when your BSOC library will be released or can you provide a sneak preview?