QuerySegmentListProcessor.php

<?php
/**
 * adds $this->joinConditions and $this->fromTables
 * to the original QuerySegmentListProcessor for the
 * use with SearchPanes
 */
namespace SRF\DataTables;

use RuntimeException;
use SMW\MediaWiki\Database;
use SMW\SQLStore\QueryEngine\QuerySegment;
use SMW\SQLStore\TableBuilder\TemporaryTableBuilder;
use SMWQuery as Query;

class QuerySegmentListProcessor {
	/* @var array */
	public $joinConditions = [];

	/* @var array */
	public $fromTables = [];

	/**
	 * @var Database
	 */
	private $connection;

	/**
	 * @var TemporaryTableBuilder
	 */
	private $temporaryTableBuilder;

	/**
	 * @var HierarchyTempTableBuilder
	 */
	private $hierarchyTempTableBuilder;

	/**
	 * Array of arrays of executed queries, indexed by the temporary table names
	 * results were fed into.
	 *
	 * @var array
	 */
	private $executedQueries = [];

	/**
	 * Query mode copied from given query. Some submethods act differently when
	 * in Query::MODE_DEBUG.
	 *
	 * @var int
	 */
	private $queryMode;

	/**
	 * @var array
	 */
	private $querySegmentList = [];

	/**
	 * @param Database $connection
	 * @param TemporaryTableBuilder $temporaryTableBuilder
	 * @param HierarchyTempTableBuilder $hierarchyTempTableBuilder
	 */
	public function __construct( $connection, TemporaryTableBuilder $temporaryTableBuilder, $hierarchyTempTableBuilder ) {
		$this->connection = $connection;
		$this->temporaryTableBuilder = $temporaryTableBuilder;
		$this->hierarchyTempTableBuilder = $hierarchyTempTableBuilder;
	}

	/**
	 * @since 2.2
	 *
	 * @return array
	 */
	public function getExecutedQueries() {
		return $this->executedQueries;
	}

	/**
	 * @since 2.2
	 *
	 * @param &$querySegmentList
	 */
	public function setQuerySegmentList( &$querySegmentList ) {
		$this->querySegmentList =& $querySegmentList;
	}

	/**
	 * @since 2.2
	 *
	 * @param int $queryMode
	 */
	public function setQueryMode( $queryMode ) {
		$this->queryMode = $queryMode;
	}

	/**
	 * Process stored queries and change store accordingly. The query obj is modified
	 * so that it contains non-recursive description of a select to execute for getting
	 * the actual result.
	 *
	 * @param int $id
	 *
	 * @throws RuntimeException
	 */
	public function process( $id ) {
		$this->hierarchyTempTableBuilder->emptyHierarchyCache();
		$this->executedQueries = [];

		// Should never happen
		if ( !isset( $this->querySegmentList[$id] ) ) {
			throw new RuntimeException( "$id doesn't exist" );
		}

		$this->segment( $this->querySegmentList[$id] );
	}

	private function segment( QuerySegment &$query ) {
		switch ( $query->type ) {
			case QuerySegment::Q_TABLE: // .
				$this->table( $query );
				break;
			case QuerySegment::Q_CONJUNCTION:
				$this->conjunction( $query );
				break;
			case QuerySegment::Q_DISJUNCTION:
				$this->disjunction( $query );
				break;
			case QuerySegment::Q_PROP_HIERARCHY:
			case QuerySegment::Q_CLASS_HIERARCHY: // make a saturated hierarchy
				$this->hierarchy( $query );
				break;
			case QuerySegment::Q_VALUE:
				break; // nothing to do
		}
	}

