2016-09-26 07:22:19 +02:00
|
|
|
<?php
|
|
|
|
|
|
|
|
|
|
|
|
namespace SilverStripe\ORM;
|
|
|
|
|
|
|
|
use SilverStripe\Core\Injector\Injectable;
|
|
|
|
use SilverStripe\Core\Injector\Injector;
|
|
|
|
use SilverStripe\ORM\Queries\SQLSelect;
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Injected into DataQuery to augment getFinalisedQuery() with a join table
|
|
|
|
*/
|
|
|
|
class ManyManyThroughQueryManipulator implements DataQueryManipulator
|
|
|
|
{
|
|
|
|
|
|
|
|
use Injectable;
|
|
|
|
|
|
|
|
/**
|
|
|
|
* DataObject that backs the joining table
|
|
|
|
*
|
|
|
|
* @var string
|
|
|
|
*/
|
|
|
|
protected $joinClass;
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Key that joins to the data class
|
|
|
|
*
|
|
|
|
* @var string $localKey
|
|
|
|
*/
|
|
|
|
protected $localKey;
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Key that joins to the parent class
|
|
|
|
*
|
|
|
|
* @var string $foreignKey
|
|
|
|
*/
|
|
|
|
protected $foreignKey;
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Build query manipulator for a given join table. Additional parameters (foreign key, etc)
|
|
|
|
* will be infered at evaluation from query parameters set via the ManyManyThroughList
|
|
|
|
*
|
|
|
|
* @param string $joinClass Class name of the joined dataobject record
|
|
|
|
* @param string $localKey The key in the join table that maps to the dataClass' PK.
|
|
|
|
* @param string $foreignKey The key in the join table that maps to joined class' PK.
|
|
|
|
*/
|
|
|
|
public function __construct($joinClass, $localKey, $foreignKey)
|
|
|
|
{
|
|
|
|
$this->setJoinClass($joinClass);
|
|
|
|
$this->setLocalKey($localKey);
|
|
|
|
$this->setForeignKey($foreignKey);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @return string
|
|
|
|
*/
|
|
|
|
public function getJoinClass()
|
|
|
|
{
|
|
|
|
return $this->joinClass;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @param mixed $joinClass
|
|
|
|
* @return $this
|
|
|
|
*/
|
|
|
|
public function setJoinClass($joinClass)
|
|
|
|
{
|
|
|
|
$this->joinClass = $joinClass;
|
|
|
|
return $this;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @return string
|
|
|
|
*/
|
|
|
|
public function getLocalKey()
|
|
|
|
{
|
|
|
|
return $this->localKey;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @param string $localKey
|
|
|
|
* @return $this
|
|
|
|
*/
|
|
|
|
public function setLocalKey($localKey)
|
|
|
|
{
|
|
|
|
$this->localKey = $localKey;
|
|
|
|
return $this;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @return string
|
|
|
|
*/
|
|
|
|
public function getForeignKey()
|
|
|
|
{
|
|
|
|
return $this->foreignKey;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @param string $foreignKey
|
|
|
|
* @return $this
|
|
|
|
*/
|
|
|
|
public function setForeignKey($foreignKey)
|
|
|
|
{
|
|
|
|
$this->foreignKey = $foreignKey;
|
|
|
|
return $this;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Get has_many relationship between parent and join table (for a given DataQuery)
|
|
|
|
*
|
|
|
|
* @param DataQuery $query
|
|
|
|
* @return HasManyList
|
|
|
|
*/
|
|
|
|
public function getParentRelationship(DataQuery $query) {
|
|
|
|
// Create has_many
|
|
|
|
$list = HasManyList::create($this->getJoinClass(), $this->getForeignKey());
|
|
|
|
$list = $list->setDataQueryParam($this->extractInheritableQueryParameters($query));
|
|
|
|
|
|
|
|
// Limit to given foreign key
|
|
|
|
if ($foreignID = $query->getQueryParam('Foreign.ID')) {
|
|
|
|
$list = $list->forForeignID($foreignID);
|
|
|
|
}
|
|
|
|
return $list;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Calculate the query parameters that should be inherited from the base many_many
|
|
|
|
* to the nested has_many list.
|
|
|
|
*
|
|
|
|
* @param DataQuery $query
|
|
|
|
* @return mixed
|
|
|
|
*/
|
|
|
|
public function extractInheritableQueryParameters(DataQuery $query) {
|
|
|
|
$params = $query->getQueryParams();
|
|
|
|
|
|
|
|
// Remove `Foreign.` query parameters for created objects,
|
|
|
|
// as this would interfere with relations on those objects.
|
|
|
|
foreach(array_keys($params) as $key) {
|
|
|
|
if(stripos($key, 'Foreign.') === 0) {
|
|
|
|
unset($params[$key]);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// Get inheritable parameters from an instance of the base query dataclass
|
|
|
|
$inst = Injector::inst()->create($query->dataClass());
|
|
|
|
$inst->setSourceQueryParams($params);
|
|
|
|
return $inst->getInheritableQueryParams();
|
|
|
|
}
|
|
|
|
|
2016-10-03 03:51:34 +02:00
|
|
|
/**
|
|
|
|
* Get name of join table alias for use in queries.
|
|
|
|
*
|
|
|
|
* @return string
|
|
|
|
*/
|
|
|
|
public function getJoinAlias() {
|
|
|
|
return $this->getJoinClass();
|
|
|
|
}
|
|
|
|
|
2016-09-26 07:22:19 +02:00
|
|
|
/**
|
|
|
|
* Invoked prior to getFinalisedQuery()
|
|
|
|
*
|
|
|
|
* @param DataQuery $dataQuery
|
|
|
|
* @param array $queriedColumns
|
|
|
|
* @param SQLSelect $sqlSelect
|
|
|
|
*/
|
|
|
|
public function beforeGetFinalisedQuery(DataQuery $dataQuery, $queriedColumns = [], SQLSelect $sqlSelect)
|
|
|
|
{
|
|
|
|
// Get metadata and SQL from join table
|
|
|
|
$hasManyRelation = $this->getParentRelationship($dataQuery);
|
|
|
|
$joinTableSQLSelect = $hasManyRelation->dataQuery()->query();
|
|
|
|
$joinTableSQL = $joinTableSQLSelect->sql($joinTableParameters);
|
|
|
|
$joinTableColumns = array_keys($joinTableSQLSelect->getSelect()); // Get aliases (keys) only
|
2016-10-03 03:51:34 +02:00
|
|
|
$joinTableAlias = $this->getJoinAlias();
|
2016-09-26 07:22:19 +02:00
|
|
|
|
|
|
|
// Get fields to join on
|
|
|
|
$localKey = $this->getLocalKey();
|
|
|
|
$schema = DataObject::getSchema();
|
|
|
|
$baseTable = $schema->baseDataClass($dataQuery->dataClass());
|
|
|
|
$childField = $schema->sqlColumnForField($baseTable, 'ID');
|
|
|
|
|
|
|
|
// Add select fields
|
|
|
|
foreach($joinTableColumns as $joinTableColumn) {
|
|
|
|
$sqlSelect->selectField(
|
|
|
|
"\"{$joinTableAlias}\".\"{$joinTableColumn}\"",
|
|
|
|
"{$joinTableAlias}_{$joinTableColumn}"
|
|
|
|
);
|
|
|
|
}
|
|
|
|
|
|
|
|
// Apply join and record sql for later insertion (at end of replacements)
|
|
|
|
$sqlSelect->addInnerJoin(
|
|
|
|
'(SELECT $$_SUBQUERY_$$)',
|
|
|
|
"\"{$joinTableAlias}\".\"{$localKey}\" = {$childField}",
|
|
|
|
$joinTableAlias,
|
|
|
|
20,
|
|
|
|
$joinTableParameters
|
|
|
|
);
|
|
|
|
$dataQuery->setQueryParam('Foreign.JoinTableSQL', $joinTableSQL);
|
|
|
|
|
|
|
|
// After this join, and prior to afterGetFinalisedQuery, $sqlSelect will be populated with the
|
|
|
|
// necessary sql rewrites (versioned, etc) that effect the base table.
|
|
|
|
// By using a placeholder for the subquery we can protect the subquery (already rewritten)
|
|
|
|
// from being re-written a second time. However we DO want the join predicate (above) to be rewritten.
|
|
|
|
// See http://php.net/manual/en/function.str-replace.php#refsect1-function.str-replace-notes
|
|
|
|
// for the reason we only add the final substitution at the end of getFinalisedQuery()
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Invoked after getFinalisedQuery()
|
|
|
|
*
|
|
|
|
* @param DataQuery $dataQuery
|
|
|
|
* @param array $queriedColumns
|
|
|
|
* @param SQLSelect $sqlQuery
|
|
|
|
*/
|
|
|
|
public function afterGetFinalisedQuery(DataQuery $dataQuery, $queriedColumns = [], SQLSelect $sqlQuery)
|
|
|
|
{
|
|
|
|
// Inject final replacement after manipulation has been performed on the base dataquery
|
|
|
|
$joinTableSQL = $dataQuery->getQueryParam('Foreign.JoinTableSQL');
|
|
|
|
if ($joinTableSQL) {
|
|
|
|
$sqlQuery->replaceText('SELECT $$_SUBQUERY_$$', $joinTableSQL);
|
|
|
|
$dataQuery->setQueryParam('Foreign.JoinTableSQL', null);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|