Newer
Older
<?php
/*********************************************************************
class.orm.php
Simple ORM (Object Relational Mapper) for PHP5 based on Django's ORM,
except that complex filter operations are not supported. The ORM simply
supports ANDed filter operations without any GROUP BY support.
Jared Hancock <jared@osticket.com>
Copyright (c) 2006-2013 osTicket
http://www.osticket.com
Released under the GNU General Public License WITHOUT ANY WARRANTY.
See LICENSE.TXT for details.
vim: expandtab sw=4 ts=4 sts=4:
**********************************************************************/
class OrmException extends Exception {}
class OrmConfigurationException extends Exception {}
// Database fields/tables do not match codebase
class InconsistentModelException extends OrmException {
function __construct() {
// Drop the model cache (just incase)
ModelMeta::flushModelCache();
call_user_func_array(array('parent', '__construct'), func_get_args());
}
}
/**
* Meta information about a model including edges (relationships), table
* name, default sorting information, database fields, etc.
*
* This class is constructed and built automatically from the model's
* ::getMeta() method using a class's ::$meta array.
*/
class ModelMeta implements ArrayAccess {
static $base = array(
'pk' => false,
'table' => false,
'defer' => array(),
'select_related' => array(),
'joins' => array(),
'foreign_keys' => array(),
var $meta = array();
var $new;
var $subclasses = array();
function __construct($model) {
// Merge ModelMeta from parent model (if inherited)
$parent = get_parent_class($this->model);
$meta = $model::$meta;
if ($model::$meta instanceof self)
$meta = $meta->meta;
if (is_subclass_of($parent, 'VerySimpleModel')) {
$this->parent = $parent::getMeta();
$meta = $this->parent->extend($this, $meta);
$meta = $meta + self::$base;
// Short circuit the meta-data processing if APCu is available.
// This is preferred as the meta-data is unlikely to change unless
// osTicket is upgraded, (then the upgrader calls the
// flushModelCache method to clear this cache). Also, GIT_VERSION is
// used in the APC key which should be changed if new code is
// deployed.
if (function_exists('apcu_store')) {
$loaded = false;
$apc_key = SECRET_SALT.GIT_VERSION."/orm/{$this->model}";
$this->meta = apcu_fetch($apc_key, $loaded);
if ($loaded)
return;
}
if (!$meta['view']) {
if (!$meta['table'])
throw new OrmConfigurationException(
sprintf(__('%s: Model does not define meta.table'), $this->model));
elseif (!$meta['pk'])
throw new OrmConfigurationException(
sprintf(__('%s: Model does not define meta.pk'), $this->model));
}
// Ensure other supported fields are set and are arrays
foreach (array('pk', 'ordering', 'defer', 'select_related') as $f) {
if (!isset($meta[$f]))
$meta[$f] = array();
elseif (!is_array($meta[$f]))
$meta[$f] = array($meta[$f]);
}
// Break down foreign-key metadata
foreach ($meta['joins'] as $field => &$j) {
if ($j['local'])
$meta['foreign_keys'][$j['local']] = $field;
$this->meta = $meta;
if (function_exists('apcu_store')) {
apcu_store($apc_key, $this->meta, 1800);
function extend(ModelMeta $child, $meta) {
$this->subclasses[$child->model] = $child;
return $meta + $this->meta + self::$base;
}
function isSuperClassOf($model) {
if (isset($this->subclasses[$model]))
return true;
foreach ($this->subclasses as $M=>$meta)
if ($meta->isSuperClassOf($M))
return true;
}
function isSubclassOf($model) {
if (!isset($this->parent))
return false;
if ($this->parent->model === $model)
return true;
return $this->parent->isSubclassOf($model);
/**
* Adds some more information to a declared relationship. If the
* relationship is a reverse relation, then the information from the
* reverse relation is loaded into the local definition
*
* Compiled-Join-Structure:
* 'constraint' => array(local => array(foreign_field, foreign_class)),
* Constraint used to construct a JOIN in an SQL query
* 'list' => boolean
* TRUE if an InstrumentedList should be employed to fetch a list
* of related items
* 'broker' => Handler for the 'list' property. Usually a subclass of
* 'InstrumentedList'
* 'null' => boolean
* TRUE if relation is nullable
* 'fkey' => array(class, pk)
* Classname and field of the first item in the constraint that
* points to a PK field of a foreign model
* 'local' => string
* The local field corresponding to the 'fkey' property
*/
function processJoin(&$j) {
if (isset($j['reverse'])) {
list($fmodel, $key) = explode('.', $j['reverse']);
// NOTE: It's ok if the forein meta data is not yet inspected.
$info = $fmodel::$meta['joins'][$key];
if (!is_array($info['constraint']))
throw new OrmConfigurationException(sprintf(__(
// `reverse` here is the reverse of an ORM relationship
'%s: Reverse does not specify any constraints'),
$j['reverse']));
foreach ($info['constraint'] as $foreign => $local) {
list($L,$field) = is_array($local) ? $local : explode('.', $local);
$constraint[$field ?: $L] = array($fmodel, $foreign);
}
if (!isset($j['list']))
$j['list'] = true;
if (!isset($j['null']))
// By default, reverse releationships can be empty lists
$j['null'] = true;
else {
foreach ($j['constraint'] as $local => $foreign) {
list($class, $field) = $constraint[$local]
= is_array($foreign) ? $foreign : explode('.', $foreign);
if ($j['list'] && !isset($j['broker'])) {
$j['broker'] = 'InstrumentedList';
}
if ($j['broker'] && !class_exists($j['broker'])) {
throw new OrmException($j['broker'] . ': List broker does not exist');
}
foreach ($constraint as $local => $foreign) {
list($class, $field) = $foreign;
if ($local[0] == "'" || $field[0] == "'" || !class_exists($class))
continue;
function addJoin($name, array $join) {
$this->meta['joins'][$name] = $join;
$this->processJoin($this->meta['joins'][$name]);
function offsetGet($field) {
return $this->meta[$field];
}
function offsetSet($field, $what) {
$this->meta[$field] = $what;
}
function offsetExists($field) {
return isset($this->meta[$field]);
}
function offsetUnset($field) {
throw new Exception('Model MetaData is immutable');
}
/**
* Fetch the column names of the table used to persist instances of this
* model in the database.
*/
function getFieldNames() {
if (!isset($this->fields))
$this->fields = self::inspectFields();
return $this->fields;
}
/**
* Create a new instance of the model, optionally hydrating it with the
* given hash table. The constructor is not called, which leaves the
* default constructor free to assume new object status.
*
* Three methods were considered, with runtime for 10000 iterations
* * unserialze('O:9:"ModelBase":0:{}') - 0.0671s
* * new ReflectionClass("ModelBase")->newInstanceWithoutConstructor()
* - 0.0478s
* * and a hybrid by cloning the reflection class instance - 0.0335s
*/
function newInstance($props=false) {
if (!isset($this->new)) {
$rc = new ReflectionClass($this->model);
$this->new = $rc->newInstanceWithoutConstructor();
$instance = clone $this->new;
// Hydrate if props were included
if (is_array($props)) {
$instance->ht = $props;
}
return $instance;
}
function inspectFields() {
if (!isset(self::$model_cache))
self::$model_cache = function_exists('apcu_fetch');
$key = SECRET_SALT.GIT_VERSION."/orm/{$this['table']}";
if ($fields = apcu_fetch($key)) {
return $fields;
}
}
$fields = DbEngine::getCompiler()->inspectTable($this['table']);
static function flushModelCache() {
if (self::$model_cache)
@apcu_clear_cache('user');
class VerySimpleModel {
static $meta = array(
'table' => false,
'ordering' => false,
'pk' => false
);
var $ht;
var $dirty = array();
var $__deferred__ = array();
function __construct($row=false) {
if (is_array($row))
foreach ($row as $field=>$value)
if (!is_array($value))
$this->set($field, $value);
$this->__new__ = true;
function get($field, $default=false) {
if (array_key_exists($field, $this->ht))
return $this->ht[$field];
elseif (($joins = static::getMeta('joins')) && isset($joins[$field])) {
$j = $joins[$field];
// Support instrumented lists and such
if (isset($j['list']) && $j['list']) {
$class = $j['fkey'][0];
$fkey = array();
// Localize the foreign key constraint
foreach ($j['constraint'] as $local=>$foreign) {
list($_klas,$F) = $foreign;
$fkey[$F ?: $_klas] = ($local[0] == "'")
? trim($local, "'") : $this->ht[$local];
}
$v = $this->ht[$field] = new $j['broker'](
// Send Model, [Foriegn-Field => Local-Id]
array($class, $fkey)
);
return $v;
}
// Support relationships
elseif (isset($j['fkey'])) {
$criteria = array();
foreach ($j['constraint'] as $local => $foreign) {
if (class_exists($klas))
$class = $klas;
if ($local[0] == "'") {
$criteria[$F] = trim($local,"'");
}
// Does not affect the local model
continue;
}
else {
$criteria[$F] = $this->ht[$local];
}
}
$v = $this->ht[$field] = $class::lookup($criteria);
}
catch (DoesNotExist $e) {
$v = null;
}
elseif (isset($this->__deferred__[$field])) {
// Fetch deferred field
$row = static::objects()->filter($this->getPk())
// XXX: Seems like all the deferred fields should be fetched
->values_flat($field)
->one();
if ($row)
return $this->ht[$field] = $row[0];
}
elseif ($field == 'pk') {
return $this->getPk();
}
if (isset($default))
return $default;
// For new objects, assume the field is NULLable
if ($this->__new__)
return null;
// Check to see if the column referenced is actually valid
if (in_array($field, static::getMeta()->getFieldNames()))
throw new OrmException(sprintf(__('%s: %s: Field not defined'),
get_class($this), $field));
}
function __get($field) {
return $this->get($field, null);
}
function getByPath($path) {
if (is_string($path))
$path = explode('__', $path);
$root = $this;
foreach ($path as $P)
$root = $root->get($P);
return $root;
}
function __isset($field) {
return array_key_exists($field, $this->ht)
|| isset(static::$meta['joins'][$field]);
function __unset($field) {
if ($this->__isset($field))
unset($this->ht[$field]);
else
unset($this->{$field});
// Update of foreign-key by assignment to model instance
$joins = static::getMeta('joins');
if (isset($joins[$field])) {
$j = $joins[$field];
if ($j['list'] && ($value instanceof InstrumentedList)) {
// Magic list property
$this->ht[$field] = $value;
return;
}
if (in_array($j['local'], static::$meta['pk'])) {
// Reverse relationship — don't null out local PK
return;
}
// Pass. Set local field to NULL in logic below
}
elseif ($value instanceof VerySimpleModel) {
// Ensure that the model being assigned as a relationship is
// an instance of the foreign model given in the
// relationship, or is a super class thereof. The super
// class case is used primary for the xxxThread classes
// which all extend from the base Thread class.
if (!$value instanceof $j['fkey'][0]
&& !$value::getMeta()->isSuperClassOf($j['fkey'][0])
) {
throw new InvalidArgumentException(
sprintf(__('Expecting NULL or instance of %s. Got a %s instead'),
$j['fkey'][0], is_object($value) ? get_class($value) : gettype($value)));
}
// Capture the object under the object's field name
$this->ht[$field] = $value;
if ($value->__new__)
// save() will be performed when saving this object
$value = null;
else
$value = $value->get($j['fkey'][1]);
// Fall through to the standard logic below
}
// Capture the foreign key id value
$field = $j['local'];
}
// elseif $field is in a relationship, adjust the relationship
elseif (isset(static::$meta['foreign_keys'][$field])) {
// meta->foreign_keys->{$field} points to the property of the
// foreign object. For instance 'object_id' points to 'object'
$related = static::$meta['foreign_keys'][$field];
}
$old = isset($this->ht[$field]) ? $this->ht[$field] : null;
if ($old != $value) {
// isset should not be used here, because `null` should not be
// replaced in the dirty array
if (!array_key_exists($field, $this->dirty))
$this->dirty[$field] = $old;
if ($related)
// $related points to a foreign object propery. If setting a
// new object_id value, the relationship to object should be
// cleared and rebuilt
unset($this->ht[$related]);
$this->ht[$field] = $value;
}
function __set($field, $value) {
return $this->set($field, $value);
}
function setAll($props) {
foreach ($props as $field=>$value)
$this->set($field, $value);
}
static function getMeta($key=false) {
if (!static::$meta instanceof ModelMeta
|| get_called_class() != static::$meta->model
) {
static::$meta = new ModelMeta(get_called_class());
}
$M = static::$meta;
return ($key) ? $M->offsetGet($key) : $M;
/**
* objects
*
* Retrieve a QuerySet for this model class which can be used to fetch
* models from the connected database. Subclasses can override this
* method to apply forced constraints on the QuerySet.
*/
static function objects() {
return new QuerySet(get_called_class());
}
/**
* lookup
*
* Retrieve a record by its primary key. This method may be short
* circuited by model caching if the record has already been loaded by
* the database. In such a case, the database will not be consulted for
* the model's data.
*
* This method can be called with an array of keyword arguments matching
* the PK of the object or the values of the primary key. Both of these
* usages are correct:
*
* >>> User::lookup(1)
* >>> User::lookup(array('id'=>1))
*
* For composite primary keys and the first usage, pass the values in
* the order they are given in the Model's 'pk' declaration in its meta
* data.
*
* Parameters:
* $criteria - (mixed) primary key for the sought model either as
* arguments or key/value array as the function's first argument
*
* Returns:
* (Object<Model>|null) a single instance of the sought model or null if
* no such instance exists.
// Model::lookup(1), where >1< is the pk value
if (!is_array($criteria)) {
$criteria = array();
$pk = static::getMeta('pk');
// Only consult cache for PK lookup, which is assumed if the
// values are passed as args rather than an array
if ($cached = ModelInstanceManager::checkCache(get_called_class(),
$criteria))
return $cached;
try {
return static::objects()->filter($criteria)->one();
}
catch (DoesNotExist $e) {
return null;
}
$ex = DbEngine::delete($this);
try {
$ex->execute();
if ($ex->affected_rows() != 1)
return false;
Signal::send('model.deleted', $this);
}
catch (OrmException $e) {
return false;
}
if ($this->__deleted__)
throw new OrmException('Trying to update a deleted object');
$pk = static::getMeta('pk');
$wasnew = $this->__new__;
// First, if any foreign properties of this object are connected to
// another *new* object, then save those objects first and set the
// local foreign key field values
foreach (static::getMeta('joins') as $prop => $j) {
if (isset($this->ht[$prop])
&& ($foreign = $this->ht[$prop])
&& $foreign instanceof VerySimpleModel
&& !in_array($j['local'], $pk)
&& null === $this->get($j['local'])
) {
if ($foreign->__new__ && !$foreign->save())
return false;
$this->set($j['local'], $foreign->get($j['fkey'][1]));
}
}
// If there's nothing in the model to be saved, then we're done
$ex = DbEngine::save($this);
try {
$ex->execute();
if ($ex->affected_rows() != 1) {
// This doesn't really signify an error. It just means that
// the database believes that the row did not change. For
// inserts though, it's a deal breaker
if ($this->__new__)
return false;
else
// No need to reload the record if requested — the
// database didn't update anything
$refetch = false;
}
catch (OrmException $e) {
return false;
// XXX: Ensure AUTO_INCREMENT is set for the field
$this->ht[$pk[0]] = $ex->insert_id();
Signal::send('model.created', $this);
}
else {
$data = array('dirty' => $this->dirty);
Signal::send('model.updated', $this, $data);
}
# Refetch row from database
if ($refetch) {
// Preserve non database information such as list relationships
// across the refetch
static::objects()->filter($this->getPk())->values()->one()
+ $this->ht;
}
if ($wasnew) {
// Attempt to update foreign, unsaved objects with the PK of
// this newly created object
foreach (static::getMeta('joins') as $prop => $j) {
if (isset($this->ht[$prop])
&& ($foreign = $this->ht[$prop])
&& in_array($j['local'], $pk)
) {
if ($foreign instanceof VerySimpleModel
&& null === $foreign->get($j['fkey'][1])
) {
$foreign->set($j['fkey'][1], $this->get($j['local']));
}
elseif ($foreign instanceof InstrumentedList) {
foreach ($foreign as $item) {
if (null === $item->get($j['fkey'][1]))
$item->set($j['fkey'][1], $this->get($j['local']));
}
}
}
}
private function getPk() {
$pk = array();
foreach ($this::getMeta('pk') as $f)
$pk[$f] = $this->ht[$f];
return $pk;
}
/**
* AnnotatedModel
*
* Simple wrapper class which allows wrapping and write-protecting of
* annotated fields retrieved from the database. Instances of this class
* will delegate most all of the heavy lifting to the wrapped Model instance.
*/
class AnnotatedModel {
var $model;
var $annotations;
function __construct($model, $annotations) {
$this->model = $model;
$this->annotations = $annotations;
}
function __get($what) {
return $this->get($what);
}
function get($what) {
if (isset($this->annotations[$what]))
return $this->annotations[$what];
return $this->model->get($what, null);
}
function __set($what, $to) {
return $this->set($what, $to);
}
function set($what, $to) {
if (isset($this->annotations[$what]))
throw new OrmException('Annotated fields are read-only');
return $this->model->set($what, $to);
}
function __isset($what) {
return isset($this->annotations[$what]) || $this->model->__isset($what);
}
// Delegate everything else to the model
function __call($what, $how) {
return call_user_func_array(array($this->model, $what), $how);
}
}
$this->func = $name;
$this->args = array_slice(func_get_args(), 1);
}
function input($what, $compiler, $model) {
if ($what instanceof SqlFunction)
$A = $what->toSql($compiler, $model);
elseif ($what instanceof Q)
$A = $compiler->compileQ($what, $model);
else
$A = $compiler->input($what);
return $A;
}
function toSql($compiler, $model=false, $alias=false) {
$args = array();
foreach ($this->args as $A) {
$args[] = $this->input($A, $compiler, $model);
return sprintf('%s(%s)%s', $this->func, implode(', ', $args),
$alias && $this->alias ? ' AS '.$compiler->quote($this->alias) : '');
}
function getAlias() {
return $this->alias;
}
function setAlias($alias) {
$this->alias = $alias;
static function __callStatic($func, $args) {
$I = new static($func);
$I->args = $args;
return $I;
}
function __call($operator, $other) {
array_unshift($other, $this);
return SqlExpression::__callStatic($operator, $other);
}
class SqlCase extends SqlFunction {
var $cases = array();
var $else = false;
static function N() {
return new static('CASE');
}
function when($expr, $result) {
if (is_array($expr))
$expr = new Q($expr);
$this->cases[] = array($expr, $result);
return $this;
}
function otherwise($result) {
$this->else = $result;
return $this;
}
function toSql($compiler, $model=false, $alias=false) {
$cases = array();
foreach ($this->cases as $A) {
list($expr, $result) = $A;
$expr = $this->input($expr, $compiler, $model);
$result = $this->input($result, $compiler, $model);
$cases[] = "WHEN {$expr} THEN {$result}";
}
if ($this->else) {
$else = $this->input($this->else, $compiler, $model);
$cases[] = "ELSE {$else}";
}
return sprintf('CASE %s END%s', implode(' ', $cases),
$alias && $this->alias ? ' AS '.$compiler->quote($this->alias) : '');
}
}
class SqlExpr extends SqlFunction {
function __construct($args) {
$this->args = $args;
}
function toSql($compiler, $model=false, $alias=false) {
$O = array();
foreach ($this->args as $field=>$value) {
list($field, $op) = $compiler->getField($field, $model);
if (is_callable($op))
$O[] = call_user_func($op, $field, $value, $model);
else
$O[] = sprintf($op, $field, $compiler->input($value));
}
return implode(' ', $O) . ($alias ? ' AS ' . $alias : '');
}
}
class SqlExpression extends SqlFunction {
var $operator;
var $operands;
function toSql($compiler, $model=false, $alias=false) {
$O = array();
foreach ($this->args as $operand) {
if ($operand instanceof SqlFunction)
$O[] = $operand->toSql($compiler, $model);
else
$O[] = $compiler->input($operand);
}
return implode(' '.$this->func.' ', $O)
. ($alias ? ' AS '.$compiler->quote($alias) : '');
}
static function __callStatic($operator, $operands) {
switch ($operator) {
case 'minus':
$operator = '-'; break;
case 'plus':
$operator = '+'; break;
case 'times':
$operator = '*'; break;
case 'bitand':
$operator = '&'; break;
case 'bitor':
$operator = '|'; break;
default:
throw new InvalidArgumentException('Invalid operator specified');
}
return parent::__callStatic($operator, $operands);
}
}
class SqlInterval extends SqlFunction {
var $type;
function toSql($compiler, $model=false, $alias=false) {
$A = $this->args[0];
if ($A instanceof SqlFunction)
$A = $A->toSql($compiler, $model);
else
$A = $compiler->input($A);
return sprintf('INTERVAL %s %s',
$A,
$this->func)
. ($alias ? ' AS '.$compiler->quote($alias) : '');
}
static function __callStatic($interval, $args) {
if (count($args) != 1) {
throw new InvalidArgumentException("Interval expects a single interval value");
}
return parent::__callStatic($interval, $args);
}
}
class SqlField extends SqlFunction {
var $level;
function __construct($field, $level=0) {
}
function toSql($compiler, $model=false, $alias=false) {
$L = $this->level;
while ($L--)
$compiler = $compiler->getParent();
list($field) = $compiler->getField($this->field, $model);
return $field;
}
}
class SqlCode extends SqlFunction {
function __construct($code) {
$this->code = $code;
}
function toSql($compiler, $model=false, $alias=false) {
return $this->code.($alias ? ' AS '.$alias : '');
}
}
class SqlAggregate extends SqlFunction {
var $func;
var $expr;
var $distinct=false;
var $constraint=false;
function __construct($func, $expr, $distinct=false, $constraint=false) {
$this->func = $func;
$this->expr = $expr;
$this->distinct = $distinct;
if ($constraint instanceof Q)
$this->constraint = $constraint;
elseif ($constraint)
$this->constraint = new Q($constraint);
}
static function __callStatic($func, $args) {
$distinct = @$args[1] ?: false;
$constraint = @$args[2] ?: false;
return new static($func, $args[0], $distinct, $constraint);
}
function toSql($compiler, $model=false, $alias=false) {
$options = array('constraint' => $this->constraint, 'model' => true);
// For DISTINCT, require a field specification — not a relationship
// specification.
$E = $this->expr;
if ($E instanceof SqlFunction) {
$field = $E->toSql($compiler, $model);
}
else {
list($field, $rmodel) = $compiler->getField($E, $model, $options);
if ($this->distinct) {
$pk = false;
$fpk = $rmodel::getMeta('pk');
foreach ($fpk as $f) {
$pk |= false !== strpos($field, $f);
}
if (!$pk) {
// Try and use the foriegn primary key
list($field) = $compiler->getField(
$this->expr . '__' . $fpk[0],
$model, $options);
}
else {
throw new OrmException(
sprintf('%s :: %s', $rmodel, $field) .
': DISTINCT aggregate expressions require specification of a single primary key field of the remote model'
);
}
}
}
return sprintf('%s(%s%s)%s', $this->func,
$this->distinct ? 'DISTINCT ' : '', $field,
$alias && $this->alias ? ' AS '.$compiler->quote($this->alias) : '');
}
function getFieldName() {
return strtolower(sprintf('%s__%s', $this->args[0], $this->func));
}
}
class QuerySet implements IteratorAggregate, ArrayAccess, Serializable, Countable {
var $model;
var $constraints = array();
var $path_constraints = array();
var $ordering = array();
var $limit = false;
var $offset = 0;
var $related = array();
var $values = array();
var $defer = array();
var $extra = array();
var $distinct = array();
var $options = array();
const LOCK_EXCLUSIVE = 1;
const LOCK_SHARED = 2;
const ASC = 'ASC';
const DESC = 'DESC';
function __construct($model) {
$this->model = $model;
}
function filter() {
// Multiple arrays passes means OR
foreach (func_get_args() as $Q) {
$this->constraints[] = $Q instanceof Q ? $Q : new Q($Q);
return $this;
}
function exclude() {
foreach (func_get_args() as $Q) {
$this->constraints[] = $Q instanceof Q ? $Q->negate() : Q::not($Q);
/**
* Add a path constraint for the query. This is different from ::filter
* in that the constraint is added to a join clause which is normally
* built from the model meta data. The ::filter() method on the other
* hand adds the constraint to the where clause. This is generally useful
* for aggregate queries and left join queries where multiple rows might
* match a filter in the where clause and would produce incorrect results.
*
* Example:
* Find users with personal email hosted with gmail.
* >>> $Q = User::objects();
* >>> $Q->constrain(['user__emails' => new Q(['type' => 'personal']))
* >>> $Q->filter(['user__emails__address__contains' => '@gmail.com'])
*/
function constrain() {
foreach (func_get_args() as $I) {
foreach ($I as $path => $Q) {
if (!is_array($Q) && !$Q instanceof Q) {
// ->constrain(array('field__path__op' => val));
$Q = array($path => $Q);
list(, $path) = SqlCompiler::splitCriteria($path);
$path = implode('__', $path);
}
$this->path_constraints[$path][] = $Q instanceof Q ? $Q : Q::all($Q);
}
}
return $this;
}
function defer() {
foreach (func_get_args() as $f)
$this->defer[$f] = true;
return $this;
}
function order_by($order, $direction=false) {
if ($order === false)
return $this->options(array('nosort' => true));
$args = func_get_args();
if (in_array($direction, array(self::ASC, self::DESC))) {
$args = array($args[0]);
}
else
$direction = false;
$new = is_array($order) ? $order : $args;
if ($direction) {
foreach ($new as $i=>$x) {
$new[$i] = array($x, $direction);
}
}
$this->ordering = array_merge($this->ordering, $new);
function getSortFields() {
$ordering = $this->ordering;
if ($this->extra['order_by'])
$ordering = array_merge($ordering, $this->extra['order_by']);
return $ordering;
}
function lock($how=false) {
$this->lock = $how ?: self::LOCK_EXCLUSIVE;
return $this;
}
function limit($count) {
$this->limit = $count;
return $this;
}
function offset($at) {
$this->offset = $at;
return $this;
}
function isWindowed() {
return $this->limit || $this->offset || (count($this->values) + count($this->annotations) + @count($this->extra['select'])) > 1;
function select_related() {
$this->related = array_merge($this->related, func_get_args());
return $this;
}
function extra(array $extra) {
foreach ($extra as $section=>$info) {
$this->extra[$section] = array_merge($this->extra[$section] ?: array(), $info);
}
return $this;
}
function distinct() {
foreach (func_get_args() as $D)
$this->distinct[] = $D;
return $this;
}
function models() {
$this->iterator = 'ModelInstanceManager';
$this->values = $this->related = array();
return $this;
}
foreach (func_get_args() as $A)
$this->values[$A] = $A;
// This disables related models
$this->related = false;
function values_flat() {
$this->values = func_get_args();
$this->iterator = 'FlatArrayIterator';
// This disables related models
$this->related = false;
function copy() {
return clone $this;
}
function all() {
return $this->getIterator()->asArray();
}
$list = $this->limit(1)->all();
/**
* one
*
* Finds and returns a single model instance based on the criteria in
* this QuerySet instance.
*
* Throws:
* DoesNotExist - if no such model exists with the given criteria
* ObjectNotUnique - if more than one model matches the given criteria
*
* Returns:
* (Object<Model>) a single instance of the sought model is guarenteed.
* If no such model or multiple models exist, an exception is thrown.
*/
function one() {
$list = $this->all();
if (count($list) == 0)
throw new DoesNotExist();
elseif (count($list) > 1)
throw new ObjectNotUnique('One object was expected; however '
.'multiple objects in the database matched the query. '
.sprintf('In fact, there are %d matching objects.', count($list))
);
// Defer to the iterator if fetching already started
if (isset($this->_iterator)) {
return $this->_iterator->count();
}
elseif (isset($this->count)) {
return $this->count;
$class = $this->compiler;
$compiler = new $class();
return $this->_count = $compiler->compileCount($this);
function toSql($compiler, $model, $alias=false) {
// FIXME: Force root model of the compiler to $model
$exec = $this->getQuery(array('compiler' => get_class($compiler),
'parent' => $compiler, 'subquery' => true));
// Rewrite the parameter numbers so they fit the parameter numbers
// of the current parameters of the $compiler
$sql = preg_replace_callback("/:(\d+)/",
function($m) use ($compiler, $exec) {
$compiler->params[] = $exec->params[$m[1]-1];
return ':'.count($compiler->params);
}, $exec->sql);
return "({$sql})".($alias ? " AS {$alias}" : '');
1194
1195
1196
1197
1198
1199
1200
1201
1202
1203
1204
1205
1206
1207
1208
1209
1210
1211
1212
1213
1214
1215
1216
1217
/**
* exists
*
* Determines if there are any rows in this QuerySet. This can be
* achieved either by evaluating a SELECT COUNT(*) query or by
* attempting to fetch the first row from the recordset and return
* boolean success.
*
* Parameters:
* $fetch - (bool) TRUE if a compile and fetch should be attempted
* instead of a SELECT COUNT(*). This would be recommended if an
* accurate count is not required and the records would be fetched
* if this method returns TRUE.
*
* Returns:
* (bool) TRUE if there would be at least one record in this QuerySet
*/
function exists($fetch=false) {
if ($fetch) {
return (bool) $this[0];
}
return $this->count() > 0;
}
function annotate($annotations) {
if (!is_array($annotations))
$annotations = func_get_args();
foreach ($annotations as $name=>$A) {
if (is_int($name))
$name = $A->getFieldName();
$A->setAlias($name);
}
function aggregate($annotations) {
// Aggregate works like annotate, except that it sets up values
// fetching which will disable model creation
$this->annotate($annotations);
// Disable other fields from being fetched
$this->aggregated = true;
$this->related = false;
return $this;
}
function options($options) {
$this->options = array_merge($this->options, $options);
return $this;
}
function countSelectFields() {
$count = count($this->values) + count($this->annotations);
if (isset($this->extra['select']))
foreach (@$this->extra['select'] as $S)
$count += count($S);
return $count;
}
function union(QuerySet $other, $all=true) {
// Values and values_list _must_ match for this to work
if ($this->countSelectFields() != $other->countSelectFields())
throw new OrmException('Union queries must have matching values counts');
// TODO: Clear OFFSET and LIMIT in the $other query
$this->chain[] = array($other, $all);
return $this;
}
function delete() {
$class = $this->compiler;
$compiler = new $class();
// XXX: Mark all in-memory cached objects as deleted
$ex = $compiler->compileBulkDelete($this);
$ex->execute();
return $ex->affected_rows();
}
function update(array $what) {
$class = $this->compiler;
$compiler = new $class;
$ex = $compiler->compileBulkUpdate($this, $what);
$ex->execute();
return $ex->affected_rows();
}
function __clone() {
unset($this->_iterator);
unset($this->query);
// IteratorAggregate interface
function getIterator() {
$class = $this->iterator;
$this->_iterator = new $class($this);
return $this->_iterator;
}
// ArrayAccess interface
function offsetExists($offset) {
return $this->getIterator()->offsetExists($offset);
}
function offsetGet($offset) {
return $this->getIterator()->offsetGet($offset);
}
function offsetUnset($a) {
throw new Exception(__('QuerySet is read-only'));
throw new Exception(__('QuerySet is read-only'));
return (string) $this->getQuery();
function getQuery($options=array()) {
if (isset($this->query))
return $this->query;
// Load defaults from model
$model = $this->model;
$meta = $model::getMeta();
$options += $this->options;
if ($options['nosort'])
$query->ordering = array();
elseif (!$query->ordering && $meta['ordering'])
$query->ordering = $meta['ordering'];
if (false !== $query->related && !$query->values && $meta['select_related'])
$query->related = $meta['select_related'];
if (!$query->defer && $meta['defer'])
$query->defer = $meta['defer'];
$class = $options['compiler'] ?: $this->compiler;
$compiler = new $class($options);
$this->query = $compiler->compileSelect($query);
/**
* Fetch a model class which can be used to render the QuerySet as a
* subquery to be used as a JOIN.
*/
function asView() {
$unique = spl_object_hash($this);
$classname = "QueryView{$unique}";
if (class_exists($classname))
return $classname;
$class = <<<EOF
class {$classname} extends VerySimpleModel {
static \$meta = array(
'view' => true,
);
static \$queryset;
static function getQuery(\$compiler) {
return ' ('.static::\$queryset->getQuery().') ';
}
static function getSqlAddParams(\$compiler) {
return static::\$queryset->toSql(\$compiler, self::\$queryset->model);
}
EOF;
eval($class); // Ugh
$classname::$queryset = $this;
return $classname;
}
function serialize() {
$info = get_object_vars($this);
unset($info['query']);
unset($info['limit']);
unset($info['offset']);
unset($info['_iterator']);
return serialize($info);
}
function unserialize($data) {
$data = unserialize($data);
foreach ($data as $name => $val) {
$this->{$name} = $val;
}
}
class DoesNotExist extends Exception {}
class ObjectNotUnique extends Exception {}
abstract class ResultSet implements Iterator, ArrayAccess, Countable {
var $resource;
var $position = 0;
var $queryset;
function __construct($queryset=false) {
$this->queryset = $queryset;
if ($queryset) {
$this->model = $queryset->model;
function prime() {
if (!isset($this->resource) && $this->queryset)
$this->resource = $this->queryset->getQuery();
}
1412
1413
1414
1415
1416
1417
1418
1419
1420
1421
1422
1423
1424
1425
1426
1427
1428
1429
1430
1431
1432
1433
1434
1435
1436
1437
1438
1439
1440
1441
1442
1443
1444
1445
1446
1447
1448
1449
1450
1451
1452
abstract function fillTo($index);
function asArray() {
$this->fillTo(PHP_INT_MAX);
return $this->cache;
}
// Iterator interface
function rewind() {
$this->position = 0;
}
function current() {
$this->fillTo($this->position);
return $this->cache[$this->position];
}
function key() {
return $this->position;
}
function next() {
$this->position++;
}
function valid() {
$this->fillTo($this->position);
return count($this->cache) > $this->position;
}
// ArrayAccess interface
function offsetExists($offset) {
$this->fillTo($offset);
return $this->position >= $offset;
}
function offsetGet($offset) {
$this->fillTo($offset);
return $this->cache[$offset];
}
function offsetUnset($a) {
throw new Exception(sprintf(__('%s is read-only'), get_class($this)));
}
function offsetSet($a, $b) {
throw new Exception(sprintf(__('%s is read-only'), get_class($this)));
}
// Countable interface
function count() {
return count($this->asArray());
}
}
class ModelInstanceManager extends ResultSet {
var $model;
var $map;
static $objectCache = array();
function cache($model) {
$key = sprintf('%s.%s',
$model::$meta->model, implode('.', $model->get('pk')));
self::$objectCache[$key] = $model;
}
/**
* uncache
*
* Drop the cached reference to the model. If the model is deleted
* database-side. Lookups for the same model should not be short
* circuited to retrieve the cached reference.
*/
static function uncache($model) {
$key = sprintf('%s.%s',
$model::$meta->model, implode('.', $model->pk));
unset(self::$objectCache[$key]);
}
static function flushCache() {
self::$objectCache = array();
}
static function checkCache($modelClass, $fields) {
$key = $modelClass::$meta->model;
foreach ($modelClass::getMeta('pk') as $f)
$key .= '.'.$fields[$f];
return @self::$objectCache[$key];
}
/**
* getOrBuild
*
* Builds a new model from the received fields or returns the model
* already stashed in the model cache. Caching helps to ensure that
* multiple lookups for the same model identified by primary key will
* fetch the exact same model. Therefore, changes made to the model
* anywhere in the project will be reflected everywhere.
*
* For annotated models (models build from querysets with annotations),
* the built or cached model is wrapped in an AnnotatedModel instance.
* The annotated fields are in the AnnotatedModel instance and the
* database-backed fields are managed by the Model instance.
*/
function getOrBuild($modelClass, $fields, $cache=true) {
// Check for NULL primary key, used with related model fetching. If
// the PK is NULL, then consider the object to also be NULL
foreach ($modelClass::getMeta('pk') as $pkf) {
if (!isset($fields[$pkf])) {
return null;
}
}
$annotations = $this->queryset->annotations;
$extras = array();
// For annotations, drop them from the $fields list and add them to
// an $extras list. The fields passed to the root model should only
// be the root model's fields. The annotated fields will be wrapped
// using an AnnotatedModel instance.
if ($annotations && $modelClass == $this->model) {
if (array_key_exists($name, $fields)) {
$extras[$name] = $fields[$name];
unset($fields[$name]);
}
}
}
// Check the cache for the model instance first
if (!($m = self::checkCache($modelClass, $fields))) {
// Construct and cache the object
$m = $modelClass::$meta->newInstance($fields);
// XXX: defer may refer to fields not in this model
$m->__deferred__ = $this->queryset->defer;
$m->__onload();
if ($cache)
$this->cache($m);
}
// Wrap annotations in an AnnotatedModel
if ($extras) {
$m = new AnnotatedModel($m, $extras);
// TODO: If the model has deferred fields which are in $fields,
// those can be resolved here
return $m;
}
/**
* buildModel
*
* This method builds the model including related models from the record
* received. For related recordsets, a $map should be setup inside this
* object prior to using this method. The $map is assumed to have this
* configuration:
*
* array(array(<fieldNames>, <modelClass>, <relativePath>))
*
* Where $modelClass is the name of the foreign (with respect to the
* root model ($this->model), $fieldNames is the number and names of
* fields in the row for this model, $relativePath is the path that
* describes the relationship between the root model and this model,
* 'user__account' for instance.
function buildModel($row) {
// TODO: Traverse to foreign keys
if ($this->map) {
if ($this->model != $this->map[0][1])
throw new OrmException('Internal select_related error');
$offset = 0;
foreach ($this->map as $info) {
@list($fields, $model_class, $path) = $info;
$values = array_slice($row, $offset, count($fields));
$record = array_combine($fields, $values);
if (!$path) {
// Build the root model
$model = $this->getOrBuild($this->model, $record);
$i = 0;
// Traverse the declared path and link the related model
$tail = array_pop($path);
$m = $model;
foreach ($path as $field) {
if (!($m = $m->get($field)))
break;
if ($m)
$m->set($tail, $this->getOrBuild($model_class, $record));
$model = $this->getOrBuild($this->model, $row);
$func = ($this->map) ? 'getRow' : 'getArray';
while ($this->resource && $index >= count($this->cache)) {
if ($row = $this->resource->{$func}()) {
$this->cache[] = $this->buildModel($row);
} else {
$this->resource->close();
$this->resource = false;
function prime() {
parent::prime();
if ($this->resource) {
$this->map = $this->resource->getMap();
}
}
class FlatArrayIterator extends ResultSet {
while ($this->resource && $index >= count($this->cache)) {
if ($row = $this->resource->getRow()) {
} else {
$this->resource->close();
$this->resource = false;
break;
}
}
}
}
class HashArrayIterator extends ResultSet {
function fillTo($index) {
while ($this->resource && $index >= count($this->cache)) {
if ($row = $this->resource->getArray()) {
$this->cache[] = $row;
} else {
$this->resource->close();
$this->resource = false;
break;
}
}
}
}
class InstrumentedList extends ModelInstanceManager {
var $key;
function __construct($fkey, $queryset=false) {
list($model, $this->key) = $fkey;
$queryset = $model::objects()->filter($this->key);
if ($related = $model::getMeta('select_related'))
$queryset->select_related($related);
}
parent::__construct($queryset);
function add($object, $at=false) {
if (!$object || !$object instanceof $this->model)
throw new Exception(sprintf(
'Attempting to add invalid object to list. Expected <%s>, but got <%s>',
$this->model,
get_class($object)
));
foreach ($this->key as $field=>$value)
$object->set($field, $value);
if (!$object->__new__)
$object->save();
if ($at !== false)
$this->cache[$at] = $object;
else
$this->cache[] = $object;
function remove($object, $delete=true) {
if ($delete)
$object->delete();
else
foreach ($this->key as $field=>$value)
$object->set($field, null);
function reset() {
$this->cache = array();
/**
* Slight edit to the standard ::next() iteration method which will skip
* deleted items.
*/
function next() {
do {
parent::next();
}
while ($this->valid() && $this->current()->__deleted__);
}
/**
* Reduce the list to a subset using a simply key/value constraint. New
* items added to the subset will have the constraint automatically
* added to all new items.
*/
function window($constraint) {
$model = $this->model;
$fields = $model::getMeta()->getFieldNames();
$key = $this->key;
foreach ($constraint as $field=>$value) {
if (!is_string($field) || false === in_array($field, $fields))
throw new OrmException('InstrumentedList windowing must be performed on local fields only');
$key[$field] = $value;
}
return new static(array($this->model, $key), $this->filter($constraint));
}
1731
1732
1733
1734
1735
1736
1737
1738
1739
1740
1741
1742
1743
1744
1745
1746
1747
1748
1749
1750
1751
1752
1753
1754
1755
1756
1757
1758
/**
* Find the first item in the current set which matches the given criteria.
* This would be used in favor of ::filter() which might trigger another
* database query. The criteria is intended to be quite simple and should
* not traverse relationships which have not already been fetched.
* Otherwise, the ::filter() or ::window() methods would provide better
* performance.
*
* Example:
* >>> $a = new User();
* >>> $a->roles->add(Role::lookup(['name' => 'administator']));
* >>> $a->roles->findFirst(['roles__name__startswith' => 'admin']);
* <Role: administrator>
*/
function findFirst(array $criteria) {
foreach ($this as $record) {
$matches = true;
foreach ($criteria as $field=>$check) {
if (!SqlCompiler::evaluate($record, $field, $check)) {
$matches = false;
break;
}
}
if ($matches)
return $record;
}
}
1759
1760
1761
1762
1763
1764
1765
1766
1767
1768
1769
1770
1771
1772
1773
1774
1775
1776
1777
1778
1779
1780
1781
1782
1783
1784
1785
1786
1787
1788
1789
1790
1791
1792
1793
1794
1795
1796
1797
1798
1799
1800
1801
1802
1803
1804
1805
1806
1807
1808
1809
1810
/**
* Sort the instrumented list in place. This would be useful to change the
* sorting order of the items in the list without fetching the list from
* the database again.
*
* Parameters:
* $key - (callable|int) A callable function to produce the sort keys
* or one of the SORT_ constants used by the array_multisort
* function
* $reverse - (bool) true if the list should be sorted descending
*
* Returns:
* This instrumented list for chaining and inlining.
*/
function sort($key=false, $reverse=false) {
// Fetch all records into the cache
$this->asArray();
if (is_callable($key)) {
array_multisort(
array_map($key, $this->cache),
$reverse ? SORT_DESC : SORT_ASC,
$this->cache);
}
elseif ($key) {
array_multisort($this->cache,
$reverse ? SORT_DESC : SORT_ASC, $key);
}
elseif ($reverse) {
rsort($this->cache);
}
else
sort($this->cache);
return $this;
}
/**
* Reverse the list item in place. Returns this object for chaining
*/
function reverse() {
$this->asArray();
array_reverse($this->cache);
return $this;
}
// Save all changes made to any list items
function saveAll() {
foreach ($this as $I)
if (!$I->save())
return false;
return true;
}
// QuerySet delegates
function count() {
return $this->objects()->count();
}
function exists() {
return $this->queryset->exists();
}
function expunge() {
if ($this->queryset->delete())
$this->reset();
function update(array $what) {
return $this->queryset->update($what);
}
// Fetch a new QuerySet
function objects() {
return clone $this->queryset;
function offsetUnset($a) {
$this->fillTo($a);
$this->cache[$a]->delete();
}
function offsetSet($a, $b) {
$this->fillTo($a);
$this->cache[$a]->delete();
$this->add($b, $a);
function __call($what, $how) {
return call_user_func_array(array($this->objects(), $what), $how);
var $joins = array();
var $aliases = array();
var $alias_num = 1;
function __construct($options=false) {
if ($options)
$this->options = array_merge($this->options, $options);
if ($options['subquery'])
$this->alias_num += 150;
}
function getParent() {
return $this->options['parent'];
/**
* Split a criteria item into the identifying pieces: path, field, and
* operator.
*/
static function splitCriteria($criteria) {
static $operators = array(
'exact' => 1, 'isnull' => 1,
'gt' => 1, 'lt' => 1, 'gte' => 1, 'lte' => 1, 'range' => 1,
'contains' => 1, 'like' => 1, 'startswith' => 1, 'endswith' => 1, 'regex' => 1,
1878
1879
1880
1881
1882
1883
1884
1885
1886
1887
1888
1889
1890
1891
1892
1893
1894
1895
1896
1897
1898
1899
1900
1901
1902
1903
1904
1905
1906
1907
1908
1909
1910
1911
1912
1913
1914
1915
'in' => 1, 'intersect' => 1,
'hasbit' => 1,
);
$path = explode('__', $criteria);
if (!isset($options['table'])) {
$field = array_pop($path);
if (isset($operators[$field])) {
$operator = $field;
$field = array_pop($path);
}
}
return array($field, $path, $operator ?: 'exact');
}
/**
* Check if the values match given the operator.
*
* Throws:
* OrmException - if $operator is not supported
*/
static function evaluate($record, $field, $check) {
static $ops; if (!isset($ops)) { $ops = array(
'exact' => function($a, $b) { return is_string($a) ? strcasecmp($a, $b) == 0 : $a == $b; },
'isnull' => function($a, $b) { return is_null($a) == $b; },
'gt' => function($a, $b) { return $a > $b; },
'gte' => function($a, $b) { return $a >= $b; },
'lt' => function($a, $b) { return $a < $b; },
'lte' => function($a, $b) { return $a <= $b; },
'contains' => function($a, $b) { return stripos($a, $b) !== false; },
'startswith' => function($a, $b) { return stripos($a, $b) === 0; },
'hasbit' => function($a, $b) { return $a & $b == $b; },
); }
list($field, $path, $operator) = self::splitCriteria($field);
if (!isset($ops[$operator]))
throw new OrmException($operator.': Unsupported operator');
if ($path)
$record = $record->getByPath($path);
// TODO: Support Q expressions
return $ops[$operator]($record->get($field), $check);
}
1920
1921
1922
1923
1924
1925
1926
1927
1928
1929
1930
1931
1932
1933
1934
1935
1936
1937
1938
1939
1940
1941
1942
1943
1944
1945
1946
1947
1948
1949
1950
1951
1952
1953
1954
1955
1956
1957
1958
1959
1960
1961
1962
1963
1964
/**
* Handles breaking down a field or model search descriptor into the
* model search path, field, and operator parts. When used in a queryset
* filter, an expression such as
*
* user__email__hostname__contains => 'foobar'
*
* would be broken down to search from the root model (passed in,
* perhaps a ticket) to the user and email models by inspecting the
* model metadata 'joins' property. The 'constraint' value found there
* will be used to build the JOIN sql clauses.
*
* The 'hostname' will be the field on 'email' model that should be
* compared in the WHERE clause. The comparison should be made using a
* 'contains' function, which in MySQL, might be implemented using
* something like "<lhs> LIKE '%foobar%'"
*
* This function will rely heavily on the pushJoin() function which will
* handle keeping track of joins made previously in the query and
* therefore prevent multiple joins to the same table for the same
* reason. (Self joins are still supported).
*
* Comparison functions supported by this function are defined for each
* respective SqlCompiler subclass; however at least these functions
* should be defined:
*
* function a__function => b
* ----------+------------------------------------------------
* exact | a is exactly equal to b
* gt | a is greater than b
* lte | b is greater than a
* lt | a is less than b
* gte | b is less than a
* ----------+------------------------------------------------
* contains | (string) b is contained within a
* statswith | (string) first len(b) chars of a are exactly b
* endswith | (string) last len(b) chars of a are exactly b
* like | (string) a matches pattern b
* ----------+------------------------------------------------
* in | a is in the list or the nested queryset b
* ----------+------------------------------------------------
* isnull | a is null (if b) else a is not null
*
* If no comparison function is declared in the field descriptor,
* 'exact' is assumed.
*
* Parameters:
* $field - (string) name of the field to join
* $model - (VerySimpleModel) root model for references in the $field
* parameter
* $options - (array) extra options for the compiler
* 'table' => return the table alias rather than the field-name
* 'model' => return the target model class rather than the operator
* 'constraint' => extra constraint for join clause
*
* Returns:
* (mixed) Usually array<field-name, operator> where field-name is the
* name of the field in the destination model, and operator is the
* requestion comparison method.
*/
function getField($field, $model, $options=array()) {
// Break apart the field descriptor by __ (double-underbars). The
// first part is assumed to be the root field in the given model.
// The parts after each of the __ pieces are links to other tables.
// The last item (after the last __) is allowed to be an operator
// specifiction.
list($field, $parts, $op) = static::splitCriteria($field);
$operator = static::$operators[$op];
$rootModel = $model;
// Call pushJoin for each segment in the join path. A new JOIN
// fragment will need to be emitted and/or cached
$joins = array();
$push = function($p, $model) use (&$joins, &$path) {
$J = $model::getMeta('joins');
if (!($info = $J[$p])) {
throw new OrmException(sprintf(
'Model `%s` does not have a relation called `%s`',
$model, $p));
}
$crumb = $path;
$path = ($path) ? "{$path}__{$p}" : $p;
$joins[] = array($crumb, $path, $model, $info);
// Roll to foreign model
return $info['fkey'];
foreach ($parts as $p) {
list($model) = $push($p, $model);
}
// If comparing a relationship, join the foreign table
// This is a comparison with a relationship — use the foreign key
$J = $model::getMeta('joins');
if (isset($J[$field])) {
list($model, $field) = $push($field, $model);
}
// Apply the joins list to $this->pushJoin
$last = count($joins) - 1;
$constraint = false;
foreach ($joins as $i=>$A) {
// Add the conststraint as the last arg to the last join
if ($i == $last)
$constraint = $options['constraint'];
$alias = $this->pushJoin($A[0], $A[1], $A[2], $A[3], $constraint);
}
if (!isset($alias)) {
// Determine the alias for the root model table
$alias = (isset($this->joins['']))
? $this->joins['']['alias']
: $this->quote($rootModel::getMeta('table'));
if (isset($options['table']) && $options['table'])
elseif (isset($this->annotations[$field]))
$field = $this->annotations[$field];
elseif ($alias)
$field = $alias.'.'.$this->quote($field);
if (isset($options['model']) && $options['model'])
$operator = $model;
/**
* Uses the compiler-specific `compileJoin` function to compile the join
* statement fragment, and caches the result in the local $joins list. A
* new alias is acquired using the `nextAlias` function which will be
* associated with the join. If the same path is requested again, the
* algorithm is short-circuited and the originally-assigned table alias
* is returned immediately.
*/
function pushJoin($tip, $path, $model, $info, $constraint=false) {
// TODO: Build the join statement fragment and return the table
// alias. The table alias will be useful where the join is used in
// the WHERE and ORDER BY clauses
// If the join already exists for the statement-being-compiled, just
// return the alias being used.
if (!$constraint && isset($this->joins[$path]))
return $this->joins[$path]['alias'];
// TODO: Support only using aliases if necessary. Use actual table
// names for everything except oddities like self-joins
$alias = $this->nextAlias();
// Keep an association between the table alias and the model. This
// will make model construction much easier when we have the data
// and the table alias from the database.
$this->aliases[$alias] = $model;
// TODO: Stash joins and join constraints into local ->joins array.
// This will be useful metadata in the executor to construct the
// final models for fetching
// TODO: Always use a table alias. This will further help with
// coordination between the data returned from the database (where
// table alias is available) and the corresponding data.
$T = array('alias' => $alias);
$this->joins[$path] = $T;
$this->joins[$path]['sql'] = $this->compileJoin($tip, $model, $alias, $info, $constraint);
2089
2090
2091
2092
2093
2094
2095
2096
2097
2098
2099
2100
2101
2102
2103
2104
2105
2106
2107
2108
2109
2110
/**
* compileQ
*
* Build a constraint represented in an arbitrarily nested Q instance.
* The placement of the compiled constraint is also considered and
* represented in the resulting CompiledExpression instance.
*
* Parameters:
* $Q - (Q) constraint represented in a Q instance
* $model - (VerySimpleModel) root model for all the field references in
* the Q instance
* $slot - (int) slot for inputs to be placed. Useful to differenciate
* inputs placed in the joins and where clauses for SQL engines
* which do not support named parameters.
*
* Returns:
* (CompiledExpression) object containing the compiled expression (with
* AND, OR, and NOT operators added). Furthermore, the $type attribute
* of the CompiledExpression will allow the compiler to place the
* constraint properly in the WHERE or HAVING clause appropriately.
*/
function compileQ(Q $Q, $model, $slot=false) {
$type = CompiledExpression::TYPE_WHERE;
foreach ($Q->constraints as $field=>$value) {
// Handle nested constraints
if ($value instanceof Q) {
$filter[] = $T = $this->compileQ($value, $model, $slot);
// Bubble up HAVING constraints
if ($T instanceof CompiledExpression
&& $T->type == CompiledExpression::TYPE_HAVING)
$type = $T->type;
// Handle relationship comparisons with model objects
elseif ($value instanceof VerySimpleModel) {
$criteria = array();
foreach ($value->pk as $f=>$v) {
$f = $field . '__' . $f;
$criteria[$f] = $v;
}
$filter[] = $this->compileQ(new Q($criteria), $model, $slot);
}
// Handle simple field = <value> constraints
list($field, $op) = $this->getField($field, $model);
if ($field instanceof SqlAggregate) {
// This constraint has to go in the HAVING clause
$field = $field->toSql($this, $model);
$type = CompiledExpression::TYPE_HAVING;
}
if ($value === null)
$filter[] = sprintf('%s IS NULL', $field);
elseif ($value instanceof SqlField)
$filter[] = sprintf($op, $field, $value->toSql($this, $model));
// Allow operators to be callable rather than sprintf
// strings
$filter[] = call_user_func($op, $field, $value, $model);
$filter[] = sprintf($op, $field, $this->input($value, $slot));
$glue = $Q->isOred() ? ' OR ' : ' AND ';
$clause = implode($glue, $filter);
if (count($filter) > 1)
$clause = '(' . $clause . ')';
if ($Q->isNegated())
$clause = 'NOT '.$clause;
return new CompiledExpression($clause, $type);
}
function compileConstraints($where, $model) {
$constraints = array();
foreach ($where as $Q) {
$constraints[] = $this->compileQ($Q, $model);
}
}
function getParams() {
return $this->params;
}
function getJoins($queryset) {
foreach ($this->joins as $path => $j) {
if (!$j['sql'])
continue;
list($base, $constraints) = $j['sql'];
// Add in path-specific constraints, if any
if (isset($queryset->path_constraints[$path])) {
foreach ($queryset->path_constraints[$path] as $Q) {
$constraints[] = $this->compileQ($Q, $queryset->model);
}
}
$sql .= $base;
if ($constraints)
$sql .= ' ON ('.implode(' AND ', $constraints).')';
}
// Add extra items from QuerySet
if (isset($queryset->extra['tables'])) {
foreach ($queryset->extra['tables'] as $S) {
$join = ' JOIN ';
// Left joins require an ON () clause
if ($lastparen = strrpos($S, '(')) {
if (preg_match('/\bon\b/i', substr($S, $lastparen - 4, 4)))
$join = ' LEFT' . $join;
}
$sql .= $join.$S;
}
}
Loading
Loading full blame...