2006-06-30 03:04:39 +04:00
|
|
|
<?php
|
|
|
|
require_once("Condition.php");
|
|
|
|
|
2006-12-29 17:40:47 +03:00
|
|
|
class Doctrine_Query_Where extends Doctrine_Query_Condition
|
|
|
|
{
|
2006-06-30 03:04:39 +04:00
|
|
|
/**
|
2006-07-05 02:36:22 +04:00
|
|
|
* load
|
2006-06-30 03:04:39 +04:00
|
|
|
* returns the parsed query part
|
|
|
|
*
|
|
|
|
* @param string $where
|
|
|
|
* @return string
|
|
|
|
*/
|
2006-12-29 17:40:47 +03:00
|
|
|
public function load($where)
|
|
|
|
{
|
2006-10-12 00:44:21 +04:00
|
|
|
$where = trim($where);
|
|
|
|
|
|
|
|
$e = Doctrine_Query::sqlExplode($where);
|
|
|
|
|
2006-12-29 17:01:31 +03:00
|
|
|
if (count($e) > 1) {
|
2006-10-12 00:44:21 +04:00
|
|
|
$tmp = $e[0].' '.$e[1];
|
|
|
|
|
2006-12-29 17:01:31 +03:00
|
|
|
if (substr($tmp, 0, 6) == 'EXISTS') {
|
2006-10-12 00:44:21 +04:00
|
|
|
return $this->parseExists($where, true);
|
2006-12-29 17:01:31 +03:00
|
|
|
} elseif (substr($where, 0, 10) == 'NOT EXISTS') {
|
2006-10-12 00:44:21 +04:00
|
|
|
return $this->parseExists($where, false);
|
2006-12-29 17:01:31 +03:00
|
|
|
}
|
2006-10-12 00:44:21 +04:00
|
|
|
}
|
2006-07-05 02:36:22 +04:00
|
|
|
|
2006-12-29 17:01:31 +03:00
|
|
|
if (count($e) < 3) {
|
2006-10-08 23:10:21 +04:00
|
|
|
$e = Doctrine_Query::sqlExplode($where, array('=', '<', '>', '!='));
|
|
|
|
}
|
2006-06-30 03:04:39 +04:00
|
|
|
$r = array_shift($e);
|
2006-10-08 23:10:21 +04:00
|
|
|
|
2006-10-27 00:53:59 +04:00
|
|
|
$a = explode('.', $r);
|
2006-06-30 03:04:39 +04:00
|
|
|
|
2006-12-29 17:01:31 +03:00
|
|
|
if (count($a) > 1) {
|
2006-06-30 03:04:39 +04:00
|
|
|
$field = array_pop($a);
|
2006-07-05 02:36:22 +04:00
|
|
|
$count = count($e);
|
|
|
|
$slice = array_slice($e, -1, 1);
|
|
|
|
$value = implode('', $slice);
|
2006-10-08 23:10:21 +04:00
|
|
|
$operator = trim(substr($where, strlen($r), -strlen($value)));
|
2006-07-05 02:36:22 +04:00
|
|
|
|
2006-12-14 16:26:16 +03:00
|
|
|
$reference = implode('.', $a);
|
2006-06-30 03:04:39 +04:00
|
|
|
$count = count($a);
|
|
|
|
|
2006-12-28 14:56:24 +03:00
|
|
|
$pos = strpos($field, '(');
|
2006-09-14 00:47:29 +04:00
|
|
|
|
2006-12-29 17:01:31 +03:00
|
|
|
if ($pos !== false) {
|
2006-09-15 14:04:22 +04:00
|
|
|
$func = substr($field, 0, $pos);
|
2006-10-06 20:50:00 +04:00
|
|
|
$value = trim(substr($field, ($pos + 1), -1));
|
2006-09-15 14:04:22 +04:00
|
|
|
|
|
|
|
$values = Doctrine_Query::sqlExplode($value, ',');
|
|
|
|
|
|
|
|
$field = array_pop($a);
|
2006-12-14 16:26:16 +03:00
|
|
|
$reference = implode('.', $a);
|
2006-09-15 14:04:22 +04:00
|
|
|
$table = $this->query->load($reference, false);
|
2006-09-15 01:10:02 +04:00
|
|
|
array_pop($a);
|
|
|
|
$reference2 = implode('.', $a);
|
2006-09-15 14:04:22 +04:00
|
|
|
$alias = $this->query->getTableAlias($reference2);
|
2006-09-14 00:47:29 +04:00
|
|
|
|
2006-09-15 01:10:02 +04:00
|
|
|
$stack = $this->query->getRelationStack();
|
|
|
|
$relation = end($stack);
|
2006-12-29 17:01:31 +03:00
|
|
|
|
2006-09-15 01:10:02 +04:00
|
|
|
$stack = $this->query->getTableStack();
|
|
|
|
|
2006-12-29 17:01:31 +03:00
|
|
|
switch ($func) {
|
2006-12-30 00:30:37 +03:00
|
|
|
case 'contains':
|
|
|
|
case 'regexp':
|
|
|
|
case 'like':
|
|
|
|
$operator = $this->getOperator($func);
|
|
|
|
|
|
|
|
if (empty($relation)) {
|
|
|
|
throw new Doctrine_Query_Exception('DQL functions contains/regexp/like can only be used for fields of related components');
|
|
|
|
}
|
|
|
|
$where = array();
|
|
|
|
foreach ($values as $value) {
|
|
|
|
$where[] = $alias.'.'.$relation->getLocal().
|
|
|
|
' IN (SELECT '.$relation->getForeign().
|
|
|
|
' FROM '.$relation->getTable()->getTableName().' WHERE '.$field.$operator.$value.')';
|
|
|
|
}
|
|
|
|
$where = implode(' AND ', $where);
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
throw new Doctrine_Query_Exception('Unknown DQL function: '.$func);
|
2006-09-15 01:10:02 +04:00
|
|
|
}
|
|
|
|
} else {
|
|
|
|
$table = $this->query->load($reference, false);
|
|
|
|
$alias = $this->query->getTableAlias($reference);
|
|
|
|
$table = $this->query->getTable($alias);
|
2006-10-27 00:53:59 +04:00
|
|
|
// check if value is enumerated value
|
|
|
|
$enumIndex = $table->enumIndex($field, trim($value, "'"));
|
|
|
|
|
2006-12-29 17:01:31 +03:00
|
|
|
if (substr($value, 0, 1) == '(') {
|
2006-10-27 00:53:59 +04:00
|
|
|
// trim brackets
|
|
|
|
$trimmed = Doctrine_Query::bracketTrim($value);
|
|
|
|
|
2006-12-29 17:01:31 +03:00
|
|
|
if (substr($trimmed, 0, 4) == 'FROM' || substr($trimmed, 0, 6) == 'SELECT') {
|
2006-10-27 00:53:59 +04:00
|
|
|
// subquery found
|
|
|
|
$q = new Doctrine_Query();
|
|
|
|
$value = '(' . $q->parseQuery($trimmed)->getQuery() . ')';
|
2006-12-29 17:01:31 +03:00
|
|
|
} elseif (substr($trimmed, 0, 4) == 'SQL:') {
|
2006-10-27 00:53:59 +04:00
|
|
|
$value = '(' . substr($trimmed, 4) . ')';
|
|
|
|
} else {
|
|
|
|
// simple in expression found
|
|
|
|
$e = Doctrine_Query::sqlExplode($trimmed, ',');
|
2006-12-29 17:01:31 +03:00
|
|
|
|
2006-10-27 00:53:59 +04:00
|
|
|
$value = array();
|
2006-12-29 17:01:31 +03:00
|
|
|
foreach ($e as $part) {
|
2006-10-27 00:53:59 +04:00
|
|
|
$index = $table->enumIndex($field, trim($part, "'"));
|
2006-12-29 17:01:31 +03:00
|
|
|
if ($index !== false) {
|
2006-10-27 00:53:59 +04:00
|
|
|
$value[] = $index;
|
2006-12-29 17:01:31 +03:00
|
|
|
} else {
|
2006-10-27 00:53:59 +04:00
|
|
|
$value[] = $this->parseLiteralValue($part);
|
2006-12-29 17:01:31 +03:00
|
|
|
}
|
2006-10-12 00:44:21 +04:00
|
|
|
}
|
2006-10-27 00:53:59 +04:00
|
|
|
$value = '(' . implode(', ', $value) . ')';
|
2006-10-12 00:44:21 +04:00
|
|
|
}
|
2006-10-27 00:53:59 +04:00
|
|
|
} else {
|
2006-12-29 17:01:31 +03:00
|
|
|
if ($enumIndex !== false) {
|
2006-10-27 00:53:59 +04:00
|
|
|
$value = $enumIndex;
|
2006-12-29 17:01:31 +03:00
|
|
|
} else {
|
2006-10-27 00:53:59 +04:00
|
|
|
$value = $this->parseLiteralValue($value);
|
2006-12-29 17:01:31 +03:00
|
|
|
}
|
2006-10-06 20:50:00 +04:00
|
|
|
}
|
2006-09-15 01:10:02 +04:00
|
|
|
|
2006-12-29 17:01:31 +03:00
|
|
|
switch ($operator) {
|
2006-12-30 00:30:37 +03:00
|
|
|
case '<':
|
|
|
|
case '>':
|
|
|
|
case '=':
|
|
|
|
case '!=':
|
|
|
|
if ($enumIndex !== false) {
|
|
|
|
$value = $enumIndex;
|
|
|
|
}
|
|
|
|
default:
|
|
|
|
$where = $alias.'.'.$field.' '.$operator.' '.$value;
|
2006-09-15 01:10:02 +04:00
|
|
|
}
|
2006-09-14 00:47:29 +04:00
|
|
|
}
|
2006-10-08 23:10:21 +04:00
|
|
|
}
|
2006-06-30 03:04:39 +04:00
|
|
|
return $where;
|
|
|
|
}
|
2006-10-27 01:32:52 +04:00
|
|
|
/**
|
|
|
|
* parses a literal value and returns the parsed value
|
2006-12-29 17:01:31 +03:00
|
|
|
*
|
2006-10-27 01:32:52 +04:00
|
|
|
* boolean literals are parsed to integers
|
|
|
|
* components are parsed to associated table aliases
|
|
|
|
*
|
|
|
|
* @param string $value literal value to be parsed
|
|
|
|
* @return string
|
|
|
|
*/
|
2006-12-29 17:40:47 +03:00
|
|
|
public function parseLiteralValue($value)
|
|
|
|
{
|
2006-10-27 00:53:59 +04:00
|
|
|
// check that value isn't a string
|
2006-12-29 17:01:31 +03:00
|
|
|
if (strpos($value, '\'') === false) {
|
2006-10-27 00:53:59 +04:00
|
|
|
// parse booleans
|
2006-12-29 17:01:31 +03:00
|
|
|
if ($value == 'true')
|
2006-10-27 00:53:59 +04:00
|
|
|
$value = 1;
|
2006-12-29 17:01:31 +03:00
|
|
|
elseif ($value == 'false')
|
2006-10-27 00:53:59 +04:00
|
|
|
$value = 0;
|
|
|
|
|
|
|
|
$a = explode('.', $value);
|
|
|
|
|
2006-12-29 17:01:31 +03:00
|
|
|
if (count($a) > 1) {
|
2006-10-27 00:53:59 +04:00
|
|
|
// either a float or a component..
|
2006-12-29 17:01:31 +03:00
|
|
|
|
|
|
|
if ( ! is_numeric($a[0])) {
|
2006-10-27 00:53:59 +04:00
|
|
|
// a component found
|
|
|
|
$value = $this->query->getTableAlias($a[0]). '.' . $a[1];
|
|
|
|
}
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
// string literal found
|
|
|
|
}
|
2006-06-30 03:04:39 +04:00
|
|
|
|
2006-10-27 00:53:59 +04:00
|
|
|
return $value;
|
|
|
|
}
|
2006-10-27 01:32:52 +04:00
|
|
|
/**
|
|
|
|
* parses an EXISTS expression
|
|
|
|
*
|
|
|
|
* @param string $where query where part to be parsed
|
|
|
|
* @param boolean $negation whether or not to use the NOT keyword
|
|
|
|
* @return string
|
|
|
|
*/
|
2006-12-29 17:40:47 +03:00
|
|
|
public function parseExists($where, $negation)
|
|
|
|
{
|
2006-10-12 00:44:21 +04:00
|
|
|
$operator = ($negation) ? 'EXISTS' : 'NOT EXISTS';
|
|
|
|
|
|
|
|
$pos = strpos($where, '(');
|
2006-12-29 17:01:31 +03:00
|
|
|
|
|
|
|
if ($pos == false)
|
2006-10-12 00:44:21 +04:00
|
|
|
throw new Doctrine_Query_Exception("Unknown expression, expected '('");
|
|
|
|
|
|
|
|
$sub = Doctrine_Query::bracketTrim(substr($where, $pos));
|
|
|
|
|
|
|
|
return $operator . ' ('.$this->query->createSubquery()->parseQuery($sub, false)->getQuery() . ')';
|
|
|
|
}
|
2006-12-14 16:26:16 +03:00
|
|
|
/**
|
|
|
|
* getOperator
|
|
|
|
*
|
|
|
|
* @param string $func
|
|
|
|
* @return string
|
|
|
|
*/
|
2006-12-29 17:40:47 +03:00
|
|
|
public function getOperator($func)
|
|
|
|
{
|
2006-12-29 17:01:31 +03:00
|
|
|
switch ($func) {
|
2006-12-30 00:30:37 +03:00
|
|
|
case 'contains':
|
|
|
|
$operator = ' = ';
|
|
|
|
break;
|
|
|
|
case 'regexp':
|
|
|
|
$operator = $this->query->getConnection()->getRegexpOperator();
|
|
|
|
break;
|
|
|
|
case 'like':
|
|
|
|
$operator = ' LIKE ';
|
|
|
|
break;
|
2006-09-15 14:04:22 +04:00
|
|
|
}
|
|
|
|
return $operator;
|
|
|
|
}
|
2006-12-28 14:56:24 +03:00
|
|
|
/**
|
|
|
|
* __toString
|
|
|
|
* return string representation of this object
|
|
|
|
*
|
|
|
|
* @return string
|
|
|
|
*/
|
2006-12-29 17:40:47 +03:00
|
|
|
public function __toString()
|
|
|
|
{
|
2006-12-14 16:26:16 +03:00
|
|
|
return ( ! empty($this->parts))?implode(' AND ', $this->parts):'';
|
2006-06-30 03:04:39 +04:00
|
|
|
}
|
|
|
|
}
|