No OneTemporary
Actions

Size

56 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/src/applications/diffusion/query/DiffusionCommitQuery.php b/src/applications/diffusion/query/DiffusionCommitQuery.php
	index 8abb67b99f..22331e8510 100644
	--- a/src/applications/diffusion/query/DiffusionCommitQuery.php
	+++ b/src/applications/diffusion/query/DiffusionCommitQuery.php
	@@ -1,566 +1,566 @@
	<?php

	final class DiffusionCommitQuery
	extends PhabricatorCursorPagedPolicyAwareQuery {

	private $ids;
	private $phids;
	private $authorPHIDs;
	private $defaultRepository;
	private $identifiers;
	private $repositoryIDs;
	private $repositoryPHIDs;
	private $identifierMap;

	private $needAuditRequests;
	private $auditIDs;
	private $auditorPHIDs;
	private $auditAwaitingUser;
	private $auditStatus;

	const AUDIT_STATUS_ANY = 'audit-status-any';
	const AUDIT_STATUS_OPEN = 'audit-status-open';
	const AUDIT_STATUS_CONCERN = 'audit-status-concern';
	const AUDIT_STATUS_ACCEPTED = 'audit-status-accepted';
	const AUDIT_STATUS_PARTIAL = 'audit-status-partial';

	private $needCommitData;

	public function withIDs(array $ids) {
	$this->ids = $ids;
	return $this;
	}

	public function withPHIDs(array $phids) {
	$this->phids = $phids;
	return $this;
	}

	public function withAuthorPHIDs(array $phids) {
	$this->authorPHIDs = $phids;
	return $this;
	}

	/**
	* Load commits by partial or full identifiers, e.g. "rXab82393", "rX1234",
	* or "a9caf12". When an identifier matches multiple commits, they will all
	* be returned; callers should be prepared to deal with more results than
	* they queried for.
	*/
	public function withIdentifiers(array $identifiers) {
	$this->identifiers = $identifiers;
	return $this;
	}

	/**
	* Look up commits in a specific repository. This is a shorthand for calling
	* @{method:withDefaultRepository} and @{method:withRepositoryIDs}.
	*/
	public function withRepository(PhabricatorRepository $repository) {
	$this->withDefaultRepository($repository);
	$this->withRepositoryIDs(array($repository->getID()));
	return $this;
	}

	/**
	* Look up commits in a specific repository. Prefer
	* @{method:withRepositoryIDs}; the underyling table is keyed by ID such
	* that this method requires a separate initial query to map PHID to ID.
	*/
	public function withRepositoryPHIDs(array $phids) {
	$this->repositoryPHIDs = $phids;
	}

	/**
	* If a default repository is provided, ambiguous commit identifiers will
	* be assumed to belong to the default repository.
	*
	* For example, "r123" appearing in a commit message in repository X is
	* likely to be unambiguously "rX123". Normally the reference would be
	* considered ambiguous, but if you provide a default repository it will
	* be correctly resolved.
	*/
	public function withDefaultRepository(PhabricatorRepository $repository) {
	$this->defaultRepository = $repository;
	return $this;
	}

	public function withRepositoryIDs(array $repository_ids) {
	$this->repositoryIDs = $repository_ids;
	return $this;
	}

	public function needCommitData($need) {
	$this->needCommitData = $need;
	return $this;
	}

	public function needAuditRequests($need) {
	$this->needAuditRequests = $need;
	return $this;
	}

	/**
	* Returns true if we should join the audit table, either because we're
	* interested in the information if it's available or because matching rows
	* must always have it.
	*/
	private function shouldJoinAudits() {
	return $this->auditStatus \|\|
	$this->rowsMustHaveAudits();
	}

	/**
	* Return true if we should `JOIN` (vs `LEFT JOIN`) the audit table, because
	* matching commits will always have audit rows.
	*/
	private function rowsMustHaveAudits() {
	return
	$this->auditIDs \|\|
	$this->auditorPHIDs \|\|
	$this->auditAwaitingUser;
	}

	public function withAuditIDs(array $ids) {
	$this->auditIDs = $ids;
	return $this;
	}

	public function withAuditorPHIDs(array $auditor_phids) {
	$this->auditorPHIDs = $auditor_phids;
	return $this;
	}

	public function withAuditAwaitingUser(PhabricatorUser $user) {
	$this->auditAwaitingUser = $user;
	return $this;
	}

	public function withAuditStatus($status) {
	$this->auditStatus = $status;
	return $this;
	}

	public function getIdentifierMap() {
	if ($this->identifierMap === null) {
	throw new Exception(
	'You must execute() the query before accessing the identifier map.');
	}
	return $this->identifierMap;
	}

	- protected function getPagingColumn() {
	- return 'commit.id';
	+ protected function getPrimaryTableAlias() {
	+ return 'commit';
	}

	protected function willExecute() {
	if ($this->identifierMap === null) {
	$this->identifierMap = array();
	}
	}

	protected function loadPage() {
	$table = new PhabricatorRepositoryCommit();
	$conn_r = $table->establishConnection('r');

	$data = queryfx_all(
	$conn_r,
	'SELECT commit.* FROM %T commit %Q %Q %Q %Q %Q',
	$table->getTableName(),
	$this->buildJoinClause($conn_r),
	$this->buildWhereClause($conn_r),
	$this->buildGroupClause($conn_r),
	$this->buildOrderClause($conn_r),
	$this->buildLimitClause($conn_r));

	return $table->loadAllFromArray($data);
	}

	protected function willFilterPage(array $commits) {
	$repository_ids = mpull($commits, 'getRepositoryID', 'getRepositoryID');
	$repos = id(new PhabricatorRepositoryQuery())
	->setViewer($this->getViewer())
	->withIDs($repository_ids)
	->execute();

	$min_qualified = PhabricatorRepository::MINIMUM_QUALIFIED_HASH;
	$result = array();

	foreach ($commits as $key => $commit) {
	$repo = idx($repos, $commit->getRepositoryID());
	if ($repo) {
	$commit->attachRepository($repo);
	} else {
	unset($commits[$key]);
	continue;
	}

	// Build the identifierMap
	if ($this->identifiers !== null) {
	$ids = array_fuse($this->identifiers);
	$prefixes = array(
	'r'.$commit->getRepository()->getCallsign(),
	'r'.$commit->getRepository()->getCallsign().':',
	'R'.$commit->getRepository()->getID().':',
	'', // No prefix is valid too and will only match the commitIdentifier
	);
	$suffix = $commit->getCommitIdentifier();

	if ($commit->getRepository()->isSVN()) {
	foreach ($prefixes as $prefix) {
	if (isset($ids[$prefix.$suffix])) {
	$result[$prefix.$suffix][] = $commit;
	}
	}
	} else {
	// This awkward construction is so we can link the commits up in O(N)
	// time instead of O(N^2).
	for ($ii = $min_qualified; $ii <= strlen($suffix); $ii++) {
	$part = substr($suffix, 0, $ii);
	foreach ($prefixes as $prefix) {
	if (isset($ids[$prefix.$part])) {
	$result[$prefix.$part][] = $commit;
	}
	}
	}
	}
	}
	}

	if ($result) {
	foreach ($result as $identifier => $matching_commits) {
	if (count($matching_commits) == 1) {
	$result[$identifier] = head($matching_commits);
	} else {
	// This reference is ambiguous (it matches more than one commit) so
	// don't link it.
	unset($result[$identifier]);
	}
	}
	$this->identifierMap += $result;
	}

	return $commits;
	}

	protected function didFilterPage(array $commits) {
	if ($this->needCommitData) {
	$data = id(new PhabricatorRepositoryCommitData())->loadAllWhere(
	'commitID in (%Ld)',
	mpull($commits, 'getID'));
	$data = mpull($data, null, 'getCommitID');
	foreach ($commits as $commit) {
	$commit_data = idx($data, $commit->getID());
	if (!$commit_data) {
	$commit_data = new PhabricatorRepositoryCommitData();
	}
	$commit->attachCommitData($commit_data);
	}
	}

	// TODO: This should just be `needAuditRequests`, not `shouldJoinAudits()`,
	// but leave that for a future diff.

	if ($this->needAuditRequests \|\| $this->shouldJoinAudits()) {
	$requests = id(new PhabricatorRepositoryAuditRequest())->loadAllWhere(
	'commitPHID IN (%Ls)',
	mpull($commits, 'getPHID'));

	$requests = mgroup($requests, 'getCommitPHID');
	foreach ($commits as $commit) {
	$audit_requests = idx($requests, $commit->getPHID(), array());
	$commit->attachAudits($audit_requests);
	foreach ($audit_requests as $audit_request) {
	$audit_request->attachCommit($commit);
	}
	}
	}

	return $commits;
	}

	private function buildWhereClause(AphrontDatabaseConnection $conn_r) {
	$where = array();

	if ($this->repositoryPHIDs !== null) {
	$map_repositories = id (new PhabricatorRepositoryQuery())
	->setViewer($this->getViewer())
	->withPHIDs($this->repositoryPHIDs)
	->execute();

	if (!$map_repositories) {
	throw new PhabricatorEmptyQueryException();
	}
	$repository_ids = mpull($map_repositories, 'getID');
	if ($this->repositoryIDs !== null) {
	$repository_ids = array_merge($repository_ids, $this->repositoryIDs);
	}
	$this->withRepositoryIDs($repository_ids);
	}

	if ($this->ids !== null) {
	$where[] = qsprintf(
	$conn_r,
	'commit.id IN (%Ld)',
	$this->ids);
	}

	if ($this->phids !== null) {
	$where[] = qsprintf(
	$conn_r,
	'commit.phid IN (%Ls)',
	$this->phids);
	}

	if ($this->repositoryIDs !== null) {
	$where[] = qsprintf(
	$conn_r,
	'commit.repositoryID IN (%Ld)',
	$this->repositoryIDs);
	}

	if ($this->authorPHIDs !== null) {
	$where[] = qsprintf(
	$conn_r,
	'commit.authorPHID IN (%Ls)',
	$this->authorPHIDs);
	}

	if ($this->identifiers !== null) {
	$min_unqualified = PhabricatorRepository::MINIMUM_UNQUALIFIED_HASH;
	$min_qualified = PhabricatorRepository::MINIMUM_QUALIFIED_HASH;

	$refs = array();
	$bare = array();
	foreach ($this->identifiers as $identifier) {
	$matches = null;
	preg_match('/^(?:[rR]([A-Z]+:?\|[0-9]+:))?(.*)$/',
	$identifier, $matches);
	$repo = nonempty(rtrim($matches[1], ':'), null);
	$commit_identifier = nonempty($matches[2], null);

	if ($repo === null) {
	if ($this->defaultRepository) {
	$repo = $this->defaultRepository->getCallsign();
	}
	}

	if ($repo === null) {
	if (strlen($commit_identifier) < $min_unqualified) {
	continue;
	}
	$bare[] = $commit_identifier;
	} else {
	$refs[] = array(
	'callsign' => $repo,
	'identifier' => $commit_identifier,
	);
	}
	}

	$sql = array();

	foreach ($bare as $identifier) {
	$sql[] = qsprintf(
	$conn_r,
	'(commit.commitIdentifier LIKE %> AND '.
	'LENGTH(commit.commitIdentifier) = 40)',
	$identifier);
	}

	if ($refs) {
	$callsigns = ipull($refs, 'callsign');

	$repos = id(new PhabricatorRepositoryQuery())
	->setViewer($this->getViewer())
	->withIdentifiers($callsigns);
	$repos->execute();

	$repos = $repos->getIdentifierMap();

	foreach ($refs as $key => $ref) {
	$repo = idx($repos, $ref['callsign']);

	if (!$repo) {
	continue;
	}

	if ($repo->isSVN()) {
	if (!ctype_digit($ref['identifier'])) {
	continue;
	}
	$sql[] = qsprintf(
	$conn_r,
	'(commit.repositoryID = %d AND commit.commitIdentifier = %s)',
	$repo->getID(),
	// NOTE: Because the 'commitIdentifier' column is a string, MySQL
	// ignores the index if we hand it an integer. Hand it a string.
	// See T3377.
	(int)$ref['identifier']);
	} else {
	if (strlen($ref['identifier']) < $min_qualified) {
	continue;
	}
	$sql[] = qsprintf(
	$conn_r,
	'(commit.repositoryID = %d AND commit.commitIdentifier LIKE %>)',
	$repo->getID(),
	$ref['identifier']);
	}
	}
	}

	if (!$sql) {
	// If we discarded all possible identifiers (e.g., they all referenced
	// bogus repositories or were all too short), make sure the query finds
	// nothing.
	throw new PhabricatorEmptyQueryException(
	pht('No commit identifiers.'));
	}

	$where[] = '('.implode(' OR ', $sql).')';
	}

	if ($this->auditIDs !== null) {
	$where[] = qsprintf(
	$conn_r,
	'audit.id IN (%Ld)',
	$this->auditIDs);
	}

	if ($this->auditorPHIDs !== null) {
	$where[] = qsprintf(
	$conn_r,
	'audit.auditorPHID IN (%Ls)',
	$this->auditorPHIDs);
	}

	if ($this->auditAwaitingUser) {
	$awaiting_user_phid = $this->auditAwaitingUser->getPHID();
	// Exclude package and project audits associated with commits where
	// the user is the author.
	$where[] = qsprintf(
	$conn_r,
	'(commit.authorPHID IS NULL OR commit.authorPHID != %s)
	OR (audit.auditorPHID = %s)',
	$awaiting_user_phid,
	$awaiting_user_phid);
	}

	$status = $this->auditStatus;
	if ($status !== null) {
	switch ($status) {
	case self::AUDIT_STATUS_PARTIAL:
	$where[] = qsprintf(
	$conn_r,
	'commit.auditStatus = %d',
	PhabricatorAuditCommitStatusConstants::PARTIALLY_AUDITED);
	break;
	case self::AUDIT_STATUS_ACCEPTED:
	$where[] = qsprintf(
	$conn_r,
	'commit.auditStatus = %d',
	PhabricatorAuditCommitStatusConstants::FULLY_AUDITED);
	break;
	case self::AUDIT_STATUS_CONCERN:
	$where[] = qsprintf(
	$conn_r,
	'audit.auditStatus = %s',
	PhabricatorAuditStatusConstants::CONCERNED);
	break;
	case self::AUDIT_STATUS_OPEN:
	$where[] = qsprintf(
	$conn_r,
	'audit.auditStatus in (%Ls)',
	PhabricatorAuditStatusConstants::getOpenStatusConstants());
	if ($this->auditAwaitingUser) {
	$where[] = qsprintf(
	$conn_r,
	'awaiting.auditStatus IS NULL OR awaiting.auditStatus != %s',
	PhabricatorAuditStatusConstants::RESIGNED);
	}
	break;
	case self::AUDIT_STATUS_ANY:
	break;
	default:
	$valid = array(
	self::AUDIT_STATUS_ANY,
	self::AUDIT_STATUS_OPEN,
	self::AUDIT_STATUS_CONCERN,
	self::AUDIT_STATUS_ACCEPTED,
	self::AUDIT_STATUS_PARTIAL,
	);
	throw new Exception(
	"Unknown audit status '{$status}'! Valid statuses are: ".
	implode(', ', $valid));
	}
	}

	$where[] = $this->buildPagingClause($conn_r);

	return $this->formatWhereClause($where);
	}

	protected function didFilterResults(array $filtered) {
	if ($this->identifierMap) {
	foreach ($this->identifierMap as $name => $commit) {
	if (isset($filtered[$commit->getPHID()])) {
	unset($this->identifierMap[$name]);
	}
	}
	}
	}

	private function buildJoinClause($conn_r) {
	$joins = array();
	$audit_request = new PhabricatorRepositoryAuditRequest();

	if ($this->shouldJoinAudits()) {
	$joins[] = qsprintf(
	$conn_r,
	'%Q %T audit ON commit.phid = audit.commitPHID',
	($this->rowsMustHaveAudits() ? 'JOIN' : 'LEFT JOIN'),
	$audit_request->getTableName());
	}

	if ($this->auditAwaitingUser) {
	// Join the request table on the awaiting user's requests, so we can
	// filter out package and project requests which the user has resigned
	// from.
	$joins[] = qsprintf(
	$conn_r,
	'LEFT JOIN %T awaiting ON audit.commitPHID = awaiting.commitPHID AND
	awaiting.auditorPHID = %s',
	$audit_request->getTableName(),
	$this->auditAwaitingUser->getPHID());
	}

	if ($joins) {
	return implode(' ', $joins);
	} else {
	return '';
	}
	}

	private function buildGroupClause(AphrontDatabaseConnection $conn_r) {
	$should_group = $this->shouldJoinAudits();

	// TODO: Currently, the audit table is missing a unique key, so we may
	// require a GROUP BY if we perform this join. See T1768. This can be
	// removed once the table has the key.
	if ($this->auditAwaitingUser) {
	$should_group = true;
	}

	if ($should_group) {
	return 'GROUP BY commit.id';
	} else {
	return '';
	}
	}

	public function getQueryApplicationClass() {
	return 'PhabricatorDiffusionApplication';
	}

	}
	diff --git a/src/applications/phrequent/query/PhrequentUserTimeQuery.php b/src/applications/phrequent/query/PhrequentUserTimeQuery.php
	index 06a9028a13..ecf8656fe5 100644
	--- a/src/applications/phrequent/query/PhrequentUserTimeQuery.php
	+++ b/src/applications/phrequent/query/PhrequentUserTimeQuery.php
	@@ -1,335 +1,337 @@
	<?php

	final class PhrequentUserTimeQuery
	extends PhabricatorCursorPagedPolicyAwareQuery {

	const ORDER_ID_ASC = 0;
	const ORDER_ID_DESC = 1;
	const ORDER_STARTED_ASC = 2;
	const ORDER_STARTED_DESC = 3;
	const ORDER_ENDED_ASC = 4;
	const ORDER_ENDED_DESC = 5;
	- const ORDER_DURATION_ASC = 6;
	- const ORDER_DURATION_DESC = 7;

	const ENDED_YES = 0;
	const ENDED_NO = 1;
	const ENDED_ALL = 2;

	+ private $ids;
	private $userPHIDs;
	private $objectPHIDs;
	- private $order = self::ORDER_ID_ASC;
	private $ended = self::ENDED_ALL;

	private $needPreemptingEvents;

	- public function withUserPHIDs($user_phids) {
	+ public function withIDs(array $ids) {
	+ $this->ids = $ids;
	+ return $this;
	+ }
	+
	+ public function withUserPHIDs(array $user_phids) {
	$this->userPHIDs = $user_phids;
	return $this;
	}

	- public function withObjectPHIDs($object_phids) {
	+ public function withObjectPHIDs(array $object_phids) {
	$this->objectPHIDs = $object_phids;
	return $this;
	}

	public function withEnded($ended) {
	$this->ended = $ended;
	return $this;
	}

	public function setOrder($order) {
	- $this->order = $order;
	+ switch ($order) {
	+ case self::ORDER_ID_ASC:
	+ $this->setOrderVector(array('-id'));
	+ break;
	+ case self::ORDER_ID_DESC:
	+ $this->setOrderVector(array('id'));
	+ break;
	+ case self::ORDER_STARTED_ASC:
	+ $this->setOrderVector(array('-start', '-id'));
	+ break;
	+ case self::ORDER_STARTED_DESC:
	+ $this->setOrderVector(array('start', 'id'));
	+ break;
	+ case self::ORDER_ENDED_ASC:
	+ $this->setOrderVector(array('-ongoing', '-end', '-id'));
	+ break;
	+ case self::ORDER_ENDED_DESC:
	+ $this->setOrderVector(array('ongoing', 'end', 'id'));
	+ break;
	+ default:
	+ throw new Exception(pht('Unknown order "%s".', $order));
	+ }
	+
	return $this;
	}

	public function needPreemptingEvents($need_events) {
	$this->needPreemptingEvents = $need_events;
	return $this;
	}

	private function buildWhereClause(AphrontDatabaseConnection $conn) {
	$where = array();

	- if ($this->userPHIDs) {
	+ if ($this->ids !== null) {
	+ $where[] = qsprintf(
	+ $conn,
	+ 'id IN (%Ld)',
	+ $this->ids);
	+ }
	+
	+ if ($this->userPHIDs !== null) {
	$where[] = qsprintf(
	$conn,
	'userPHID IN (%Ls)',
	$this->userPHIDs);
	}

	- if ($this->objectPHIDs) {
	+ if ($this->objectPHIDs !== null) {
	$where[] = qsprintf(
	$conn,
	'objectPHID IN (%Ls)',
	$this->objectPHIDs);
	}

	switch ($this->ended) {
	case self::ENDED_ALL:
	break;
	case self::ENDED_YES:
	$where[] = qsprintf(
	$conn,
	'dateEnded IS NOT NULL');
	break;
	case self::ENDED_NO:
	$where[] = qsprintf(
	$conn,
	'dateEnded IS NULL');
	break;
	default:
	throw new Exception("Unknown ended '{$this->ended}'!");
	}

	$where[] = $this->buildPagingClause($conn);

	return $this->formatWhereClause($where);
	}

	- protected function getPagingColumn() {
	- switch ($this->order) {
	- case self::ORDER_ID_ASC:
	- case self::ORDER_ID_DESC:
	- return 'id';
	- case self::ORDER_STARTED_ASC:
	- case self::ORDER_STARTED_DESC:
	- return 'dateStarted';
	- case self::ORDER_ENDED_ASC:
	- case self::ORDER_ENDED_DESC:
	- return 'dateEnded';
	- case self::ORDER_DURATION_ASC:
	- case self::ORDER_DURATION_DESC:
	- return 'COALESCE(dateEnded, UNIX_TIMESTAMP()) - dateStarted';
	- default:
	- throw new Exception("Unknown order '{$this->order}'!");
	- }
	- }
	-
	- protected function getPagingValue($result) {
	- switch ($this->order) {
	- case self::ORDER_ID_ASC:
	- case self::ORDER_ID_DESC:
	- return $result->getID();
	- case self::ORDER_STARTED_ASC:
	- case self::ORDER_STARTED_DESC:
	- return $result->getDateStarted();
	- case self::ORDER_ENDED_ASC:
	- case self::ORDER_ENDED_DESC:
	- return $result->getDateEnded();
	- case self::ORDER_DURATION_ASC:
	- case self::ORDER_DURATION_DESC:
	- return ($result->getDateEnded() \|\| time()) - $result->getDateStarted();
	- default:
	- throw new Exception("Unknown order '{$this->order}'!");
	- }
	+ public function getOrderableColumns() {
	+ return parent::getOrderableColumns() + array(
	+ 'start' => array(
	+ 'column' => 'dateStarted',
	+ 'type' => 'int',
	+ ),
	+ 'ongoing' => array(
	+ 'column' => 'dateEnded',
	+ 'type' => 'null',
	+ ),
	+ 'end' => array(
	+ 'column' => 'dateEnded',
	+ 'type' => 'int',
	+ ),
	+ );
	}

	- protected function getReversePaging() {
	- switch ($this->order) {
	- case self::ORDER_ID_ASC:
	- case self::ORDER_STARTED_ASC:
	- case self::ORDER_ENDED_ASC:
	- case self::ORDER_DURATION_ASC:
	- return true;
	- case self::ORDER_ID_DESC:
	- case self::ORDER_STARTED_DESC:
	- case self::ORDER_ENDED_DESC:
	- case self::ORDER_DURATION_DESC:
	- return false;
	- default:
	- throw new Exception("Unknown order '{$this->order}'!");
	- }
	+ protected function getPagingValueMap($cursor, array $keys) {
	+ $usertime = $this->loadCursorObject($cursor);
	+ return array(
	+ 'id' => $usertime->getID(),
	+ 'start' => $usertime->getDateStarted(),
	+ 'ongoing' => $usertime->getDateEnded(),
	+ 'end' => $usertime->getDateEnded(),
	+ );
	}

	protected function loadPage() {
	$usertime = new PhrequentUserTime();
	$conn = $usertime->establishConnection('r');

	$data = queryfx_all(
	$conn,
	'SELECT usertime.* FROM %T usertime %Q %Q %Q',
	$usertime->getTableName(),
	$this->buildWhereClause($conn),
	$this->buildOrderClause($conn),
	$this->buildLimitClause($conn));

	return $usertime->loadAllFromArray($data);
	}

	protected function didFilterPage(array $page) {
	if ($this->needPreemptingEvents) {
	$usertime = new PhrequentUserTime();
	$conn_r = $usertime->establishConnection('r');

	$preempt = array();
	foreach ($page as $event) {
	$preempt[] = qsprintf(
	$conn_r,
	'(userPHID = %s AND
	(dateStarted BETWEEN %d AND %d) AND
	(dateEnded IS NULL OR dateEnded > %d))',
	$event->getUserPHID(),
	$event->getDateStarted(),
	nonempty($event->getDateEnded(), PhabricatorTime::getNow()),
	$event->getDateStarted());
	}

	$preempting_events = queryfx_all(
	$conn_r,
	'SELECT * FROM %T WHERE %Q ORDER BY dateStarted ASC, id ASC',
	$usertime->getTableName(),
	implode(' OR ', $preempt));
	$preempting_events = $usertime->loadAllFromArray($preempting_events);

	$preempting_events = mgroup($preempting_events, 'getUserPHID');

	foreach ($page as $event) {
	$e_start = $event->getDateStarted();
	$e_end = $event->getDateEnded();

	$select = array();
	$user_events = idx($preempting_events, $event->getUserPHID(), array());
	foreach ($user_events as $u_event) {
	if ($u_event->getID() == $event->getID()) {
	// Don't allow an event to preempt itself.
	continue;
	}

	$u_start = $u_event->getDateStarted();
	$u_end = $u_event->getDateEnded();

	if ($u_start < $e_start) {
	// This event started before our event started, so it's not
	// preempting us.
	continue;
	}

	if ($u_start == $e_start) {
	if ($u_event->getID() < $event->getID()) {
	// This event started at the same time as our event started,
	// but has a lower ID, so it's not preempting us.
	continue;
	}
	}

	if (($e_end !== null) && ($u_start > $e_end)) {
	// Our event has ended, and this event started after it ended.
	continue;
	}

	if (($u_end !== null) && ($u_end < $e_start)) {
	// This event ended before our event began.
	continue;
	}

	$select[] = $u_event;
	}

	$event->attachPreemptingEvents($select);
	}
	}

	return $page;
	}

	/* -( Helper Functions ) --------------------------------------------------- */

	public static function getEndedSearchOptions() {
	return array(
	self::ENDED_ALL => pht('All'),
	self::ENDED_NO => pht('No'),
	self::ENDED_YES => pht('Yes'),
	);
	}

	public static function getOrderSearchOptions() {
	return array(
	self::ORDER_STARTED_ASC => pht('by furthest start date'),
	self::ORDER_STARTED_DESC => pht('by nearest start date'),
	self::ORDER_ENDED_ASC => pht('by furthest end date'),
	self::ORDER_ENDED_DESC => pht('by nearest end date'),
	- self::ORDER_DURATION_ASC => pht('by smallest duration'),
	- self::ORDER_DURATION_DESC => pht('by largest duration'),
	);
	}

	public static function getUserTotalObjectsTracked(
	PhabricatorUser $user,
	$limit = PHP_INT_MAX) {

	$usertime_dao = new PhrequentUserTime();
	$conn = $usertime_dao->establishConnection('r');

	$count = queryfx_one(
	$conn,
	'SELECT COUNT(usertime.id) N FROM %T usertime '.
	'WHERE usertime.userPHID = %s '.
	'AND usertime.dateEnded IS NULL '.
	'LIMIT %d',
	$usertime_dao->getTableName(),
	$user->getPHID(),
	$limit);
	return $count['N'];
	}

	public static function isUserTrackingObject(
	PhabricatorUser $user,
	$phid) {

	$usertime_dao = new PhrequentUserTime();
	$conn = $usertime_dao->establishConnection('r');

	$count = queryfx_one(
	$conn,
	'SELECT COUNT(usertime.id) N FROM %T usertime '.
	'WHERE usertime.userPHID = %s '.
	'AND usertime.objectPHID = %s '.
	'AND usertime.dateEnded IS NULL',
	$usertime_dao->getTableName(),
	$user->getPHID(),
	$phid);
	return $count['N'] > 0;
	}

	public static function getUserTimeSpentOnObject(
	PhabricatorUser $user,
	$phid) {

	$usertime_dao = new PhrequentUserTime();
	$conn = $usertime_dao->establishConnection('r');

	// First calculate all the time spent where the
	// usertime blocks have ended.
	$sum_ended = queryfx_one(
	$conn,
	'SELECT SUM(usertime.dateEnded - usertime.dateStarted) N '.
	'FROM %T usertime '.
	'WHERE usertime.userPHID = %s '.
	'AND usertime.objectPHID = %s '.
	'AND usertime.dateEnded IS NOT NULL',
	$usertime_dao->getTableName(),
	$user->getPHID(),
	$phid);

	// Now calculate the time spent where the usertime
	// blocks have not yet ended.
	$sum_not_ended = queryfx_one(
	$conn,
	'SELECT SUM(UNIX_TIMESTAMP() - usertime.dateStarted) N '.
	'FROM %T usertime '.
	'WHERE usertime.userPHID = %s '.
	'AND usertime.objectPHID = %s '.
	'AND usertime.dateEnded IS NULL',
	$usertime_dao->getTableName(),
	$user->getPHID(),
	$phid);

	return $sum_ended['N'] + $sum_not_ended['N'];
	}

	public function getQueryApplicationClass() {
	return 'PhabricatorPhrequentApplication';
	}

	}
	diff --git a/src/infrastructure/query/policy/PhabricatorCursorPagedPolicyAwareQuery.php b/src/infrastructure/query/policy/PhabricatorCursorPagedPolicyAwareQuery.php
	index fdeb3cd459..dceaf6c331 100644
	--- a/src/infrastructure/query/policy/PhabricatorCursorPagedPolicyAwareQuery.php
	+++ b/src/infrastructure/query/policy/PhabricatorCursorPagedPolicyAwareQuery.php
	@@ -1,948 +1,950 @@
	<?php

	/**
	* A query class which uses cursor-based paging. This paging is much more
	* performant than offset-based paging in the presence of policy filtering.
	*
	* @task appsearch Integration with ApplicationSearch
	* @task paging Paging
	* @task order Result Ordering
	*/
	abstract class PhabricatorCursorPagedPolicyAwareQuery
	extends PhabricatorPolicyAwareQuery {

	private $afterID;
	private $beforeID;
	private $applicationSearchConstraints = array();
	private $applicationSearchOrders = array();
	private $internalPaging;
	private $orderVector;

	protected function getPagingColumn() {
	return 'id';
	}

	protected function getPagingValue($result) {
	if (!is_object($result)) {
	// This interface can't be typehinted and PHP gets really angry if we
	// call a method on a non-object, so add an explicit check here.
	throw new Exception(pht('Expected object, got "%s"!', gettype($result)));
	}
	return $result->getID();
	}

	protected function getReversePaging() {
	return false;
	}

	protected function nextPage(array $page) {
	// See getPagingViewer() for a description of this flag.
	$this->internalPaging = true;

	if ($this->beforeID) {
	$this->beforeID = $this->getPagingValue(last($page));
	} else {
	$this->afterID = $this->getPagingValue(last($page));
	}
	}

	final public function setAfterID($object_id) {
	$this->afterID = $object_id;
	return $this;
	}

	final protected function getAfterID() {
	return $this->afterID;
	}

	final public function setBeforeID($object_id) {
	$this->beforeID = $object_id;
	return $this;
	}

	final protected function getBeforeID() {
	return $this->beforeID;
	}


	/**
	* Get the viewer for making cursor paging queries.
	*
	* NOTE: You should ONLY use this viewer to load cursor objects while
	* building paging queries.
	*
	* Cursor paging can happen in two ways. First, the user can request a page
	* like `/stuff/?after=33`, which explicitly causes paging. Otherwise, we
	* can fall back to implicit paging if we filter some results out of a
	* result list because the user can't see them and need to go fetch some more
	* results to generate a large enough result list.
	*
	* In the first case, want to use the viewer's policies to load the object.
	* This prevents an attacker from figuring out information about an object
	* they can't see by executing queries like `/stuff/?after=33&order=name`,
	* which would otherwise give them a hint about the name of the object.
	* Generally, if a user can't see an object, they can't use it to page.
	*
	* In the second case, we need to load the object whether the user can see
	* it or not, because we need to examine new results. For example, if a user
	* loads `/stuff/` and we run a query for the first 100 items that they can
	* see, but the first 100 rows in the database aren't visible, we need to
	* be able to issue a query for the next 100 results. If we can't load the
	* cursor object, we'll fail or issue the same query over and over again.
	* So, generally, internal paging must bypass policy controls.
	*
	* This method returns the appropriate viewer, based on the context in which
	* the paging is occuring.
	*
	* @return PhabricatorUser Viewer for executing paging queries.
	*/
	final protected function getPagingViewer() {
	if ($this->internalPaging) {
	return PhabricatorUser::getOmnipotentUser();
	} else {
	return $this->getViewer();
	}
	}

	final protected function buildLimitClause(AphrontDatabaseConnection $conn_r) {
	if ($this->getRawResultLimit()) {
	return qsprintf($conn_r, 'LIMIT %d', $this->getRawResultLimit());
	} else {
	return '';
	}
	}

	final protected function didLoadResults(array $results) {
	if ($this->beforeID) {
	$results = array_reverse($results, $preserve_keys = true);
	}
	return $results;
	}

	final public function executeWithCursorPager(AphrontCursorPagerView $pager) {
	$this->setLimit($pager->getPageSize() + 1);

	if ($pager->getAfterID()) {
	$this->setAfterID($pager->getAfterID());
	} else if ($pager->getBeforeID()) {
	$this->setBeforeID($pager->getBeforeID());
	}

	$results = $this->execute();

	$sliced_results = $pager->sliceResults($results);

	if ($sliced_results) {
	if ($pager->getBeforeID() \|\| (count($results) > $pager->getPageSize())) {
	$pager->setNextPageID($this->getPagingValue(last($sliced_results)));
	}

	if ($pager->getAfterID() \|\|
	($pager->getBeforeID() && (count($results) > $pager->getPageSize()))) {
	$pager->setPrevPageID($this->getPagingValue(head($sliced_results)));
	}
	}

	return $sliced_results;
	}


	/**
	* Return the alias this query uses to identify the primary table.
	*
	* Some automatic query constructions may need to be qualified with a table
	* alias if the query performs joins which make column names ambiguous. If
	* this is the case, return the alias for the primary table the query
	* uses; generally the object table which has `id` and `phid` columns.
	*
	* @return string Alias for the primary table.
	*/
	protected function getPrimaryTableAlias() {
	return null;
	}


	/* -( Paging )------------------------------------------------------------- */


	protected function buildPagingClause(AphrontDatabaseConnection $conn) {
	$orderable = $this->getOrderableColumns();

	// TODO: Remove this once subqueries modernize.
	if (!$orderable) {
	if ($this->beforeID) {
	return qsprintf(
	$conn,
	'%Q %Q %s',
	$this->getPagingColumn(),
	$this->getReversePaging() ? '<' : '>',
	$this->beforeID);
	} else if ($this->afterID) {
	return qsprintf(
	$conn,
	'%Q %Q %s',
	$this->getPagingColumn(),
	$this->getReversePaging() ? '>' : '<',
	$this->afterID);
	} else {
	return null;
	}
	}

	$vector = $this->getOrderVector();

	if ($this->beforeID !== null) {
	$cursor = $this->beforeID;
	$reversed = true;
	} else if ($this->afterID !== null) {
	$cursor = $this->afterID;
	$reversed = false;
	} else {
	// No paging is being applied to this query so we do not need to
	// construct a paging clause.
	return '';
	}

	$keys = array();
	foreach ($vector as $order) {
	$keys[] = $order->getOrderKey();
	}

	$value_map = $this->getPagingValueMap($cursor, $keys);

	$columns = array();
	foreach ($vector as $order) {
	$key = $order->getOrderKey();

	if (!array_key_exists($key, $value_map)) {
	throw new Exception(
	pht(
	'Query "%s" failed to return a value from getPagingValueMap() '.
	'for column "%s".',
	get_class($this),
	$key));
	}

	$column = $orderable[$key];
	$column['value'] = $value_map[$key];

	$columns[] = $column;
	}

	return $this->buildPagingClauseFromMultipleColumns(
	$conn,
	$columns,
	array(
	'reversed' => $reversed,
	));
	}

	protected function getPagingValueMap($cursor, array $keys) {
	// TODO: This is a hack to make this work with existing classes for now.
	return array(
	'id' => $cursor,
	);
	}

	protected function loadCursorObject($cursor) {
	$query = newv(get_class($this), array())
	->setViewer($this->getPagingViewer())
	->withIDs(array((int)$cursor));

	$this->willExecuteCursorQuery($query);

	$object = $query->executeOne();
	if (!$object) {
	throw new Exception(
	pht(
	'Cursor "%s" does not identify a valid object.',
	$cursor));
	}

	return $object;
	}

	protected function willExecuteCursorQuery(
	PhabricatorCursorPagedPolicyAwareQuery $query) {
	return;
	}


	/**
	* Simplifies the task of constructing a paging clause across multiple
	* columns. In the general case, this looks like:
	*
	* A > a OR (A = a AND B > b) OR (A = a AND B = b AND C > c)
	*
	* To build a clause, specify the name, type, and value of each column
	* to include:
	*
	* $this->buildPagingClauseFromMultipleColumns(
	* $conn_r,
	* array(
	* array(
	* 'table' => 't',
	* 'column' => 'title',
	* 'type' => 'string',
	* 'value' => $cursor->getTitle(),
	* 'reverse' => true,
	* ),
	* array(
	* 'table' => 't',
	* 'column' => 'id',
	* 'type' => 'int',
	* 'value' => $cursor->getID(),
	* ),
	* ),
	* array(
	* 'reversed' => $is_reversed,
	* ));
	*
	* This method will then return a composable clause for inclusion in WHERE.
	*
	* @param AphrontDatabaseConnection Connection query will execute on.
	* @param list<map> Column description dictionaries.
	* @param map Additional constuction options.
	* @return string Query clause.
	*/
	final protected function buildPagingClauseFromMultipleColumns(
	AphrontDatabaseConnection $conn,
	array $columns,
	array $options) {

	foreach ($columns as $column) {
	PhutilTypeSpec::checkMap(
	$column,
	array(
	'table' => 'optional string\|null',
	'column' => 'string',
	'value' => 'wild',
	'type' => 'string',
	'reverse' => 'optional bool',
	'unique' => 'optional bool',
	));
	}

	PhutilTypeSpec::checkMap(
	$options,
	array(
	'reversed' => 'optional bool',
	));

	$is_query_reversed = idx($options, 'reversed', false);

	$clauses = array();
	$accumulated = array();
	$last_key = last_key($columns);
	foreach ($columns as $key => $column) {
	$type = $column['type'];
	switch ($type) {
	case 'null':
	$value = qsprintf($conn, '%d', ($column['value'] ? 0 : 1));
	break;
	case 'int':
	$value = qsprintf($conn, '%d', $column['value']);
	break;
	case 'float':
	$value = qsprintf($conn, '%f', $column['value']);
	break;
	case 'string':
	$value = qsprintf($conn, '%s', $column['value']);
	break;
	default:
	throw new Exception("Unknown column type '{$type}'!");
	}

	$is_column_reversed = idx($column, 'reverse', false);
	$reverse = ($is_query_reversed xor $is_column_reversed);

	$clause = $accumulated;

	$table_name = idx($column, 'table');
	$column_name = $column['column'];
	if ($table_name !== null) {
	$field = qsprintf($conn, '%T.%T', $table_name, $column_name);
	} else {
	$field = qsprintf($conn, '%T', $column_name);
	}

	if ($type == 'null') {
	$field = qsprintf($conn, '(%Q IS NULL)', $field);
	}

	$clause[] = qsprintf(
	$conn,
	'%Q %Q %Q',
	$field,
	$reverse ? '>' : '<',
	$value);
	$clauses[] = '('.implode(') AND (', $clause).')';

	$accumulated[] = qsprintf(
	$conn,
	'%Q = %Q',
	$field,
	$value);
	}

	return '('.implode(') OR (', $clauses).')';
	}


	/* -( Result Ordering )---------------------------------------------------- */


	/**
	* @task order
	*/
	public function setOrderVector($vector) {
	$vector = PhabricatorQueryOrderVector::newFromVector($vector);

	$orderable = $this->getOrderableColumns();

	// Make sure that all the components identify valid columns.
	$unique = array();
	foreach ($vector as $order) {
	$key = $order->getOrderKey();
	if (empty($orderable[$key])) {
	$valid = implode(', ', array_keys($orderable));
	throw new Exception(
	pht(
	'This query ("%s") does not support sorting by order key "%s". '.
	'Supported orders are: %s.',
	get_class($this),
	$key,
	$valid));
	}

	$unique[$key] = idx($orderable[$key], 'unique', false);
	}

	// Make sure that the last column is unique so that this is a strong
	// ordering which can be used for paging.
	$last = last($unique);
	if ($last !== true) {
	throw new Exception(
	pht(
	'Order vector "%s" is invalid: the last column in an order must '.
	'be a column with unique values, but "%s" is not unique.',
	$vector->getAsString(),
	last_key($unique)));
	}

	// Make sure that other columns are not unique; an ordering like "id, name"
	// does not make sense because only "id" can ever have an effect.
	array_pop($unique);
	foreach ($unique as $key => $is_unique) {
	if ($is_unique) {
	throw new Exception(
	pht(
	'Order vector "%s" is invalid: only the last column in an order '.
	'may be unique, but "%s" is a unique column and not the last '.
	'column in the order.',
	$vector->getAsString(),
	$key));
	}
	}

	$this->orderVector = $vector;
	return $this;
	}


	/**
	* @task order
	*/
	protected function getOrderVector() {
	if (!$this->orderVector) {
	$vector = $this->getDefaultOrderVector();
	$vector = PhabricatorQueryOrderVector::newFromVector($vector);

	// We call setOrderVector() here to apply checks to the default vector.
	// This catches any errors in the implementation.
	$this->setOrderVector($vector);
	}

	return $this->orderVector;
	}


	/**
	* @task order
	*/
	protected function getDefaultOrderVector() {
	return array('id');
	}


	/**
	* @task order
	*/
	public function getOrderableColumns() {
	// TODO: Remove this once all subclasses move off the old stuff.
	if ($this->getPagingColumn() !== 'id') {
	// This class has bad old custom logic around paging, so return nothing
	// here. This deactivates the new order code.
	return array();
	}

	return array(
	'id' => array(
	'table' => $this->getPrimaryTableAlias(),
	'column' => 'id',
	'reverse' => false,
	'type' => 'int',
	'unique' => true,
	),
	);
	}


	/**
	* @task order
	*/
	final protected function buildOrderClause(AphrontDatabaseConnection $conn) {
	$orderable = $this->getOrderableColumns();

	// TODO: Remove this once all subclasses move off the old stuff. We'll
	// only enter this block for code using older ordering mechanisms. New
	// code should expose an orderable column list.
	if (!$orderable) {
	if ($this->beforeID) {
	return qsprintf(
	$conn,
	'ORDER BY %Q %Q',
	$this->getPagingColumn(),
	$this->getReversePaging() ? 'DESC' : 'ASC');
	} else {
	return qsprintf(
	$conn,
	'ORDER BY %Q %Q',
	$this->getPagingColumn(),
	$this->getReversePaging() ? 'ASC' : 'DESC');
	}
	}

	$vector = $this->getOrderVector();

	$parts = array();
	foreach ($vector as $order) {
	$part = $orderable[$order->getOrderKey()];
	if ($order->getIsReversed()) {
	$part['reverse'] = !idx($part, 'reverse', false);
	}
	$parts[] = $part;
	}

	return $this->formatOrderClause($conn, $parts);
	}


	/**
	* @task order
	*/
	protected function formatOrderClause(
	AphrontDatabaseConnection $conn,
	array $parts) {

	$is_query_reversed = false;
	if ($this->getReversePaging()) {
	$is_query_reversed = !$is_query_reversed;
	}

	if ($this->getBeforeID()) {
	$is_query_reversed = !$is_query_reversed;
	}

	$sql = array();
	foreach ($parts as $key => $part) {
	$is_column_reversed = !empty($part['reverse']);

	$descending = true;
	if ($is_query_reversed) {
	$descending = !$descending;
	}

	if ($is_column_reversed) {
	$descending = !$descending;
	}

	$table = idx($part, 'table');
	$column = $part['column'];

	+ if ($table !== null) {
	+ $field = qsprintf($conn, '%T.%T', $table, $column);
	+ } else {
	+ $field = qsprintf($conn, '%T', $column);
	+ }
	+
	+ if (idx($part, 'type') === 'null') {
	+ $field = qsprintf($conn, '(%Q IS NULL)', $field);
	+ }
	+
	if ($descending) {
	- if ($table !== null) {
	- $sql[] = qsprintf($conn, '%T.%T DESC', $table, $column);
	- } else {
	- $sql[] = qsprintf($conn, '%T DESC', $column);
	- }
	+ $sql[] = qsprintf($conn, '%Q DESC', $field);
	} else {
	- if ($table !== null) {
	- $sql[] = qsprintf($conn, '%T.%T ASC', $table, $column);
	- } else {
	- $sql[] = qsprintf($conn, '%T ASC', $column);
	- }
	+ $sql[] = qsprintf($conn, '%Q ASC', $field);
	}
	}

	return qsprintf($conn, 'ORDER BY %Q', implode(', ', $sql));
	}


	/* -( Application Search )------------------------------------------------- */


	/**
	* Constrain the query with an ApplicationSearch index, requiring field values
	* contain at least one of the values in a set.
	*
	* This constraint can build the most common types of queries, like:
	*
	* - Find users with shirt sizes "X" or "XL".
	* - Find shoes with size "13".
	*
	* @param PhabricatorCustomFieldIndexStorage Table where the index is stored.
	* @param string\|list<string> One or more values to filter by.
	* @return this
	* @task appsearch
	*/
	public function withApplicationSearchContainsConstraint(
	PhabricatorCustomFieldIndexStorage $index,
	$value) {

	$this->applicationSearchConstraints[] = array(
	'type' => $index->getIndexValueType(),
	'cond' => '=',
	'table' => $index->getTableName(),
	'index' => $index->getIndexKey(),
	'value' => $value,
	);

	return $this;
	}


	/**
	* Constrain the query with an ApplicationSearch index, requiring values
	* exist in a given range.
	*
	* This constraint is useful for expressing date ranges:
	*
	* - Find events between July 1st and July 7th.
	*
	* The ends of the range are inclusive, so a `$min` of `3` and a `$max` of
	* `5` will match fields with values `3`, `4`, or `5`. Providing `null` for
	* either end of the range will leave that end of the constraint open.
	*
	* @param PhabricatorCustomFieldIndexStorage Table where the index is stored.
	* @param int\|null Minimum permissible value, inclusive.
	* @param int\|null Maximum permissible value, inclusive.
	* @return this
	* @task appsearch
	*/
	public function withApplicationSearchRangeConstraint(
	PhabricatorCustomFieldIndexStorage $index,
	$min,
	$max) {

	$index_type = $index->getIndexValueType();
	if ($index_type != 'int') {
	throw new Exception(
	pht(
	'Attempting to apply a range constraint to a field with index type '.
	'"%s", expected type "%s".',
	$index_type,
	'int'));
	}

	$this->applicationSearchConstraints[] = array(
	'type' => $index->getIndexValueType(),
	'cond' => 'range',
	'table' => $index->getTableName(),
	'index' => $index->getIndexKey(),
	'value' => array($min, $max),
	);

	return $this;
	}


	/**
	* Order the results by an ApplicationSearch index.
	*
	* @param PhabricatorCustomField Field to which the index belongs.
	* @param PhabricatorCustomFieldIndexStorage Table where the index is stored.
	* @param bool True to sort ascending.
	* @return this
	* @task appsearch
	*/
	public function withApplicationSearchOrder(
	PhabricatorCustomField $field,
	PhabricatorCustomFieldIndexStorage $index,
	$ascending) {

	$this->applicationSearchOrders[] = array(
	'key' => $field->getFieldKey(),
	'type' => $index->getIndexValueType(),
	'table' => $index->getTableName(),
	'index' => $index->getIndexKey(),
	'ascending' => $ascending,
	);

	return $this;
	}


	/**
	* Get the name of the query's primary object PHID column, for constructing
	* JOIN clauses. Normally (and by default) this is just `"phid"`, but it may
	* be something more exotic.
	*
	* See @{method:getPrimaryTableAlias} if the column needs to be qualified with
	* a table alias.
	*
	* @return string Column name.
	* @task appsearch
	*/
	protected function getApplicationSearchObjectPHIDColumn() {
	if ($this->getPrimaryTableAlias()) {
	$prefix = $this->getPrimaryTableAlias().'.';
	} else {
	$prefix = '';
	}

	return $prefix.'phid';
	}


	/**
	* Determine if the JOINs built by ApplicationSearch might cause each primary
	* object to return multiple result rows. Generally, this means the query
	* needs an extra GROUP BY clause.
	*
	* @return bool True if the query may return multiple rows for each object.
	* @task appsearch
	*/
	protected function getApplicationSearchMayJoinMultipleRows() {
	foreach ($this->applicationSearchConstraints as $constraint) {
	$type = $constraint['type'];
	$value = $constraint['value'];
	$cond = $constraint['cond'];

	switch ($cond) {
	case '=':
	switch ($type) {
	case 'string':
	case 'int':
	if (count((array)$value) > 1) {
	return true;
	}
	break;
	default:
	throw new Exception(pht('Unknown index type "%s"!', $type));
	}
	break;
	case 'range':
	// NOTE: It's possible to write a custom field where multiple rows
	// match a range constraint, but we don't currently ship any in the
	// upstream and I can't immediately come up with cases where this
	// would make sense.
	break;
	default:
	throw new Exception(pht('Unknown constraint condition "%s"!', $cond));
	}
	}

	return false;
	}


	/**
	* Construct a GROUP BY clause appropriate for ApplicationSearch constraints.
	*
	* @param AphrontDatabaseConnection Connection executing the query.
	* @return string Group clause.
	* @task appsearch
	*/
	protected function buildApplicationSearchGroupClause(
	AphrontDatabaseConnection $conn_r) {

	if ($this->getApplicationSearchMayJoinMultipleRows()) {
	return qsprintf(
	$conn_r,
	'GROUP BY %Q',
	$this->getApplicationSearchObjectPHIDColumn());
	} else {
	return '';
	}
	}


	/**
	* Construct a JOIN clause appropriate for applying ApplicationSearch
	* constraints.
	*
	* @param AphrontDatabaseConnection Connection executing the query.
	* @return string Join clause.
	* @task appsearch
	*/
	protected function buildApplicationSearchJoinClause(
	AphrontDatabaseConnection $conn_r) {

	$joins = array();
	foreach ($this->applicationSearchConstraints as $key => $constraint) {
	$table = $constraint['table'];
	$alias = 'appsearch_'.$key;
	$index = $constraint['index'];
	$cond = $constraint['cond'];
	$phid_column = $this->getApplicationSearchObjectPHIDColumn();
	switch ($cond) {
	case '=':
	$type = $constraint['type'];
	switch ($type) {
	case 'string':
	$constraint_clause = qsprintf(
	$conn_r,
	'%T.indexValue IN (%Ls)',
	$alias,
	(array)$constraint['value']);
	break;
	case 'int':
	$constraint_clause = qsprintf(
	$conn_r,
	'%T.indexValue IN (%Ld)',
	$alias,
	(array)$constraint['value']);
	break;
	default:
	throw new Exception(pht('Unknown index type "%s"!', $type));
	}

	$joins[] = qsprintf(
	$conn_r,
	'JOIN %T %T ON %T.objectPHID = %Q
	AND %T.indexKey = %s
	AND (%Q)',
	$table,
	$alias,
	$alias,
	$phid_column,
	$alias,
	$index,
	$constraint_clause);
	break;
	case 'range':
	list($min, $max) = $constraint['value'];
	if (($min === null) && ($max === null)) {
	// If there's no actual range constraint, just move on.
	break;
	}

	if ($min === null) {
	$constraint_clause = qsprintf(
	$conn_r,
	'%T.indexValue <= %d',
	$alias,
	$max);
	} else if ($max === null) {
	$constraint_clause = qsprintf(
	$conn_r,
	'%T.indexValue >= %d',
	$alias,
	$min);
	} else {
	$constraint_clause = qsprintf(
	$conn_r,
	'%T.indexValue BETWEEN %d AND %d',
	$alias,
	$min,
	$max);
	}

	$joins[] = qsprintf(
	$conn_r,
	'JOIN %T %T ON %T.objectPHID = %Q
	AND %T.indexKey = %s
	AND (%Q)',
	$table,
	$alias,
	$alias,
	$phid_column,
	$alias,
	$index,
	$constraint_clause);
	break;
	default:
	throw new Exception(pht('Unknown constraint condition "%s"!', $cond));
	}
	}

	foreach ($this->applicationSearchOrders as $key => $order) {
	$table = $order['table'];
	$alias = 'appsearch_order_'.$key;
	$index = $order['index'];
	$phid_column = $this->getApplicationSearchObjectPHIDColumn();

	$joins[] = qsprintf(
	$conn_r,
	'LEFT JOIN %T %T ON %T.objectPHID = %Q
	AND %T.indexKey = %s',
	$table,
	$alias,
	$alias,
	$phid_column,
	$alias,
	$index);
	}

	return implode(' ', $joins);
	}

	protected function buildApplicationSearchOrders(
	AphrontDatabaseConnection $conn_r,
	$reverse) {

	$orders = array();
	foreach ($this->applicationSearchOrders as $key => $order) {
	$alias = 'appsearch_order_'.$key;

	if ($order['ascending'] xor $reverse) {
	$orders[] = qsprintf($conn_r, '%T.indexValue ASC', $alias);
	} else {
	$orders[] = qsprintf($conn_r, '%T.indexValue DESC', $alias);
	}
	}

	return $orders;
	}

	protected function buildApplicationSearchPagination(
	AphrontDatabaseConnection $conn_r,
	$cursor) {

	// We have to get the current field values on the cursor object.
	$fields = PhabricatorCustomField::getObjectFields(
	$cursor,
	PhabricatorCustomField::ROLE_APPLICATIONSEARCH);
	$fields->setViewer($this->getViewer());
	$fields->readFieldsFromStorage($cursor);

	$fields = mpull($fields->getFields(), null, 'getFieldKey');

	$columns = array();
	foreach ($this->applicationSearchOrders as $key => $order) {
	$alias = 'appsearch_order_'.$key;

	$field = idx($fields, $order['key']);

	$columns[] = array(
	'name' => $alias.'.indexValue',
	'value' => $field->getValueForStorage(),
	'type' => $order['type'],
	);
	}

	return $columns;
	}

	}

File Metadata

Mime Type: text/x-diff
Expires: Mon, Mar 16, 10:06 AM (18 h, 44 m)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 962389
Default Alt Text: (56 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions