Hand rolling an ORM Class -- Singleton, Static Parent,? - php

Question

I'm writing a web reporting extension to a data warehouse my company purchased. The data warehouse is data-model neutral, and has tables storing the table relationships and metalayer data for the fields. This makes it pretty easy for me to write a basic ORM class, which is what I'm trying to do. It all works, but...
My ORM class holds the PDO instance, the fields for the table (used as a whitelist), and metalayer info for the fields. It also has convenience functions for mapping the table relationships (generates the FROM / JOIN clauses) and mapping the filters supplied from the web (generates the WHERE clause).
The SELECT clause is generated in child classes of the ORM, based on the model requested. When the page loads, there are several models that need to be built. Obviously, I only need one instance of the ORM (like a monostate), but I would like each child class to inherit the properties and convenience functions of the ORM -- without redoing the parent class' queries each time a child class is instantiated.
The singleton pattern may fit here, but I'm finding it difficult to subclass a singleton. And I just can't seem to get static properties to work right.
I think I'm close but I'm either missing something or making this too difficult. I'm now considering dropping the properties into a thin class and extending from there while mixing the convenience function in with traits. I've seen similar questions for this topic, but haven't come up with a definite solution.
I'm not at work, but this is a simplified example of the code that should give you the gist of what I'm trying to do.
Class ORM {
protected $conn;
protected $fields;
protected $relations;
protected $table;
protected $sql;
public function __construct ($view, $database) {
$this->conn = new PDO(...$database...);
$this->table = $view;
$this->getFields();
$this->getRelations();
}
private function getFields () {
//select fields from metalayer where table = $table;
//$this->fields = $result;
}
private function getRelations () {
//select relations from relations where table = $table;
//$this->relations = $result;
}
protected function mapTables ($tables) {
// $this->sql = "FROM $this->table";
// foreach ($tables as $table) {
// $this->sql .= "LEFT JOIN $table ON $relations[$table]['key1'] = $relations[$table]['key2'];
}
protected function mapFilters ($filters) {
// $this->sql = "WHERE 1=1";
// foreach $filters as $filter {
// $this->sql .= "AND ($filter['field'] = $filter['criterion1'] OR ...criterion2, etc.)
}
}
Class ExampleModelDAO extends ORM {
public function __construct($view, $database, $params) {
parent::__construct($view, $database);
// parse params
parent::mapTables($tables);
parent::mapFilters($filters);
}
public function get() {
// Prepend $this->sql with SELECT statement specific to model
// Query database and return model
}
}

Answer 1

First off, your orm/model shouldn't know anything about the database. There are a million ways to do this but I would start with a simple database class that offers some additional functionality on top of pdo but completely independent from anything else. This will also allow you to do direct database access without requiring the need for a model as well as allow you to create models that are database independent. For maximum flexibility you want to look into the adapter pattern and data mapper. However, to keep it simple, here is a very basic example (without an adapter or data mapper) of mapping a model to a data store.
<?php
class DB extends PDO {
public function __construct() {
try {
parent::__construct(/* db info */);
} catch (Exception $e) {
// handle the error
}
}
public function read() {
// read from database
}
public function write() {
// write to database
}
// etc...
}
So your database class will have some simple crud operations. Then your orm can interact with this class like so...
<?php
class ORM {
public function __construct() {
$this->db = new DB();
}
public function find($options) {
return $this->db->read($options);
}
public function save($data) {
return $this->db->create($data); // or update()
}
// etc...
}
This should be enough to get you going. Also, rather than using a singleton pattern for your database, if you don't manage your connections externally, you could use a simple modified registry type pattern (note this isn't a true registry)
<?php
class DB extends PDO {
protected static $instances = array();
public function __construct() ...
public static function get($name) {
if(! isset(self::$instances[$name]) {
self::$instances[$name] = new self();
}
return self::$instances[$name];
}
}
class ORM {
public function __construct() {
$this->db = DB::get('connection1');
}
}
There are better ways to do this but I will leave that up to you.