class DatabaseCondition

class DatabaseCondition  implements QueryConditionInterface, Countable {
 
 /**
 * Array of conditions.
 *
 * @var array
 */
 protected $conditions = array();
 
 /**
 * Array of arguments.
 *
 * @var array
 */
 protected $arguments = array();
 
 /**
 * Whether the conditions have been changed.
 *
 * TRUE if the condition has been changed since the last compile.
 * FALSE if the condition has been compiled and not changed.
 *
 * @var bool
 */
 protected $changed = TRUE;
 
 /**
 * The identifier of the query placeholder this condition has been compiled against.
 */
 protected $queryPlaceholderIdentifier;
 
 /**
 * Contains the string version of the Condition.
 *
 * @var string
 */
 protected $stringVersion;
 
 /**
 * Constructs a DataBaseCondition object.
 *
 * @param string $conjunction
 * The operator to use to combine conditions: 'AND' or 'OR'.
 */
 public function __construct($conjunction) {
 $this->conditions ['#conjunction'] = $conjunction;
 }
 
 /**
 * Implements Countable::count().
 *
 * Returns the size of this conditional. The size of the conditional is the
 * size of its conditional array minus one, because one element is the
 * conjunction.
 */
 public function count () {
 return count ($this->conditions ) - 1;
 }
 
 /**
 * Implements QueryConditionInterface::condition().
 */
 public function condition($field, $value = NULL, $operator = NULL) {
 if (!isset($operator)) {
 if (is_array ($value)) {
 $operator = 'IN';
 }
 elseif (!isset($value)) {
 $operator = 'IS NULL';
 }
 else {
 $operator = '=';
 }
 }
 $this->conditions [] = array(
 'field' => $field,
 'value' => $value,
 'operator' => $operator,
 );
 $this->changed  = TRUE;
 return $this;
 }
 
 /**
 * Implements QueryConditionInterface::where().
 */
 public function where($snippet, $args = array()) {
 $this->conditions [] = array(
 'field' => $snippet,
 'value' => $args,
 'operator' => NULL,
 );
 $this->changed  = TRUE;
 return $this;
 }
 
 /**
 * Implements QueryConditionInterface::isNull().
 */
 public function isNull($field) {
 return $this->condition ($field);
 }
 
 /**
 * Implements QueryConditionInterface::isNotNull().
 */
 public function isNotNull($field) {
 return $this->condition ($field, NULL, 'IS NOT NULL');
 }
 
 /**
 * Implements QueryConditionInterface::exists().
 */
 public function exists(SelectQueryInterface $select) {
 return $this->condition ('', $select, 'EXISTS');
 }
 
 /**
 * Implements QueryConditionInterface::notExists().
 */
 public function notExists(SelectQueryInterface $select) {
 return $this->condition ('', $select, 'NOT EXISTS');
 }
 
 /**
 * Implements QueryConditionInterface::conditions().
 */
 public function &conditions() {
 return $this->conditions ;
 }
 
 /**
 * Implements QueryConditionInterface::arguments().
 */
 public function arguments() {
 // If the caller forgot to call compile() first, refuse to run.
 if ($this->changed ) {
 return NULL;
 }
 return $this->arguments ;
 }
 
