http://revjim.net/comments/10165/

This week as I learned both the name of this pattern, and the SQL to implement it efficiently in MySQL I thought I’d share some notes on what we’ve come up with.

Class Table Inheritance

We’re using CTI for a number of reasons, some excellent, and some because that is how our brains work. One key benefit is we get the ability to operate on heterogenous collections of object. (i.e. display a sorted list of contact objects irrespective of whether they are individuals, organizations, etc.) The fact that something as fundamental as polymorphism can be difficult to accomplish using other O/R techniques hilights the general difficulty and impedance mismatch of object to relational mapping.

There are, however a few challenges involved.

The Model

Challenge 1:

Solution 1:

SELECT 
  c.id as id, c.contactType,
  i.firstName, i.lastName,
  o.name as orgName
FROM
  Contact as c
LEFT JOIN Individual as i ON i.id = c.id 
LEFT JOIN Organization as o ON o.id = c.id

(And it’s pretty easy to coax the necessary SQL out of our modified version of DB_DataObject. I’ll demonstrate that in a future entry)

Challenge 2:

One solution would be select all known records, and do sorting and slicing at the application level. (This is so wrong it makes my head hurt) Another solution would be store a field like “sortName” on Contact, which you could calculate and save on inserts and updates. This is on the right track.

Solution 2:

SELECT 
  c.id as id, c.contactType,
  i.firstName, i.lastName,
  o.name as orgName,
CASE 
 WHEN c.contactType = 'Individual' THEN CONCAT(i.lastName, i.firstName)
 WHEN c.contactType = 'Organization' THEN o.name
END as sortName
FROM
  Contact as c
LEFT JOIN Individual as i ON i.id = c.id 
LEFT JOIN Organization as o ON o.id = c.id
ORDER by sortName

This simply adds a switch statement to your field list conditionally setting the value of sortName.

There is nothing quite so satisfying as finding the right tool for the right job. I’m currently totally in love with the CASE statement, and think everyone should know about it. (hence this bit of evangelism)

Tip: don’t forget that ‘,’ after orgName, I keep forgetting it and wondering why my SQL isn’t working.

So concludes today’s edition of “Enterprise Development with MySQL” (“Kellan Learns SQL” didn’t sound as impressive). In the near future I hope to get a chance to write up some of the PHP libs we’ve been building/modifying to support object rich web development techniques, completing the picture. (OLamp anyone?)

Mixing Metaphors

Transparent, Unified Access

1. don’t have to write all those toArray() method to dump your data to Smarty
2. can lazy load data as needed
3. can provide intelligent formatting without the need to write a Smarty plugin

(fyi this “ideal world” is also known as Template Toolkit)

SPL

A quick example (there are probably better ones)

Say you had a class that you used to help you page through a list of results, and at the bottom of each page you wanted to add a slug like “Widgets 21-30 of 142″.

One solution would be to assign {$objectType}, {$showingMin}, {$showingMax}, {$totalToShow} (or some such) variables to Smarty, and then have something like the following in your template:

{$objectType} {$showingMin}-{$showingMax} of {$totalToShow} in

But to my eye that seems to clutter up the paging code with assigns, and clutter up the templates with unintuitive markup. (and this is a simple case)

Another solution would be to build the string at some point in your code, and pass that to Smarty (making your eventual I18N process just that much more challenging)

The third solution is to have your Pager class pretend to be an array, allowing you to add {$page.showStatus} to your templates which Smarty will compile into $this->tplvars['page']['showStatus'], and the SPL will intercept and transform into $page->offsetGet('showStatus');

So whats does the Pager class look like? Well the relevant bits look like:

class Pager implements ArrayAccess {
   ...
   function offsetGet($k) {
    if ($this->offsetExists($k)) {
                return $this->$k();
        }
   }


function offsetExists($k) {
       return method_exists($this, $k);
   }

/* set and unset don't do anything */

   function offsetSet($k, $v) {}
   function offsetUnset($k) {}

function showStatus() {
      ...construct status string and return it....
   }
}

A Word About Security

• strip all non-word characters from your access key like so: $key = preg_replace('/\W/', '', $key);
• the method calls are already namespaced to the object, but you could quarantine them further by appending a string to them (e.g. ‘tmpl‘), in which case your offsetGet() becomes

     function offsetGet($k) {
          $k = pregreplace('/\W/', '', $k);
      $f = "tmpl$f";
          return $this->$f();
     }
  

  (alternately you could use Relection API to limit offsetGet to only exposing methods inherited from some base class, or whatever other creative solution strikes your fancy)