Entity “фреймворк” для PHP из одного класса

Сейчас ваше решение тянет на одноразовое

огромное количество качественных решений

теперь посмотрим на ваш случай:

<?php
/**
 * Инициирует ПДО, выполняет запрос с параметрами.
 * Результат возвращает в виде dbResult.
 * dbResult - итератор
 */
class db extends component {
  protected $pdo;
  protected $dsn = 'mysql:host=localhost;dbname=test';
  protected $user = 'root';
  protected $password = '';
  protected $options = [PDO::MYSQL_ATTR_INIT_COMMAND => 'SET NAMES \'UTF8\''];
  protected $queryClass = 'mysqlQuery';

  public function __construct($config = NULL) {
    parent::__construct($config);
    $this->pdo = new PDO($this->dsn, $this->user, $this->password, $this->options);
    // бросаем исключения при проблемах
    $this->pdo->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);
  }

  public function insId() {
    return $this->pdo->lastInsertId();
  }

  protected function prepareParam($param) {
    $result = [];
    foreach($param as $key=>$value) {
      $key = ':' . (string) $key;
      $value = (string) $value;
      $result[$key] = $value;
    }
    return $result;
  }

  public function go($sql, $param=NULL) {
    $statement = $this->pdo->prepare($sql, [\PDO::ATTR_CURSOR => \PDO::CURSOR_SCROLL]);
    $statement->setFetchMode(\PDO::FETCH_ASSOC);
    if($param) {
      $param = $this->prepareParam($param);
      $executeResult = $statement->execute($param);
    }
    else {
      $executeResult = $statement->execute();
    }
    return new dbResult([
      'statement'=>$statement,
      'ok'=>$executeResult
    ]);
  }

  // Вернем построитель запросов характерный для данной базы
  public function query($config) {
      $class = $this->queryClass;
      return new $class($config);
  }
}

<?php
/**
 * Итератор по результатам запроса.
 * публичное свойство ОК содержит булево значение удачности запроса.
 * Метод one - сахар для запросов когда ожидается только один резульат.
 */
class dbResult extends component implements Iterator
{
    protected $key;
    protected $current;

    protected $statement;
    public $ok;
    public $modelName;

    public function current() {
        return $this->current;
    }

    public function next() {
        $this->key++;
    }

    public function key() {
        return $this->key;
    }

    public function valid() {
        $this->current = $this->getRecord($this->key);
        if (false === $this->current) { // (!array()) == True
            return false;
        } else return true;
    }

    // Получаем отдельную запись, и если это уместно - выполняем манипуляции после загрузки
    protected function getRecord($key) {
        $record = $this->statement->fetch(
            \PDO::FETCH_ASSOC,
            \PDO::FETCH_ORI_ABS, 
            $key
        );
        if($record AND $this->modelName) {
            $model = model($this->modelName);
            $model->load($record);
            return $model;
        } else return $record;
    }

    public function rewind() {
        $this->key = 0;
    }

    public function one() {
        $this->rewind();
        $this->valid();
        $obj = $this->current();
        $this->statement->closeCursor();    
        return $obj;
    }
}

<?php
class mysqlQuery extends mysqlQueryCore {
  public function insert($data) {
    $data = $this->filterField($data);
    $this->param = $data;
    $sql = 'INSERT '.$this->table().' SET '.$this->fields2set($data);
    $this->sql = $sql;
    return $this;
  }

  public function update($data, $where, $whereParam=NULL) {
    $data = $this->filterField($data);
    $this->param = $data;
    $where = $this->where($where, $whereParam);
    $sql = 'UPDATE '.$this->table().' SET '.$this->fields2set($data).' WHERE '.$where;
    $this->sql = $sql;
    return $this;
  }

  public function delete($where, $whereParam=NULL) {
    $this->param = []; // reset old request
    $where = $this->where($where, $whereParam);
    $sql = 'DELETE FROM '.$this->table().' WHERE '.$where;
    $this->sql = $sql;
    return $this;
  }

