A function class to represent a join and create the SQL necessary to implement the join. More...

Inheritance diagram for views_join:

Public Member Functions
	construct ($table=NULL, $left_table=NULL, $left_field=NULL, $field=NULL, $extra=array(), $type= 'LEFT')
	Construct the views_join object.
	build_join ($select_query, $table, $view_query)
	Build the SQL for the join this object represents.
Public Attributes
	$table = NULL
	$left_table = NULL
	$left_field = NULL
	$field = NULL
	$extra = NULL
	$type = NULL
	$definition = array()

Detailed Description

A function class to represent a join and create the SQL necessary to implement the join.

This is the Delegation pattern. If we had PHP5 exclusively, we would declare this an interface.

Extensions of this class can be used to create more interesting joins.

join definition

table: table to join (right table)
field: field to join on (right field)
left_table: The table we join to
left_field: The field we join to
type: either LEFT (default) or INNER
extra: An array of extra conditions on the join. Each condition is either a string that's directly added, or an array of items:
- table: if not set, current table; if NULL, no table. This field can't be set in the cached definition because it can't know aliases; this field can only be used by realtime joins.
- field: Field or formula in formulas we can reference the right table by using alias
See also:
SelectQueryInterface::addJoin()
- operator: defaults to =
- value: Must be set. If an array, operator will be defaulted to IN.
- numeric: If true, the value will not be surrounded in quotes.
- extra type: How all the extras will be combined. Either AND or OR. Defaults to AND.

Definition at line 1439 of file handlers.inc.

Member Function Documentation

views_join::build_join	(	$	select_query,
		$	table,
		$	view_query
	)

Build the SQL for the join this object represents.

Parameters:

	$select_query	An implementation of SelectQueryInterface.
	$table	The base table to join.
	$view_query	The source query, implementation of views_plugin_query.

Returns:

Reimplemented in views_join_subquery.

Definition at line 1491 of file handlers.inc.

                                                          {
    if (empty($this->definition['table formula'])) {
      $right_table = $this->table;
    }
    else {
      $right_table = $this->definition['table formula'];
    }

    if ($this->left_table) {
      $left = $view_query->get_table_info($this->left_table);
      $left_field = "$left[alias].$this->left_field";
    }
    else {
      // This can be used if left_field is a formula or something. It should be used only *very* rarely.
      $left_field = $this->left_field;
    }

    $condition = "$left_field = $table[alias].$this->field";
    $arguments = array();

    // Tack on the extra.
    if (isset($this->extra)) {
      if (is_array($this->extra)) {
        $extras = array();
        foreach ($this->extra as $info) {
          $extra = '';
          // Figure out the table name. Remember, only use aliases provided
          // if at all possible.
          $join_table = '';
          if (!array_key_exists('table', $info)) {
            $join_table = $table['alias'] . '.';
          }
          elseif (isset($info['table'])) {
            $join_table = $info['table'] . '.';
          }

          // Convert a single-valued array of values to the single-value case,
          // and transform from IN() notation to = notation
          if (is_array($info['value']) && count($info['value']) == 1) {
            if (empty($info['operator'])) {
              $operator = '=';
            }
            else {
              $operator = $info['operator'] == 'NOT IN' ? '!=' : '=';
            }
            $info['value'] = array_shift($info['value']);
          }

          if (is_array($info['value'])) {
            // With an array of values, we need multiple placeholders and the
            // 'IN' operator is implicit.
            foreach ($info['value'] as $value) {
              $placeholder_i = ':views_join_condition_' . $select_query->nextPlaceholder();
              $arguments[$placeholder_i] = $value;
            }

            $operator = !empty($info['operator']) ? $info['operator'] : 'IN';
            $placeholder = '( ' . implode(', ', array_keys($arguments)) . ' )';
          }
          else {
            // With a single value, the '=' operator is implicit.
            $operator = !empty($info['operator']) ? $info['operator'] : '=';
            $placeholder = ':views_join_condition_' . $select_query->nextPlaceholder();
            $arguments[$placeholder] = $info['value'];
          }

          $extras[] = "$join_table$info[field] $operator $placeholder";
        }

        if ($extras) {
          if (count($extras) == 1) {
            $condition .= ' AND ' . array_shift($extras);
          }
          else {
            $condition .= ' AND (' . implode(' ' . $this->extra_type . ' ', $extras) . ')';
          }
        }
      }
      elseif ($this->extra && is_string($this->extra)) {
        $condition .= " AND ($this->extra)";
      }
    }

    $select_query->addJoin($this->type, $right_table, $table['alias'], $condition, $arguments);
  }

views_join::construct	(	$	table = `NULL`,
		$	left_table = `NULL`,
		$	left_field = `NULL`,
		$	field = `NULL`,
		$	extra = `array()`,
		$	type = `'LEFT'`
	)

Construct the views_join object.

Reimplemented in views_join_subquery.

Definition at line 1451 of file handlers.inc.

                                                                                                                             {
    $this->extra_type = 'AND';
    if (!empty($table)) {
      $this->table = $table;
      $this->left_table = $left_table;
      $this->left_field = $left_field;
      $this->field = $field;
      $this->extra = $extra;
      $this->type = strtoupper($type);
    }
    elseif (!empty($this->definition)) {
      // if no arguments, construct from definition.
      // These four must exist or it will throw notices.
      $this->table = $this->definition['table'];
      $this->left_table = $this->definition['left_table'];
      $this->left_field = $this->definition['left_field'];
      $this->field = $this->definition['field'];
      if (!empty($this->definition['extra'])) {
        $this->extra = $this->definition['extra'];
      }
      if (!empty($this->definition['extra type'])) {
        $this->extra_type = strtoupper($this->definition['extra type']);
      }

      $this->type = !empty($this->definition['type']) ? strtoupper($this->definition['type']) : 'LEFT';
    }
  }

The documentation for this class was generated from the following file:

includes/handlers.inc

views_join Class Reference [Views' join handlers]

Public Member Functions

Public Attributes

Detailed Description

Member Function Documentation

views_join Class Reference
[Views' join handlers]