 /**
 * Implements QueryConditionInterface::compile().
 *
 * @throws InvalidQueryConditionOperatorException
 */
 public function compile(DatabaseConnection $connection, QueryPlaceholderInterface $queryPlaceholder) {
 // Re-compile if this condition changed or if we are compiled against a
 // different query placeholder object.
 if ($this->changed  || isset($this->queryPlaceholderIdentifier ) && $this->queryPlaceholderIdentifier  != $queryPlaceholder->uniqueIdentifier ()) {
 $this->queryPlaceholderIdentifier  = $queryPlaceholder->uniqueIdentifier ();
 $condition_fragments = array();
 $arguments = array();
 $conditions = $this->conditions ;
 $conjunction = $conditions['#conjunction'];
 unset($conditions['#conjunction']);
 foreach ($conditions as $condition) {
 if (empty($condition['operator'])) {
 // This condition is a literal string, so let it through as is.
 $condition_fragments[] = ' (' . $condition['field'] . ') ';
 $arguments += $condition['value'];
 }
 else {
 // It's a structured condition, so parse it out accordingly.
 // Note that $condition['field'] will only be an object for a dependent
 // DatabaseCondition object, not for a dependent subquery.
 if ($condition['field'] instanceof QueryConditionInterface) {
 // Compile the sub-condition recursively and add it to the list.
 $condition['field']->compile ($connection, $queryPlaceholder);
 $condition_fragments[] = '(' . (string) $condition['field'] . ')';
 $arguments += $condition['field']->arguments ();
 }
 else {
 // If the operator contains an invalid character, throw an
 // exception to protect against SQL injection attempts.
 if (stripos ($condition['operator'], 'UNION') !== FALSE || strpbrk ($condition['operator'], '[-\'"();') !== FALSE) {
 throw new InvalidQueryConditionOperatorException ('Invalid characters in query operator: ' . $condition['operator']);
 }
 // For simplicity, we treat all operators as the same data structure.
 // In the typical degenerate case, this won't get changed.
 $operator_defaults = array(
 'prefix' => '',
 'postfix' => '',
 'delimiter' => '',
 'operator' => $condition['operator'],
 'use_value' => TRUE,
 );
 $operator = $connection->mapConditionOperator ($condition['operator']);
 if (!isset($operator)) {
 $operator = $this->mapConditionOperator ($condition['operator']);
 }
 $operator += $operator_defaults;
 $placeholders = array();
 if ($condition['value'] instanceof SelectQueryInterface) {
 $condition['value']->compile ($connection, $queryPlaceholder);
 $placeholders[] = (string) $condition['value'];
 $arguments += $condition['value']->arguments ();
 // Subqueries are the actual value of the operator, we don't
 // need to add another below.
 $operator['use_value'] = FALSE;
 }
 elseif (!$operator['delimiter']) {
 $condition['value'] = array(
 $condition['value'],
 );
 }
 if ($operator['use_value']) {
 foreach ($condition['value'] as $value) {
 $placeholder = ':db_condition_placeholder_' . $queryPlaceholder->nextPlaceholder ();
 $arguments[$placeholder] = $value;
 $placeholders[] = $placeholder;
 }
 }
 $condition_fragments[] = ' (' . $connection->escapeField ($condition['field']) . ' ' . $operator['operator'] . ' ' . $operator['prefix'] . implode ($operator['delimiter'], $placeholders) . $operator['postfix'] . ') ';
 }
 }
 }
 $this->changed  = FALSE;
 $this->stringVersion  = implode ($conjunction, $condition_fragments);
 $this->arguments  = $arguments;
 }
 }
 
 /**
 * Implements QueryConditionInterface::compiled().
 */
 public function compiled() {
 return !$this->changed ;
 }
 
 /**
 * Implements PHP magic __toString method to convert the conditions to string.
 *
 * @return string
 * A string version of the conditions.
 */
 public function __toString() {
 // If the caller forgot to call compile() first, refuse to run.
 if ($this->changed ) {
 return '';
 }
 return $this->stringVersion ;
 }
 
 /**
 * PHP magic __clone() method.
 *
 * Only copies fields that implement QueryConditionInterface. Also sets
 * $this->changed to TRUE.
 */
 function __clone() {
 $this->changed  = TRUE;
 foreach ($this->conditions  as $key => $condition) {
 if ($key !== '#conjunction') {
 if ($condition['field'] instanceof QueryConditionInterface) {
 $this->conditions [$key]['field'] = clone $condition['field'];
 }
 if ($condition['value'] instanceof SelectQueryInterface) {
 $this->conditions [$key]['value'] = clone $condition['value'];
 }
 }
 }
 }
 
 /**
 * Gets any special processing requirements for the condition operator.
 *
 * Some condition types require special processing, such as IN, because
 * the value data they pass in is not a simple value. This is a simple
 * overridable lookup function.
 *
 * @param $operator
 * The condition operator, such as "IN", "BETWEEN", etc. Case-sensitive.
 *
 * @return
 * The extra handling directives for the specified operator, or NULL.
 */
 protected function mapConditionOperator($operator) {
 // $specials does not use drupal_static as its value never changes.
 static $specials = array(
 'BETWEEN' => array(
 'delimiter' => ' AND ',
 ),
 'IN' => array(
 'delimiter' => ', ',
 'prefix' => ' (',
 'postfix' => ')',
 ),
 'NOT IN' => array(
 'delimiter' => ', ',
 'prefix' => ' (',
 'postfix' => ')',
 ),
 'EXISTS' => array(
 'prefix' => ' (',
 'postfix' => ')',
 ),
 'NOT EXISTS' => array(
 'prefix' => ' (',
 'postfix' => ')',
 ),
 'IS NULL' => array(
 'use_value' => FALSE,
 ),
 'IS NOT NULL' => array(
 'use_value' => FALSE,
 ),
 // Use backslash for escaping wildcard characters.
'LIKE' => array(
 'postfix' => " ESCAPE '\\\\'",
 ),
 'NOT LIKE' => array(
 'postfix' => " ESCAPE '\\\\'",
 ),
 // These ones are here for performance reasons.
'=' => array(),
 '<' => array(),
 '>' => array(),
 '>=' => array(),
 '<=' => array(),
 );
 if (isset($specials[$operator])) {
 $return = $specials[$operator];
 }
 else {
 // We need to upper case because PHP index matches are case sensitive but
 // do not need the more expensive drupal_strtoupper because SQL statements are ASCII.
 $operator = strtoupper ($operator);
 $return = isset($specials[$operator]) ? $specials[$operator] : array();
 }
 $return += array(
 'operator' => $operator,
 );
 return $return;
 }
}