	/**
	 * Resolves normal queries with possible conjunctive subconditions
	 */
	private function table( QuerySegment &$query ) {
		foreach ( $query->components as $qid => $joinField ) {
			$subQuery = $this->querySegmentList[$qid];
			$this->segment( $subQuery );
			$alias = $subQuery->alias;

			if ( $subQuery->joinTable !== '' ) { // Join with jointable.joinfield
				$op = $subQuery->not ? '!' : '';

				$joinType = $subQuery->joinType ? $subQuery->joinType : 'INNER';
				$t = $this->connection->tableName( $subQuery->joinTable ) . " AS $subQuery->alias";
				// If the alias is the same as the table name and if there is a prefix, MediaWiki does not declare the unprefixed alias
				$joinTable = $subQuery->joinTable === $subQuery->alias ? $this->connection->tableName( $subQuery->joinTable ) : $subQuery->joinTable;

				if ( $subQuery->from ) {
					$t = "($t $subQuery->from)";
					$alias = 'nested' . $subQuery->alias;
					$query->fromTables[$alias] = array_merge( (array)$subQuery->fromTables, [ $subQuery->alias => $joinTable ] );
					$query->joinConditions = array_merge( (array)$query->joinConditions, (array)$subQuery->joinConditions );

				} else {
					$query->fromTables[$alias] = $joinTable;
				}

				$query->joinConditions[$alias] = [ $joinType . ' JOIN', "$joinField$op=" . $subQuery->joinfield ];

				$this->fromTables[$subQuery->alias] = $joinTable;

				ksort( $this->fromTables );
				$this->joinConditions[$subQuery->alias] = [ $joinType . ' JOIN', "$joinField$op=" . $subQuery->joinfield ];

				$query->from .= " $joinType JOIN $t ON $joinField$op=" . $subQuery->joinfield;
				if ( $joinType === 'LEFT' ) {
					$query->where .= ( ( $query->where === '' ) ? '' : ' AND ' ) . '(' . $subQuery->joinfield . ' IS NULL)';
				}

			} elseif ( $subQuery->joinfield !== '' ) { // Require joinfield as "value" via WHERE.
				$condition = '';

				if ( $subQuery->null === true ) {
						$condition .= ( $condition ? ' OR ' : '' ) . "$joinField IS NULL";
				} else {
					foreach ( $subQuery->joinfield as $value ) {
						$op = $subQuery->not ? '!' : '';
						$condition .= ( $condition ? ' OR ' : '' ) . "$joinField$op=" . $this->connection->addQuotes( $value );
					}
				}

				if ( count( $subQuery->joinfield ) > 1 ) {
					$condition = "($condition)";
				}

				$query->where .= ( ( $query->where === '' || $subQuery->where === null ) ? '' : ' AND ' ) . $condition;
				$query->from .= $subQuery->from;
				$query->fromTables = array_merge( (array)$query->fromTables, (array)$subQuery->fromTables );
				$query->joinConditions = array_merge( (array)$query->joinConditions, (array)$subQuery->joinConditions );
			} else { // interpret empty joinfields as impossible condition (empty result)
				$query->joinfield = ''; // make whole query false
				$query->joinTable = '';
				$query->where = '';
				$query->from = '';
				$query->fromTables = [];
				$query->joinConditions = [];
				break;
			}

			if ( $subQuery->where !== '' && $subQuery->where !== null ) {
				if ( $subQuery->joinType === 'LEFT' || $subQuery->joinType == 'LEFT OUTER' ) {
					$query->from .= ' AND (' . $subQuery->where . ')';
					$query->joinConditions[$alias][1] .= ' AND (' . $subQuery->where . ')';
				} else {
					$query->where .= ( ( $query->where === '' ) ? '' : ' AND ' ) . '(' . $subQuery->where . ')';
				}
			}
		}

		$query->components = [];
	}

	private function conjunction( QuerySegment &$query ) {
		reset( $query->components );
		$key = false;

		// Pick one subquery as anchor point ...
		foreach ( $query->components as $qkey => $qid ) {
			$key = $qkey;

			if ( $this->querySegmentList[$qkey]->joinTable !== '' ) {
				break;
			}
		}

		$result = $this->querySegmentList[$key];
		unset( $query->components[$key] );

		// Execute it first (may change jointable and joinfield, e.g. when
		// making temporary tables)
		$this->segment( $result );

		// ... and append to this query the remaining queries.
		foreach ( $query->components as $qid => $joinfield ) {
			$result->components[$qid] = $result->joinfield;
		}

		// Second execute, now incorporating remaining conditions.
		$this->segment( $result );

		$query = $result;
	}