  public function select($data, $where, $whereParam=NULL) {
    $this->param = []; // reset old request
    if(is_array($data)) {
      $data = $this->quoteFieldList($data);
    }
    $where = $this->where($where, $whereParam);
    $sql = 'SELECT '.$data.' FROM '.$this->table().' WHERE '.$where;
    $this->sql = $sql;
    return $this;
  }


  public function count($where, $whereParam=NULL) {
    $data = 'COUNT(1) as cnt';
    return $this->select($data, $where, $whereParam);
  }

  public function limit($limit, $offset=NULL) {
    $this->sql = $this->sql . $this->limitSql($limit, $offset);
    return $this;
  }

  public function order($order) {
    $this->sql = $this->sql . $this->orderSql($order);
    return $this;
  }
}

<?php
class mysqlQueryCore extends component {
  protected $table;
  protected $allowed=[];


  public $param=[];
  public $sql='';

  public function reset() {
    $this->sql = '';
    $this->param = [];
  }

  public function where($data, $param = NULL) {
    if($param) {
      foreach($param as $key=>$value) {
        $this->param['where_'.$key] = $value;
      }
      return $data;
    }
    if(true === $data) $data = '1=1';
    if(is_int($data)) {
      $this->param['where_id'] = $data;
      $where = $this->quoteId('id') .'=:where_id';
      return $where;
    }
    if(is_array($data)) {
      $where = $this->array2where($data);
      return $where;
    }
    if(is_string($data)) {
      return $data;
    }
    return FALSE;
  }

  protected function array2where($data) {
    $data = $this->filterField($data);
    $mylist = [];
    foreach($data as $key=>$value) {
      $mylist[] = $this->quoteId($key) .'=:where_'.$key;
      $this->param['where_'.$key] = $value;
    }
    return implode(' AND ', $mylist);  
  }


  public function orderSql($order) {
    if($order{0}=='!') {
      $field = substr($order,1);
      $field = $this->quoteId($field);
      $result = ' ORDER BY '.$field.' DESC';
    }
    else {
      $field = $order;
      $field = $this->quoteId($field);
      $result = ' ORDER BY '.$field.' ASC';
    }
    return $result;
  }

  public function limitSql($limit,$offset=NULL) {
    $result = ' LIMIT ';
    if($offset) $result .= intval($offset).','.intval($limit);
    else $result .= intval($limit);
    return $result;
  }


  public function quoteFieldList($fields) {
//    $allowed = array_flip($this->allowed);
    $allowed = $this->allowed;
    $mylist = [];
    foreach($fields as $value) {
      if(isset($allowed[$value])) $mylist[] = $this->quoteId($value);
    }
    return implode(' , ', $mylist);
  }

  // $fields = ['name'=>'namedata','value'=>'valuedata']
  // return: `name` = :name, `value` = :value
  public function fields2set($fields) {
    $mylist = [];
    foreach($fields as $key=>$value) {
      $mylist[] = $this->quoteId($key) .'=:'.$key;
    }
    return implode(' , ', $mylist);
  }


  public function quoteId($id) {
    return "`".$id."`";
  }

  public function filterField($data) {
//    $allowed = array_flip($this->allowed);
    $allowed = $this->allowed;
    if (is_object($data) OR is_array($data)) {
      $result = [];
      foreach ($data as $key => $value) {
        if(isset($allowed[$key])) $result[$key] = $value;
      }
      return $result;
    }
    else {
      return FALSE;
    }	
  }

  public function table() {
    return $this->quoteId($this->table);
  }
}

необходимо каждый раз вытаскивать все эти связи в виде гроздьев объектов на страницу контекст которой будет разрушен через долю миллисекунды

А никто и не говорит про "каждый раз". Но это с завидной регулярностью оказывается нужно в бизнес-логике, и вот тогда адекватные агрегаты оказываются намного проще для использования, чем несвязанные классы.