PHP ORM style of querying

Question

Ok so I have made an ORM library for PHP. It uses syntax like so:

*(assume that $business_locations is an array)*

Business::type(Business:TYPE_AUTOMOTIVE)->
          size(Business::SIZE_SMALL)->
          left_join(BusinessOwner::table(), BusinessOwner::business_id(), SQL::OP_EQUALS, Business::id())->
          left_join(Owner::table(), SQL::OP_EQUALS, Owner::id(), BusinessOwner::owner_id())->
          where(Business::location_id(), SQL::in($business_locations))->
          group_by(Business::id())->
          select(SQL::count(BusinessOwner::id());

Which can also be represented as:

$query = new Business();
$query->set_type(Business:TYPE_AUTOMOTIVE);
$query->set_size(Business::SIZE_SMALL);
$query->left_join(BusinessOwner::table(), BusinessOwner::business_id(), SQL::OP_EQUALS, $query->id());
$query->left_join(Owner::table(), SQL::OP_EQUALS, Owner::id(), BusinessOwner::owner_id());
$query->where(Business::location_id(), SQL::in($business_locations));
$query->group_by(Business::id());
$query->select(SQL::count(BusinessOwner::id());

This would produce a query like:

SELECT COUNT(`business_owners`.`id`)
FROM   `businesses`
       LEFT JOIN `business_owners`
         ON `business_owners`.`business_id` = `businesses`.`id`
       LEFT JOIN `owners`
         ON `owners`.`id` = `business_owners`.`owner_id`
WHERE  `businesses`.`type` = 'automotive'
       AND `businesses`.`size` = 'small'
       AND `businesses`.`location_id` IN ( 1, 2, 3, 4 )
GROUP  BY `businesses`.`id`  

Please keep in mind that the syntax might not be prefectly correct (I only wrote this off the top of my head)

• Any way, what do you think of this style of querying?
• Is the first method or second better/clearer/cleaner/etc?
• What would you do to improve it?

Answer 1

One small improvement:

return $this 

from each function.

Then you can chain them like this:

$query->set_type(Business:TYPE_AUTOMOTIVE)->set_size(Business::SIZE_SMALL);

Answer 2

I know libraries like mysqli offer both styles. But to me that's slightly odd - there is one important difference between static and OO.

• 1st style (static) implies you can only do one query at a time.

• 2nd style (OO) implies you can do more than 1.

So which is true? Personally I'd go with which ever is true.

Answer 3

Both styles are horribly messy and verbose. I'd go with something much nicer like Doctrine.