	private function disjunction( QuerySegment &$query ) {
		if ( $this->queryMode !== Query::MODE_NONE ) {
			$this->temporaryTableBuilder->create( $this->connection->tableName( $query->alias ) );
		}

		$this->executedQueries[$query->alias] = [];

		foreach ( $query->components as $qid => $joinField ) {
			$subQuery = $this->querySegmentList[$qid];
			$this->segment( $subQuery );
			$sql = '';

			if ( $subQuery->joinTable !== '' ) {
				$sql = 'INSERT ' . 'IGNORE ' . 'INTO ' .
					   $this->connection->tableName( $query->alias ) .
					   " SELECT DISTINCT $subQuery->joinfield FROM " . $this->connection->tableName( $subQuery->joinTable ) .
					   " AS $subQuery->alias $subQuery->from" . ( $subQuery->where ? " WHERE $subQuery->where" : '' );
			} elseif ( $subQuery->joinfield !== '' ) {
				// NOTE: this works only for single "unconditional" values without further
				// WHERE or FROM. The execution must take care of not creating any others.
				$values = '';

				// This produces an error on postgres with
				// pg_query(): Query failed: ERROR:  duplicate key value violates
				// unique constraint "sunittest_t3_pkey" DETAIL:  Key (id)=(274) already exists.

				foreach ( $subQuery->joinfield as $value ) {
					$values .= ( $values ? ',' : '' ) . '(' . $this->connection->addQuotes( $value ) . ')';
				}

				$sql = 'INSERT ' . 'IGNORE ' . 'INTO ' . $this->connection->tableName( $query->alias ) . " (id) VALUES $values";
			} // else: // interpret empty joinfields as impossible condition (empty result), ignore

			if ( $sql ) {
				$this->executedQueries[$query->alias][] = $sql;

				if ( $this->queryMode !== Query::MODE_NONE ) {
					$this->connection->query(
						$sql,
						__METHOD__,
						ISQLPlatform::QUERY_CHANGE_ROWS
					);
				}
			}
		}

		$query->type = QuerySegment::Q_TABLE;
		$query->where = '';
		$query->components = [];

		$query->joinTable = $query->alias;
		$query->joinfield = "$query->alias.id";
		$query->sortfields = []; // Make sure we got no sortfields.

		// TODO: currently this eliminates sortkeys, possibly keep them (needs
		// different temp table format though, maybe not such a good thing to do)
	}

	/**
	 * Find subproperties or subcategories. This may require iterative computation,
	 * and temporary tables are used in many cases.
	 *
	 * @param QuerySegment &$query
	 */
	private function hierarchy( QuerySegment &$query ) {
		switch ( $query->type ) {
			case QuerySegment::Q_PROP_HIERARCHY:
				$type = 'property';
				break;
			case QuerySegment::Q_CLASS_HIERARCHY:
				$type = 'class';
				break;
		}

		[ $smwtable, $depth ] = $this->hierarchyTempTableBuilder->getTableDefinitionByType(
			$type
		);

		// An individual depth was annotated as part of the query
		if ( $query->depth !== null ) {
			$depth = $query->depth;
		}

		if ( $depth <= 0 ) { // treat as value, no recursion
			$query->type = QuerySegment::Q_VALUE;
			return;
		}

		$values = '';
		$valuecond = '';

		foreach ( $query->joinfield as $value ) {
			$values .= ( $values ? ',' : '' ) . '(' . $this->connection->addQuotes( $value ) . ')';
			$valuecond .= ( $valuecond ? ' OR ' : '' ) . 'o_id=' . $this->connection->addQuotes( $value );
		}

		// Try to safe time (SELECT is cheaper than creating/dropping 3 temp tables):
		$res = $this->connection->select(
			$smwtable,
			's_id',
			$valuecond,
			__METHOD__,
			[ 'LIMIT' => 1 ]
		);

		if ( !$res->fetchObject() ) { // no subobjects, we are done!
			$res->free();
			$query->type = QuerySegment::Q_VALUE;
			return;
		}

		$res->free();
		$tablename = $this->connection->tableName( $query->alias );
		$this->executedQueries[$query->alias] = [
			"Recursively computed hierarchy for element(s) $values.",
			"SELECT s_id FROM $smwtable WHERE $valuecond LIMIT 1"
		];

		$query->joinTable = $query->alias;
		$query->joinfield = "$query->alias.id";

		$this->hierarchyTempTableBuilder->fillTempTable(
			$type,
			$tablename,
			$values,
			$depth
		);
	}

	/**
	 * After querying, make sure no temporary database tables are left.
	 *
	 * @todo I might be better to keep the tables and possibly reuse them later
	 * on. Being temporary, the tables will vanish with the session anyway.
	 */
	public function cleanUp() {
		foreach ( $this->executedQueries as $table => $log ) {
			$this->temporaryTableBuilder->drop( $this->connection->tableName( $table ) );
		}
	}
}