No OneTemporary
Actions

Size

80 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/src/applications/people/storage/PhabricatorUser.php b/src/applications/people/storage/PhabricatorUser.php
	index 38c9b421a8..e12bef88f8 100644
	--- a/src/applications/people/storage/PhabricatorUser.php
	+++ b/src/applications/people/storage/PhabricatorUser.php
	@@ -1,901 +1,900 @@
	<?php

	/**
	* @task factors Multi-Factor Authentication
	*/
	final class PhabricatorUser
	extends PhabricatorUserDAO
	implements
	PhutilPerson,
	PhabricatorPolicyInterface,
	PhabricatorCustomFieldInterface,
	PhabricatorDestructableInterface {

	const SESSION_TABLE = 'phabricator_session';
	const NAMETOKEN_TABLE = 'user_nametoken';
	const MAXIMUM_USERNAME_LENGTH = 64;

	protected $userName;
	protected $realName;
	protected $sex;
	protected $translation;
	protected $passwordSalt;
	protected $passwordHash;
	protected $profileImagePHID;
	protected $timezoneIdentifier = '';

	protected $consoleEnabled = 0;
	protected $consoleVisible = 0;
	protected $consoleTab = '';

	protected $conduitCertificate;

	protected $isSystemAgent = 0;
	protected $isAdmin = 0;
	protected $isDisabled = 0;
	protected $isEmailVerified = 0;
	protected $isApproved = 0;
	protected $isEnrolledInMultiFactor = 0;

	protected $accountSecret;

	private $profileImage = self::ATTACHABLE;
	private $profile = null;
	private $status = self::ATTACHABLE;
	private $preferences = null;
	private $omnipotent = false;
	private $customFields = self::ATTACHABLE;

	private $alternateCSRFString = self::ATTACHABLE;
	private $session = self::ATTACHABLE;

	protected function readField($field) {
	switch ($field) {
	case 'timezoneIdentifier':
	// If the user hasn't set one, guess the server's time.
	return nonempty(
	$this->timezoneIdentifier,
	date_default_timezone_get());
	// Make sure these return booleans.
	case 'isAdmin':
	return (bool)$this->isAdmin;
	case 'isDisabled':
	return (bool)$this->isDisabled;
	case 'isSystemAgent':
	return (bool)$this->isSystemAgent;
	case 'isEmailVerified':
	return (bool)$this->isEmailVerified;
	case 'isApproved':
	return (bool)$this->isApproved;
	default:
	return parent::readField($field);
	}
	}


	/**
	* Is this a live account which has passed required approvals? Returns true
	* if this is an enabled, verified (if required), approved (if required)
	* account, and false otherwise.
	*
	* @return bool True if this is a standard, usable account.
	*/
	public function isUserActivated() {
	if ($this->getIsDisabled()) {
	return false;
	}

	if (!$this->getIsApproved()) {
	return false;
	}

	if (PhabricatorUserEmail::isEmailVerificationRequired()) {
	if (!$this->getIsEmailVerified()) {
	return false;
	}
	}

	return true;
	}

	/**
	* Returns `true` if this is a standard user who is logged in. Returns `false`
	* for logged out, anonymous, or external users.
	*
	* @return bool `true` if the user is a standard user who is logged in with
	* a normal session.
	*/
	public function getIsStandardUser() {
	$type_user = PhabricatorPeoplePHIDTypeUser::TYPECONST;
	return $this->getPHID() && (phid_get_type($this->getPHID()) == $type_user);
	}

	public function getConfiguration() {
	return array(
	self::CONFIG_AUX_PHID => true,
	- self::CONFIG_PARTIAL_OBJECTS => true,
	) + parent::getConfiguration();
	}

	public function generatePHID() {
	return PhabricatorPHID::generateNewPHID(
	PhabricatorPeoplePHIDTypeUser::TYPECONST);
	}

	public function setPassword(PhutilOpaqueEnvelope $envelope) {
	if (!$this->getPHID()) {
	throw new Exception(
	'You can not set a password for an unsaved user because their PHID '.
	'is a salt component in the password hash.');
	}

	if (!strlen($envelope->openEnvelope())) {
	$this->setPasswordHash('');
	} else {
	$this->setPasswordSalt(md5(Filesystem::readRandomBytes(32)));
	$hash = $this->hashPassword($envelope);
	$this->setPasswordHash($hash->openEnvelope());
	}
	return $this;
	}

	// To satisfy PhutilPerson.
	public function getSex() {
	return $this->sex;
	}

	public function getMonogram() {
	return '@'.$this->getUsername();
	}

	public function getTranslation() {
	try {
	if ($this->translation &&
	class_exists($this->translation) &&
	is_subclass_of($this->translation, 'PhabricatorTranslation')) {
	return $this->translation;
	}
	} catch (PhutilMissingSymbolException $ex) {
	return null;
	}
	return null;
	}

	public function isLoggedIn() {
	return !($this->getPHID() === null);
	}

	public function save() {
	if (!$this->getConduitCertificate()) {
	$this->setConduitCertificate($this->generateConduitCertificate());
	}

	if (!strlen($this->getAccountSecret())) {
	$this->setAccountSecret(Filesystem::readRandomCharacters(64));
	}

	$result = parent::save();

	if ($this->profile) {
	$this->profile->save();
	}

	$this->updateNameTokens();

	id(new PhabricatorSearchIndexer())
	->queueDocumentForIndexing($this->getPHID());

	return $result;
	}

	public function attachSession(PhabricatorAuthSession $session) {
	$this->session = $session;
	return $this;
	}

	public function getSession() {
	return $this->assertAttached($this->session);
	}

	public function hasSession() {
	return ($this->session !== self::ATTACHABLE);
	}

	private function generateConduitCertificate() {
	return Filesystem::readRandomCharacters(255);
	}

	public function comparePassword(PhutilOpaqueEnvelope $envelope) {
	if (!strlen($envelope->openEnvelope())) {
	return false;
	}
	if (!strlen($this->getPasswordHash())) {
	return false;
	}

	return PhabricatorPasswordHasher::comparePassword(
	$this->getPasswordHashInput($envelope),
	new PhutilOpaqueEnvelope($this->getPasswordHash()));
	}

	private function getPasswordHashInput(PhutilOpaqueEnvelope $password) {
	$input =
	$this->getUsername().
	$password->openEnvelope().
	$this->getPHID().
	$this->getPasswordSalt();

	return new PhutilOpaqueEnvelope($input);
	}

	private function hashPassword(PhutilOpaqueEnvelope $password) {
	$hasher = PhabricatorPasswordHasher::getBestHasher();

	$input_envelope = $this->getPasswordHashInput($password);
	return $hasher->getPasswordHashForStorage($input_envelope);
	}

	const CSRF_CYCLE_FREQUENCY = 3600;
	const CSRF_SALT_LENGTH = 8;
	const CSRF_TOKEN_LENGTH = 16;
	const CSRF_BREACH_PREFIX = 'B@';

	const EMAIL_CYCLE_FREQUENCY = 86400;
	const EMAIL_TOKEN_LENGTH = 24;

	private function getRawCSRFToken($offset = 0) {
	return $this->generateToken(
	time() + (self::CSRF_CYCLE_FREQUENCY * $offset),
	self::CSRF_CYCLE_FREQUENCY,
	PhabricatorEnv::getEnvConfig('phabricator.csrf-key'),
	self::CSRF_TOKEN_LENGTH);
	}

	/**
	* @phutil-external-symbol class PhabricatorStartup
	*/
	public function getCSRFToken() {
	$salt = PhabricatorStartup::getGlobal('csrf.salt');
	if (!$salt) {
	$salt = Filesystem::readRandomCharacters(self::CSRF_SALT_LENGTH);
	PhabricatorStartup::setGlobal('csrf.salt', $salt);
	}

	// Generate a token hash to mitigate BREACH attacks against SSL. See
	// discussion in T3684.
	$token = $this->getRawCSRFToken();
	$hash = PhabricatorHash::digest($token, $salt);
	return 'B@'.$salt.substr($hash, 0, self::CSRF_TOKEN_LENGTH);
	}

	public function validateCSRFToken($token) {
	$salt = null;
	$version = 'plain';

	// This is a BREACH-mitigating token. See T3684.
	$breach_prefix = self::CSRF_BREACH_PREFIX;
	$breach_prelen = strlen($breach_prefix);

	if (!strncmp($token, $breach_prefix, $breach_prelen)) {
	$version = 'breach';
	$salt = substr($token, $breach_prelen, self::CSRF_SALT_LENGTH);
	$token = substr($token, $breach_prelen + self::CSRF_SALT_LENGTH);
	}

	// When the user posts a form, we check that it contains a valid CSRF token.
	// Tokens cycle each hour (every CSRF_CYLCE_FREQUENCY seconds) and we accept
	// either the current token, the next token (users can submit a "future"
	// token if you have two web frontends that have some clock skew) or any of
	// the last 6 tokens. This means that pages are valid for up to 7 hours.
	// There is also some Javascript which periodically refreshes the CSRF
	// tokens on each page, so theoretically pages should be valid indefinitely.
	// However, this code may fail to run (if the user loses their internet
	// connection, or there's a JS problem, or they don't have JS enabled).
	// Choosing the size of the window in which we accept old CSRF tokens is
	// an issue of balancing concerns between security and usability. We could
	// choose a very narrow (e.g., 1-hour) window to reduce vulnerability to
	// attacks using captured CSRF tokens, but it's also more likely that real
	// users will be affected by this, e.g. if they close their laptop for an
	// hour, open it back up, and try to submit a form before the CSRF refresh
	// can kick in. Since the user experience of submitting a form with expired
	// CSRF is often quite bad (you basically lose data, or it's a big pain to
	// recover at least) and I believe we gain little additional protection
	// by keeping the window very short (the overwhelming value here is in
	// preventing blind attacks, and most attacks which can capture CSRF tokens
	// can also just capture authentication information [sniffing networks]
	// or act as the user [xss]) the 7 hour default seems like a reasonable
	// balance. Other major platforms have much longer CSRF token lifetimes,
	// like Rails (session duration) and Django (forever), which suggests this
	// is a reasonable analysis.
	$csrf_window = 6;

	for ($ii = -$csrf_window; $ii <= 1; $ii++) {
	$valid = $this->getRawCSRFToken($ii);
	switch ($version) {
	// TODO: We can remove this after the BREACH version has been in the
	// wild for a while.
	case 'plain':
	if ($token == $valid) {
	return true;
	}
	break;
	case 'breach':
	$digest = PhabricatorHash::digest($valid, $salt);
	if (substr($digest, 0, self::CSRF_TOKEN_LENGTH) == $token) {
	return true;
	}
	break;
	default:
	throw new Exception('Unknown CSRF token format!');
	}
	}

	return false;
	}

	private function generateToken($epoch, $frequency, $key, $len) {
	if ($this->getPHID()) {
	$vec = $this->getPHID().$this->getAccountSecret();
	} else {
	$vec = $this->getAlternateCSRFString();
	}

	$time_block = floor($epoch / $frequency);
	$vec = $vec.$key.$time_block;

	return substr(PhabricatorHash::digest($vec), 0, $len);
	}

	public function attachUserProfile(PhabricatorUserProfile $profile) {
	$this->profile = $profile;
	return $this;
	}

	public function loadUserProfile() {
	if ($this->profile) {
	return $this->profile;
	}

	$profile_dao = new PhabricatorUserProfile();
	$this->profile = $profile_dao->loadOneWhere('userPHID = %s',
	$this->getPHID());

	if (!$this->profile) {
	$profile_dao->setUserPHID($this->getPHID());
	$this->profile = $profile_dao;
	}

	return $this->profile;
	}

	public function loadPrimaryEmailAddress() {
	$email = $this->loadPrimaryEmail();
	if (!$email) {
	throw new Exception('User has no primary email address!');
	}
	return $email->getAddress();
	}

	public function loadPrimaryEmail() {
	return $this->loadOneRelative(
	new PhabricatorUserEmail(),
	'userPHID',
	'getPHID',
	'(isPrimary = 1)');
	}

	public function loadPreferences() {
	if ($this->preferences) {
	return $this->preferences;
	}

	$preferences = null;
	if ($this->getPHID()) {
	$preferences = id(new PhabricatorUserPreferences())->loadOneWhere(
	'userPHID = %s',
	$this->getPHID());
	}

	if (!$preferences) {
	$preferences = new PhabricatorUserPreferences();
	$preferences->setUserPHID($this->getPHID());

	$default_dict = array(
	PhabricatorUserPreferences::PREFERENCE_TITLES => 'glyph',
	PhabricatorUserPreferences::PREFERENCE_EDITOR => '',
	PhabricatorUserPreferences::PREFERENCE_MONOSPACED => '',
	PhabricatorUserPreferences::PREFERENCE_DARK_CONSOLE => 0);

	$preferences->setPreferences($default_dict);
	}

	$this->preferences = $preferences;
	return $preferences;
	}

	public function loadEditorLink($path, $line, $callsign) {
	$editor = $this->loadPreferences()->getPreference(
	PhabricatorUserPreferences::PREFERENCE_EDITOR);

	if (is_array($path)) {
	$multiedit = $this->loadPreferences()->getPreference(
	PhabricatorUserPreferences::PREFERENCE_MULTIEDIT);
	switch ($multiedit) {
	case '':
	$path = implode(' ', $path);
	break;
	case 'disable':
	return null;
	}
	}

	if (!strlen($editor)) {
	return null;
	}

	$uri = strtr($editor, array(
	'%%' => '%',
	'%f' => phutil_escape_uri($path),
	'%l' => phutil_escape_uri($line),
	'%r' => phutil_escape_uri($callsign),
	));

	// The resulting URI must have an allowed protocol. Otherwise, we'll return
	// a link to an error page explaining the misconfiguration.

	$ok = PhabricatorHelpEditorProtocolController::hasAllowedProtocol($uri);
	if (!$ok) {
	return '/help/editorprotocol/';
	}

	return (string)$uri;
	}

	public function getAlternateCSRFString() {
	return $this->assertAttached($this->alternateCSRFString);
	}

	public function attachAlternateCSRFString($string) {
	$this->alternateCSRFString = $string;
	return $this;
	}

	private static function tokenizeName($name) {
	if (function_exists('mb_strtolower')) {
	$name = mb_strtolower($name, 'UTF-8');
	} else {
	$name = strtolower($name);
	}
	$name = trim($name);
	if (!strlen($name)) {
	return array();
	}
	return preg_split('/\s+/', $name);
	}

	/**
	* Populate the nametoken table, which used to fetch typeahead results. When
	* a user types "linc", we want to match "Abraham Lincoln" from on-demand
	* typeahead sources. To do this, we need a separate table of name fragments.
	*/
	public function updateNameTokens() {
	$tokens = array_merge(
	self::tokenizeName($this->getRealName()),
	self::tokenizeName($this->getUserName()));
	$tokens = array_unique($tokens);
	$table = self::NAMETOKEN_TABLE;
	$conn_w = $this->establishConnection('w');

	$sql = array();
	foreach ($tokens as $token) {
	$sql[] = qsprintf(
	$conn_w,
	'(%d, %s)',
	$this->getID(),
	$token);
	}

	queryfx(
	$conn_w,
	'DELETE FROM %T WHERE userID = %d',
	$table,
	$this->getID());
	if ($sql) {
	queryfx(
	$conn_w,
	'INSERT INTO %T (userID, token) VALUES %Q',
	$table,
	implode(', ', $sql));
	}
	}

	public function sendWelcomeEmail(PhabricatorUser $admin) {
	$admin_username = $admin->getUserName();
	$admin_realname = $admin->getRealName();
	$user_username = $this->getUserName();
	$is_serious = PhabricatorEnv::getEnvConfig('phabricator.serious-business');

	$base_uri = PhabricatorEnv::getProductionURI('/');

	$engine = new PhabricatorAuthSessionEngine();
	$uri = $engine->getOneTimeLoginURI(
	$this,
	$this->loadPrimaryEmail(),
	PhabricatorAuthSessionEngine::ONETIME_WELCOME);

	$body = <<<EOBODY
	Welcome to Phabricator!

	{$admin_username} ({$admin_realname}) has created an account for you.

	Username: {$user_username}

	To login to Phabricator, follow this link and set a password:

	{$uri}

	After you have set a password, you can login in the future by going here:

	{$base_uri}

	EOBODY;

	if (!$is_serious) {
	$body .= <<<EOBODY

	Love,
	Phabricator

	EOBODY;
	}

	$mail = id(new PhabricatorMetaMTAMail())
	->addTos(array($this->getPHID()))
	->setSubject('[Phabricator] Welcome to Phabricator')
	->setBody($body)
	->saveAndSend();
	}

	public function sendUsernameChangeEmail(
	PhabricatorUser $admin,
	$old_username) {

	$admin_username = $admin->getUserName();
	$admin_realname = $admin->getRealName();
	$new_username = $this->getUserName();

	$password_instructions = null;
	if (PhabricatorAuthProviderPassword::getPasswordProvider()) {
	$engine = new PhabricatorAuthSessionEngine();
	$uri = $engine->getOneTimeLoginURI(
	$this,
	null,
	PhabricatorAuthSessionEngine::ONETIME_USERNAME);
	$password_instructions = <<<EOTXT
	If you use a password to login, you'll need to reset it before you can login
	again. You can reset your password by following this link:

	{$uri}

	And, of course, you'll need to use your new username to login from now on. If
	you use OAuth to login, nothing should change.

	EOTXT;
	}

	$body = <<<EOBODY
	{$admin_username} ({$admin_realname}) has changed your Phabricator username.

	Old Username: {$old_username}
	New Username: {$new_username}

	{$password_instructions}
	EOBODY;

	$mail = id(new PhabricatorMetaMTAMail())
	->addTos(array($this->getPHID()))
	->setSubject('[Phabricator] Username Changed')
	->setBody($body)
	->saveAndSend();
	}

	public static function describeValidUsername() {
	return pht(
	'Usernames must contain only numbers, letters, period, underscore and '.
	'hyphen, and can not end with a period. They must have no more than %d '.
	'characters.',
	new PhutilNumber(self::MAXIMUM_USERNAME_LENGTH));
	}

	public static function validateUsername($username) {
	// NOTE: If you update this, make sure to update:
	//
	// - Remarkup rule for @mentions.
	// - Routing rule for "/p/username/".
	// - Unit tests, obviously.
	// - describeValidUsername() method, above.

	if (strlen($username) > self::MAXIMUM_USERNAME_LENGTH) {
	return false;
	}

	return (bool)preg_match('/^[a-zA-Z0-9._-]*[a-zA-Z0-9_-]\z/', $username);
	}

	public static function getDefaultProfileImageURI() {
	return celerity_get_resource_uri('/rsrc/image/avatar.png');
	}

	public function attachStatus(PhabricatorCalendarEvent $status) {
	$this->status = $status;
	return $this;
	}

	public function getStatus() {
	return $this->assertAttached($this->status);
	}

	public function hasStatus() {
	return $this->status !== self::ATTACHABLE;
	}

	public function attachProfileImageURI($uri) {
	$this->profileImage = $uri;
	return $this;
	}

	public function getProfileImageURI() {
	return $this->assertAttached($this->profileImage);
	}

	public function loadProfileImageURI() {
	if ($this->profileImage && ($this->profileImage !== self::ATTACHABLE)) {
	return $this->profileImage;
	}

	$src_phid = $this->getProfileImagePHID();

	if ($src_phid) {
	// TODO: (T603) Can we get rid of this entirely and move it to
	// PeopleQuery with attach/attachable?
	$file = id(new PhabricatorFile())->loadOneWhere('phid = %s', $src_phid);
	if ($file) {
	$this->profileImage = $file->getBestURI();
	return $this->profileImage;
	}
	}

	$this->profileImage = self::getDefaultProfileImageURI();
	return $this->profileImage;
	}

	public function getFullName() {
	if (strlen($this->getRealName())) {
	return $this->getUsername().' ('.$this->getRealName().')';
	} else {
	return $this->getUsername();
	}
	}

	public function __toString() {
	return $this->getUsername();
	}

	public static function loadOneWithEmailAddress($address) {
	$email = id(new PhabricatorUserEmail())->loadOneWhere(
	'address = %s',
	$address);
	if (!$email) {
	return null;
	}
	return id(new PhabricatorUser())->loadOneWhere(
	'phid = %s',
	$email->getUserPHID());
	}

	/* -( Multi-Factor Authentication )---------------------------------------- */


	/**
	* Update the flag storing this user's enrollment in multi-factor auth.
	*
	* With certain settings, we need to check if a user has MFA on every page,
	* so we cache MFA enrollment on the user object for performance. Calling this
	* method synchronizes the cache by examining enrollment records. After
	* updating the cache, use @{method:getIsEnrolledInMultiFactor} to check if
	* the user is enrolled.
	*
	* This method should be called after any changes are made to a given user's
	* multi-factor configuration.
	*
	* @return void
	* @task factors
	*/
	public function updateMultiFactorEnrollment() {
	$factors = id(new PhabricatorAuthFactorConfig())->loadAllWhere(
	'userPHID = %s',
	$this->getPHID());

	$enrolled = count($factors) ? 1 : 0;
	if ($enrolled !== $this->isEnrolledInMultiFactor) {
	$unguarded = AphrontWriteGuard::beginScopedUnguardedWrites();
	queryfx(
	$this->establishConnection('w'),
	'UPDATE %T SET isEnrolledInMultiFactor = %d WHERE id = %d',
	$this->getTableName(),
	$enrolled,
	$this->getID());
	unset($unguarded);

	$this->isEnrolledInMultiFactor = $enrolled;
	}
	}


	/**
	* Check if the user is enrolled in multi-factor authentication.
	*
	* Enrolled users have one or more multi-factor authentication sources
	* attached to their account. For performance, this value is cached. You
	* can use @{method:updateMultiFactorEnrollment} to update the cache.
	*
	* @return bool True if the user is enrolled.
	* @task factors
	*/
	public function getIsEnrolledInMultiFactor() {
	return $this->isEnrolledInMultiFactor;
	}


	/* -( Omnipotence )-------------------------------------------------------- */


	/**
	* Returns true if this user is omnipotent. Omnipotent users bypass all policy
	* checks.
	*
	* @return bool True if the user bypasses policy checks.
	*/
	public function isOmnipotent() {
	return $this->omnipotent;
	}


	/**
	* Get an omnipotent user object for use in contexts where there is no acting
	* user, notably daemons.
	*
	* @return PhabricatorUser An omnipotent user.
	*/
	public static function getOmnipotentUser() {
	static $user = null;
	if (!$user) {
	$user = new PhabricatorUser();
	$user->omnipotent = true;
	$user->makeEphemeral();
	}
	return $user;
	}


	/* -( PhabricatorPolicyInterface )----------------------------------------- */


	public function getCapabilities() {
	return array(
	PhabricatorPolicyCapability::CAN_VIEW,
	PhabricatorPolicyCapability::CAN_EDIT,
	);
	}

	public function getPolicy($capability) {
	switch ($capability) {
	case PhabricatorPolicyCapability::CAN_VIEW:
	return PhabricatorPolicies::POLICY_PUBLIC;
	case PhabricatorPolicyCapability::CAN_EDIT:
	if ($this->getIsSystemAgent()) {
	return PhabricatorPolicies::POLICY_ADMIN;
	} else {
	return PhabricatorPolicies::POLICY_NOONE;
	}
	}
	}

	public function hasAutomaticCapability($capability, PhabricatorUser $viewer) {
	return $this->getPHID() && ($viewer->getPHID() === $this->getPHID());
	}

	public function describeAutomaticCapability($capability) {
	switch ($capability) {
	case PhabricatorPolicyCapability::CAN_EDIT:
	return pht('Only you can edit your information.');
	default:
	return null;
	}
	}


	/* -( PhabricatorCustomFieldInterface )------------------------------------ */


	public function getCustomFieldSpecificationForRole($role) {
	return PhabricatorEnv::getEnvConfig('user.fields');
	}

	public function getCustomFieldBaseClass() {
	return 'PhabricatorUserCustomField';
	}

	public function getCustomFields() {
	return $this->assertAttached($this->customFields);
	}

	public function attachCustomFields(PhabricatorCustomFieldAttachment $fields) {
	$this->customFields = $fields;
	return $this;
	}


	/* -( PhabricatorDestructableInterface )----------------------------------- */


	public function destroyObjectPermanently(
	PhabricatorDestructionEngine $engine) {

	$this->openTransaction();
	$this->delete();

	$externals = id(new PhabricatorExternalAccount())->loadAllWhere(
	'userPHID = %s',
	$this->getPHID());
	foreach ($externals as $external) {
	$external->delete();
	}

	$prefs = id(new PhabricatorUserPreferences())->loadAllWhere(
	'userPHID = %s',
	$this->getPHID());
	foreach ($prefs as $pref) {
	$pref->delete();
	}

	$profiles = id(new PhabricatorUserProfile())->loadAllWhere(
	'userPHID = %s',
	$this->getPHID());
	foreach ($profiles as $profile) {
	$profile->delete();
	}

	$keys = id(new PhabricatorUserSSHKey())->loadAllWhere(
	'userPHID = %s',
	$this->getPHID());
	foreach ($keys as $key) {
	$key->delete();
	}

	$emails = id(new PhabricatorUserEmail())->loadAllWhere(
	'userPHID = %s',
	$this->getPHID());
	foreach ($emails as $email) {
	$email->delete();
	}

	$sessions = id(new PhabricatorAuthSession())->loadAllWhere(
	'userPHID = %s',
	$this->getPHID());
	foreach ($sessions as $session) {
	$session->delete();
	}

	$factors = id(new PhabricatorAuthFactorConfig())->loadAllWhere(
	'userPHID = %s',
	$this->getPHID());
	foreach ($factors as $factor) {
	$factor->delete();
	}

	$this->saveTransaction();
	}


	}
	diff --git a/src/infrastructure/storage/lisk/LiskDAO.php b/src/infrastructure/storage/lisk/LiskDAO.php
	index 3683e35e6f..b3f54d0817 100644
	--- a/src/infrastructure/storage/lisk/LiskDAO.php
	+++ b/src/infrastructure/storage/lisk/LiskDAO.php
	@@ -1,1823 +1,1715 @@
	<?php

	/**
	* Simple object-authoritative data access object that makes it easy to build
	* stuff that you need to save to a database. Basically, it means that the
	* amount of boilerplate code (and, particularly, boilerplate SQL) you need
	* to write is greatly reduced.
	*
	* Lisk makes it fairly easy to build something quickly and end up with
	* reasonably high-quality code when you're done (e.g., getters and setters,
	* objects, transactions, reasonably structured OO code). It's also very thin:
	* you can break past it and use MySQL and other lower-level tools when you
	* need to in those couple of cases where it doesn't handle your workflow
	* gracefully.
	*
	* However, Lisk won't scale past one database and lacks many of the features
	* of modern DAOs like Hibernate: for instance, it does not support joins or
	* polymorphic storage.
	*
	* This means that Lisk is well-suited for tools like Differential, but often a
	* poor choice elsewhere. And it is strictly unsuitable for many projects.
	*
	* Lisk's model is object-authoritative: the PHP class definition is the
	* master authority for what the object looks like.
	*
	* =Building New Objects=
	*
	* To create new Lisk objects, extend @{class:LiskDAO} and implement
	* @{method:establishLiveConnection}. It should return an
	* @{class:AphrontDatabaseConnection}; this will tell Lisk where to save your
	* objects.
	*
	* class Dog extends LiskDAO {
	*
	* protected $name;
	* protected $breed;
	*
	* public function establishLiveConnection() {
	* return $some_connection_object;
	* }
	* }
	*
	* Now, you should create your table:
	*
	* lang=sql
	* CREATE TABLE dog (
	* id int unsigned not null auto_increment primary key,
	* name varchar(32) not null,
	* breed varchar(32) not null,
	* dateCreated int unsigned not null,
	* dateModified int unsigned not null
	* );
	*
	* For each property in your class, add a column with the same name to the table
	* (see @{method:getConfiguration} for information about changing this mapping).
	* Additionally, you should create the three columns `id`, `dateCreated` and
	* `dateModified`. Lisk will automatically manage these, using them to implement
	* autoincrement IDs and timestamps. If you do not want to use these features,
	* see @{method:getConfiguration} for information on disabling them. At a bare
	* minimum, you must normally have an `id` column which is a primary or unique
	* key with a numeric type, although you can change its name by overriding
	* @{method:getIDKey} or disable it entirely by overriding @{method:getIDKey} to
	* return null. Note that many methods rely on a single-part primary key and
	* will no longer work (they will throw) if you disable it.
	*
	* As you add more properties to your class in the future, remember to add them
	* to the database table as well.
	*
	* Lisk will now automatically handle these operations: getting and setting
	* properties, saving objects, loading individual objects, loading groups
	* of objects, updating objects, managing IDs, updating timestamps whenever
	* an object is created or modified, and some additional specialized
	* operations.
	*
	* = Creating, Retrieving, Updating, and Deleting =
	*
	* To create and persist a Lisk object, use @{method:save}:
	*
	* $dog = id(new Dog())
	* ->setName('Sawyer')
	* ->setBreed('Pug')
	* ->save();
	*
	* Note that **Lisk automatically builds getters and setters for all of your
	* object's protected properties** via @{method:__call}. If you want to add
	* custom behavior to your getters or setters, you can do so by overriding the
	* @{method:readField} and @{method:writeField} methods.
	*
	* Calling @{method:save} will persist the object to the database. After calling
	* @{method:save}, you can call @{method:getID} to retrieve the object's ID.
	*
	* To load objects by ID, use the @{method:load} method:
	*
	* $dog = id(new Dog())->load($id);
	*
	* This will load the Dog record with ID $id into $dog, or `null` if no such
	* record exists (@{method:load} is an instance method rather than a static
	* method because PHP does not support late static binding, at least until PHP
	* 5.3).
	*
	* To update an object, change its properties and save it:
	*
	* $dog->setBreed('Lab')->save();
	*
	* To delete an object, call @{method:delete}:
	*
	* $dog->delete();
	*
	* That's Lisk CRUD in a nutshell.
	*
	* = Queries =
	*
	* Often, you want to load a bunch of objects, or execute a more specialized
	* query. Use @{method:loadAllWhere} or @{method:loadOneWhere} to do this:
	*
	* $pugs = $dog->loadAllWhere('breed = %s', 'Pug');
	* $sawyer = $dog->loadOneWhere('name = %s', 'Sawyer');
	*
	* These methods work like @{function@libphutil:queryfx}, but only take half of
	* a query (the part after the WHERE keyword). Lisk will handle the connection,
	* columns, and object construction; you are responsible for the rest of it.
	* @{method:loadAllWhere} returns a list of objects, while
	* @{method:loadOneWhere} returns a single object (or `null`).
	*
	* There's also a @{method:loadRelatives} method which helps to prevent the 1+N
	* queries problem.
	*
	* = Managing Transactions =
	*
	* Lisk uses a transaction stack, so code does not generally need to be aware
	* of the transactional state of objects to implement correct transaction
	* semantics:
	*
	* $obj->openTransaction();
	* $obj->save();
	* $other->save();
	* // ...
	* $other->openTransaction();
	* $other->save();
	* $another->save();
	* if ($some_condition) {
	* $other->saveTransaction();
	* } else {
	* $other->killTransaction();
	* }
	* // ...
	* $obj->saveTransaction();
	*
	* Assuming ##$obj##, ##$other## and ##$another## live on the same database,
	* this code will work correctly by establishing savepoints.
	*
	* Selects whose data are used later in the transaction should be included in
	* @{method:beginReadLocking} or @{method:beginWriteLocking} block.
	*
	* @task conn Managing Connections
	* @task config Configuring Lisk
	* @task load Loading Objects
	* @task info Examining Objects
	* @task save Writing Objects
	* @task hook Hooks and Callbacks
	* @task util Utilities
	* @task xaction Managing Transactions
	* @task isolate Isolation for Unit Testing
	*/
	abstract class LiskDAO {

	const CONFIG_IDS = 'id-mechanism';
	const CONFIG_TIMESTAMPS = 'timestamps';
	const CONFIG_AUX_PHID = 'auxiliary-phid';
	const CONFIG_SERIALIZATION = 'col-serialization';
	- const CONFIG_PARTIAL_OBJECTS = 'partial-objects';
	const CONFIG_BINARY = 'binary';

	const SERIALIZATION_NONE = 'id';
	const SERIALIZATION_JSON = 'json';
	const SERIALIZATION_PHP = 'php';

	const IDS_AUTOINCREMENT = 'ids-auto';
	const IDS_COUNTER = 'ids-counter';
	const IDS_MANUAL = 'ids-manual';

	const COUNTER_TABLE_NAME = 'lisk_counter';

	- private $dirtyFields = array();
	- private $missingFields = array();
	private static $processIsolationLevel = 0;
	private static $transactionIsolationLevel = 0;

	private $ephemeral = false;

	private static $connections = array();

	private $inSet = null;

	protected $id;
	protected $phid;
	protected $dateCreated;
	protected $dateModified;

	/**
	* Build an empty object.
	*
	* @return obj Empty object.
	*/
	public function __construct() {
	$id_key = $this->getIDKey();
	if ($id_key) {
	$this->$id_key = null;
	}
	-
	- if ($this->getConfigOption(self::CONFIG_PARTIAL_OBJECTS)) {
	- $this->resetDirtyFields();
	- }
	}


	/* -( Managing Connections )----------------------------------------------- */


	/**
	* Establish a live connection to a database service. This method should
	* return a new connection. Lisk handles connection caching and management;
	* do not perform caching deeper in the stack.
	*
	* @param string Mode, either 'r' (reading) or 'w' (reading and writing).
	* @return AphrontDatabaseConnection New database connection.
	* @task conn
	*/
	abstract protected function establishLiveConnection($mode);


	/**
	* Return a namespace for this object's connections in the connection cache.
	* Generally, the database name is appropriate. Two connections are considered
	* equivalent if they have the same connection namespace and mode.
	*
	* @return string Connection namespace for cache
	* @task conn
	*/
	abstract protected function getConnectionNamespace();


	/**
	* Get an existing, cached connection for this object.
	*
	* @param mode Connection mode.
	* @return AprontDatabaseConnection\|null Connection, if it exists in cache.
	* @task conn
	*/
	protected function getEstablishedConnection($mode) {
	$key = $this->getConnectionNamespace().':'.$mode;
	if (isset(self::$connections[$key])) {
	return self::$connections[$key];
	}
	return null;
	}


	/**
	* Store a connection in the connection cache.
	*
	* @param mode Connection mode.
	* @param AphrontDatabaseConnection Connection to cache.
	* @return this
	* @task conn
	*/
	protected function setEstablishedConnection(
	$mode,
	AphrontDatabaseConnection $connection,
	$force_unique = false) {

	$key = $this->getConnectionNamespace().':'.$mode;

	if ($force_unique) {
	$key .= ':unique';
	while (isset(self::$connections[$key])) {
	$key .= '!';
	}
	}

	self::$connections[$key] = $connection;
	return $this;
	}


	/* -( Configuring Lisk )--------------------------------------------------- */


	/**
	* Change Lisk behaviors, like ID configuration and timestamps. If you want
	* to change these behaviors, you should override this method in your child
	* class and change the options you're interested in. For example:
	*
	* public function getConfiguration() {
	* return array(
	* Lisk_DataAccessObject::CONFIG_EXAMPLE => true,
	* ) + parent::getConfiguration();
	* }
	*
	* The available options are:
	*
	* CONFIG_IDS
	* Lisk objects need to have a unique identifying ID. The three mechanisms
	* available for generating this ID are IDS_AUTOINCREMENT (default, assumes
	* the ID column is an autoincrement primary key), IDS_MANUAL (you are taking
	* full responsibility for ID management), or IDS_COUNTER (see below).
	*
	* InnoDB does not persist the value of `auto_increment` across restarts,
	* and instead initializes it to `MAX(id) + 1` during startup. This means it
	* may reissue the same autoincrement ID more than once, if the row is deleted
	* and then the database is restarted. To avoid this, you can set an object to
	* use a counter table with IDS_COUNTER. This will generally behave like
	* IDS_AUTOINCREMENT, except that the counter value will persist across
	* restarts and inserts will be slightly slower. If a database stores any
	* DAOs which use this mechanism, you must create a table there with this
	* schema:
	*
	* CREATE TABLE lisk_counter (
	* counterName VARCHAR(64) COLLATE utf8_bin PRIMARY KEY,
	* counterValue BIGINT UNSIGNED NOT NULL
	* ) ENGINE=InnoDB DEFAULT CHARSET=utf8;
	*
	* CONFIG_TIMESTAMPS
	* Lisk can automatically handle keeping track of a `dateCreated' and
	* `dateModified' column, which it will update when it creates or modifies
	* an object. If you don't want to do this, you may disable this option.
	* By default, this option is ON.
	*
	* CONFIG_AUX_PHID
	* This option can be enabled by being set to some truthy value. The meaning
	* of this value is defined by your PHID generation mechanism. If this option
	* is enabled, a `phid' property will be populated with a unique PHID when an
	* object is created (or if it is saved and does not currently have one). You
	* need to override generatePHID() and hook it into your PHID generation
	* mechanism for this to work. By default, this option is OFF.
	*
	* CONFIG_SERIALIZATION
	* You can optionally provide a column serialization map that will be applied
	* to values when they are written to the database. For example:
	*
	* self::CONFIG_SERIALIZATION => array(
	* 'complex' => self::SERIALIZATION_JSON,
	* )
	*
	* This will cause Lisk to JSON-serialize the 'complex' field before it is
	* written, and unserialize it when it is read.
	*
	- * CONFIG_PARTIAL_OBJECTS
	- * Sometimes, it is useful to load only some fields of an object (such as
	- * when you are loading all objects of a class, but only care about a few
	- * fields). Turning on this option (by setting it to a truthy value) allows
	- * users of the class to create/use partial objects, but it comes with some
	- * side effects: your class cannot override the setters and getters provided
	- * by Lisk (use readField and writeField instead), and you should not
	- * directly access or assign protected members of your class (use the getters
	- * and setters).
	- *
	* CONFIG_BINARY
	* You can optionally provide a map of columns to a flag indicating that
	* they store binary data. These columns will not raise an error when
	* handling binary writes.
	*
	* @return dictionary Map of configuration options to values.
	*
	* @task config
	*/
	protected function getConfiguration() {
	return array(
	self::CONFIG_IDS => self::IDS_AUTOINCREMENT,
	self::CONFIG_TIMESTAMPS => true,
	- self::CONFIG_PARTIAL_OBJECTS => false,
	);
	}


	/**
	* Determine the setting of a configuration option for this class of objects.
	*
	* @param const Option name, one of the CONFIG_* constants.
	* @return mixed Option value, if configured (null if unavailable).
	*
	* @task config
	*/
	public function getConfigOption($option_name) {
	static $options = null;

	if (!isset($options)) {
	$options = $this->getConfiguration();
	}

	return idx($options, $option_name);
	}


	/* -( Loading Objects )---------------------------------------------------- */


	/**
	* Load an object by ID. You need to invoke this as an instance method, not
	* a class method, because PHP doesn't have late static binding (until
	* PHP 5.3.0). For example:
	*
	* $dog = id(new Dog())->load($dog_id);
	*
	* @param int Numeric ID identifying the object to load.
	* @return obj\|null Identified object, or null if it does not exist.
	*
	* @task load
	*/
	public function load($id) {
	if (is_object($id)) {
	$id = (string)$id;
	}

	if (!$id \|\| (!is_int($id) && !ctype_digit($id))) {
	return null;
	}

	return $this->loadOneWhere(
	'%C = %d',
	$this->getIDKeyForUse(),
	$id);
	}


	/**
	* Loads all of the objects, unconditionally.
	*
	* @return dict Dictionary of all persisted objects of this type, keyed
	* on object ID.
	*
	* @task load
	*/
	public function loadAll() {
	return $this->loadAllWhere('1 = 1');
	}

	- /**
	- * Loads all objects, but only fetches the specified columns.
	- *
	- * @param array Array of canonical column names as strings
	- * @return dict Dictionary of all objects, keyed by ID.
	- *
	- * @task load
	- */
	- public function loadColumns(array $columns) {
	- return $this->loadColumnsWhere($columns, '1 = 1');
	- }
	-

	/**
	* Load all objects which match a WHERE clause. You provide everything after
	* the 'WHERE'; Lisk handles everything up to it. For example:
	*
	* $old_dogs = id(new Dog())->loadAllWhere('age > %d', 7);
	*
	* The pattern and arguments are as per queryfx().
	*
	* @param string queryfx()-style SQL WHERE clause.
	* @param ... Zero or more conversions.
	* @return dict Dictionary of matching objects, keyed on ID.
	*
	* @task load
	*/
	public function loadAllWhere($pattern /* , $arg, $arg, $arg ... */) {
	- $args = func_get_args();
	- array_unshift($args, null);
	- $data = call_user_func_array(
	- array($this, 'loadRawDataWhere'),
	- $args);
	- return $this->loadAllFromArray($data);
	- }
	-
	- /**
	- * Loads selected columns from objects that match a WHERE clause. You must
	- * provide everything after the WHERE. See loadAllWhere().
	- *
	- * @param array List of column names.
	- * @param string queryfx()-style SQL WHERE clause.
	- * @param ... Zero or more conversions.
	- * @return dict Dictionary of matching objecks, keyed by ID.
	- *
	- * @task load
	- */
	- public function loadColumnsWhere(array $columns, $pattern /* , $args... */) {
	- if (!$this->getConfigOption(self::CONFIG_PARTIAL_OBJECTS)) {
	- throw new BadMethodCallException(
	- 'This class does not support partial objects.');
	- }
	$args = func_get_args();
	$data = call_user_func_array(
	array($this, 'loadRawDataWhere'),
	$args);
	return $this->loadAllFromArray($data);
	}


	/**
	* Load a single object identified by a 'WHERE' clause. You provide
	* everything after the 'WHERE', and Lisk builds the first half of the
	* query. See loadAllWhere(). This method is similar, but returns a single
	* result instead of a list.
	*
	* @param string queryfx()-style SQL WHERE clause.
	* @param ... Zero or more conversions.
	* @return obj\|null Matching object, or null if no object matches.
	*
	* @task load
	*/
	public function loadOneWhere($pattern /* , $arg, $arg, $arg ... */) {
	$args = func_get_args();
	- array_unshift($args, null);
	$data = call_user_func_array(
	array($this, 'loadRawDataWhere'),
	$args);

	if (count($data) > 1) {
	throw new AphrontQueryCountException(
	'More than 1 result from loadOneWhere()!');
	}

	$data = reset($data);
	if (!$data) {
	return null;
	}

	return $this->loadFromArray($data);
	}


	- protected function loadRawDataWhere($columns, $pattern /* , $args... */) {
	+ protected function loadRawDataWhere($pattern /* , $args... */) {
	$connection = $this->establishConnection('r');

	$lock_clause = '';
	if ($connection->isReadLocking()) {
	$lock_clause = 'FOR UPDATE';
	} else if ($connection->isWriteLocking()) {
	$lock_clause = 'LOCK IN SHARE MODE';
	}

	$args = func_get_args();
	- $args = array_slice($args, 2);
	-
	- if (!$columns) {
	- $column = '*';
	- } else {
	- $column = '%LC';
	- $columns[] = $this->getIDKey();
	-
	- $properties = $this->getProperties();
	- $this->missingFields = array_diff_key(
	- array_flip($properties),
	- array_flip($columns));
	- }
	+ $args = array_slice($args, 1);

	- $pattern = 'SELECT '.$column.' FROM %T WHERE '.$pattern.' %Q';
	+ $pattern = 'SELECT * FROM %T WHERE '.$pattern.' %Q';
	array_unshift($args, $this->getTableName());
	- if ($columns) {
	- array_unshift($args, $columns);
	- }
	array_push($args, $lock_clause);
	array_unshift($args, $pattern);

	return call_user_func_array(
	array($connection, 'queryData'),
	$args);
	}


	/**
	* Reload an object from the database, discarding any changes to persistent
	* properties. This is primarily useful after entering a transaction but
	* before applying changes to an object.
	*
	* @return this
	*
	* @task load
	*/
	public function reload() {
	if (!$this->getID()) {
	throw new Exception("Unable to reload object that hasn't been loaded!");
	}

	$result = $this->loadOneWhere(
	'%C = %d',
	$this->getIDKeyForUse(),
	$this->getID());

	if (!$result) {
	throw new AphrontQueryObjectMissingException();
	}

	return $this;
	}


	/**
	* Initialize this object's properties from a dictionary. Generally, you
	* load single objects with loadOneWhere(), but sometimes it may be more
	* convenient to pull data from elsewhere directly (e.g., a complicated
	* join via @{method:queryData}) and then load from an array representation.
	*
	* @param dict Dictionary of properties, which should be equivalent to
	* selecting a row from the table or calling
	* @{method:getProperties}.
	* @return this
	*
	* @task load
	*/
	public function loadFromArray(array $row) {
	static $valid_properties = array();

	$map = array();
	foreach ($row as $k => $v) {
	// We permit (but ignore) extra properties in the array because a
	// common approach to building the array is to issue a raw SELECT query
	// which may include extra explicit columns or joins.

	// This pathway is very hot on some pages, so we're inlining a cache
	// and doing some microoptimization to avoid a strtolower() call for each
	// assignment. The common path (assigning a valid property which we've
	// already seen) always incurs only one empty(). The second most common
	// path (assigning an invalid property which we've already seen) costs
	// an empty() plus an isset().

	if (empty($valid_properties[$k])) {
	if (isset($valid_properties[$k])) {
	// The value is set but empty, which means it's false, so we've
	// already determined it's not valid. We don't need to check again.
	continue;
	}
	$valid_properties[$k] = $this->hasProperty($k);
	if (!$valid_properties[$k]) {
	continue;
	}
	}

	$map[$k] = $v;
	}

	$this->willReadData($map);

	foreach ($map as $prop => $value) {
	$this->$prop = $value;
	}

	$this->didReadData();

	return $this;
	}


	/**
	* Initialize a list of objects from a list of dictionaries. Usually you
	* load lists of objects with @{method:loadAllWhere}, but sometimes that
	* isn't flexible enough. One case is if you need to do joins to select the
	* right objects:
	*
	* function loadAllWithOwner($owner) {
	* $data = $this->queryData(
	* 'SELECT d.*
	* FROM owner o
	* JOIN owner_has_dog od ON o.id = od.ownerID
	* JOIN dog d ON od.dogID = d.id
	* WHERE o.id = %d',
	* $owner);
	* return $this->loadAllFromArray($data);
	* }
	*
	* This is a lot messier than @{method:loadAllWhere}, but more flexible.
	*
	* @param list List of property dictionaries.
	* @return dict List of constructed objects, keyed on ID.
	*
	* @task load
	*/
	public function loadAllFromArray(array $rows) {
	$result = array();

	$id_key = $this->getIDKey();

	foreach ($rows as $row) {
	$obj = clone $this;
	if ($id_key && isset($row[$id_key])) {
	$result[$row[$id_key]] = $obj->loadFromArray($row);
	} else {
	$result[] = $obj->loadFromArray($row);
	}
	if ($this->inSet) {
	$this->inSet->addToSet($obj);
	}
	}

	return $result;
	}

	/**
	* This method helps to prevent the 1+N queries problem. It happens when you
	* execute a query for each row in a result set. Like in this code:
	*
	* COUNTEREXAMPLE, name=Easy to write but expensive to execute
	* $diffs = id(new DifferentialDiff())->loadAllWhere(
	* 'revisionID = %d',
	* $revision->getID());
	* foreach ($diffs as $diff) {
	* $changesets = id(new DifferentialChangeset())->loadAllWhere(
	* 'diffID = %d',
	* $diff->getID());
	* // Do something with $changesets.
	* }
	*
	* One can solve this problem by reading all the dependent objects at once and
	* assigning them later:
	*
	* COUNTEREXAMPLE, name=Cheaper to execute but harder to write and maintain
	* $diffs = id(new DifferentialDiff())->loadAllWhere(
	* 'revisionID = %d',
	* $revision->getID());
	* $all_changesets = id(new DifferentialChangeset())->loadAllWhere(
	* 'diffID IN (%Ld)',
	* mpull($diffs, 'getID'));
	* $all_changesets = mgroup($all_changesets, 'getDiffID');
	* foreach ($diffs as $diff) {
	* $changesets = idx($all_changesets, $diff->getID(), array());
	* // Do something with $changesets.
	* }
	*
	* The method @{method:loadRelatives} abstracts this approach which allows
	* writing a code which is simple and efficient at the same time:
	*
	* name=Easy to write and cheap to execute
	* $diffs = $revision->loadRelatives(new DifferentialDiff(), 'revisionID');
	* foreach ($diffs as $diff) {
	* $changesets = $diff->loadRelatives(
	* new DifferentialChangeset(),
	* 'diffID');
	* // Do something with $changesets.
	* }
	*
	* This will load dependent objects for all diffs in the first call of
	* @{method:loadRelatives} and use this result for all following calls.
	*
	* The method supports working with set of sets, like in this code:
	*
	* $diffs = $revision->loadRelatives(new DifferentialDiff(), 'revisionID');
	* foreach ($diffs as $diff) {
	* $changesets = $diff->loadRelatives(
	* new DifferentialChangeset(),
	* 'diffID');
	* foreach ($changesets as $changeset) {
	* $hunks = $changeset->loadRelatives(
	* new DifferentialHunk(),
	* 'changesetID');
	* // Do something with hunks.
	* }
	* }
	*
	* This code will execute just three queries - one to load all diffs, one to
	* load all their related changesets and one to load all their related hunks.
	* You can try to write an equivalent code without using this method as
	* a homework.
	*
	* The method also supports retrieving referenced objects, for example authors
	* of all diffs (using shortcut @{method:loadOneRelative}):
	*
	* foreach ($diffs as $diff) {
	* $author = $diff->loadOneRelative(
	* new PhabricatorUser(),
	* 'phid',
	* 'getAuthorPHID');
	* // Do something with author.
	* }
	*
	* It is also possible to specify additional conditions for the `WHERE`
	* clause. Similarly to @{method:loadAllWhere}, you can specify everything
	* after `WHERE` (except `LIMIT`). Contrary to @{method:loadAllWhere}, it is
	* allowed to pass only a constant string (`%` doesn't have a special
	* meaning). This is intentional to avoid mistakes with using data from one
	* row in retrieving other rows. Example of a correct usage:
	*
	* $status = $author->loadOneRelative(
	* new PhabricatorCalendarEvent(),
	* 'userPHID',
	* 'getPHID',
	* '(UNIX_TIMESTAMP() BETWEEN dateFrom AND dateTo)');
	*
	* @param LiskDAO Type of objects to load.
	* @param string Name of the column in target table.
	* @param string Method name in this table.
	* @param string Additional constraints on returned rows. It supports no
	* placeholders and requires putting the WHERE part into
	* parentheses. It's not possible to use LIMIT.
	* @return list Objects of type $object.
	*
	* @task load
	*/
	public function loadRelatives(
	LiskDAO $object,
	$foreign_column,
	$key_method = 'getID',
	$where = '') {

	if (!$this->inSet) {
	id(new LiskDAOSet())->addToSet($this);
	}
	$relatives = $this->inSet->loadRelatives(
	$object,
	$foreign_column,
	$key_method,
	$where);
	return idx($relatives, $this->$key_method(), array());
	}

	/**
	* Load referenced row. See @{method:loadRelatives} for details.
	*
	* @param LiskDAO Type of objects to load.
	* @param string Name of the column in target table.
	* @param string Method name in this table.
	* @param string Additional constraints on returned rows. It supports no
	* placeholders and requires putting the WHERE part into
	* parentheses. It's not possible to use LIMIT.
	* @return LiskDAO Object of type $object or null if there's no such object.
	*
	* @task load
	*/
	final public function loadOneRelative(
	LiskDAO $object,
	$foreign_column,
	$key_method = 'getID',
	$where = '') {

	$relatives = $this->loadRelatives(
	$object,
	$foreign_column,
	$key_method,
	$where);

	if (!$relatives) {
	return null;
	}

	if (count($relatives) > 1) {
	throw new AphrontQueryCountException(
	'More than 1 result from loadOneRelative()!');
	}

	return reset($relatives);
	}

	final public function putInSet(LiskDAOSet $set) {
	$this->inSet = $set;
	return $this;
	}

	final protected function getInSet() {
	return $this->inSet;
	}


	/* -( Examining Objects )-------------------------------------------------- */


	/**
	* Set unique ID identifying this object. You normally don't need to call this
	* method unless with `IDS_MANUAL`.
	*
	* @param mixed Unique ID.
	* @return this
	* @task save
	*/
	public function setID($id) {
	static $id_key = null;
	if ($id_key === null) {
	$id_key = $this->getIDKeyForUse();
	}
	$this->$id_key = $id;
	return $this;
	}


	/**
	* Retrieve the unique ID identifying this object. This value will be null if
	* the object hasn't been persisted and you didn't set it manually.
	*
	* @return mixed Unique ID.
	*
	* @task info
	*/
	public function getID() {
	static $id_key = null;
	if ($id_key === null) {
	$id_key = $this->getIDKeyForUse();
	}
	return $this->$id_key;
	}


	public function getPHID() {
	return $this->phid;
	}


	/**
	* Test if a property exists.
	*
	* @param string Property name.
	* @return bool True if the property exists.
	* @task info
	*/
	public function hasProperty($property) {
	return (bool)$this->checkProperty($property);
	}


	/**
	* Retrieve a list of all object properties. This list only includes
	* properties that are declared as protected, and it is expected that
	* all properties returned by this function should be persisted to the
	* database.
	* Properties that should not be persisted must be declared as private.
	*
	* @return dict Dictionary of normalized (lowercase) to canonical (original
	* case) property names.
	*
	* @task info
	*/
	protected function getProperties() {
	static $properties = null;
	if (!isset($properties)) {
	$class = new ReflectionClass(get_class($this));
	$properties = array();
	foreach ($class->getProperties(ReflectionProperty::IS_PROTECTED) as $p) {
	$properties[strtolower($p->getName())] = $p->getName();
	}

	$id_key = $this->getIDKey();
	if ($id_key != 'id') {
	unset($properties['id']);
	}

	if (!$this->getConfigOption(self::CONFIG_TIMESTAMPS)) {
	unset($properties['datecreated']);
	unset($properties['datemodified']);
	}

	if ($id_key != 'phid' && !$this->getConfigOption(self::CONFIG_AUX_PHID)) {
	unset($properties['phid']);
	}
	}
	return $properties;
	}


	/**
	* Check if a property exists on this object.
	*
	* @return string\|null Canonical property name, or null if the property
	* does not exist.
	*
	* @task info
	*/
	protected function checkProperty($property) {
	static $properties = null;
	if ($properties === null) {
	$properties = $this->getProperties();
	}

	$property = strtolower($property);
	if (empty($properties[$property])) {
	return null;
	}

	return $properties[$property];
	}


	/**
	* Get or build the database connection for this object.
	*
	* @param string 'r' for read, 'w' for read/write.
	* @param bool True to force a new connection. The connection will not
	* be retrieved from or saved into the connection cache.
	* @return LiskDatabaseConnection Lisk connection object.
	*
	* @task info
	*/
	public function establishConnection($mode, $force_new = false) {
	if ($mode != 'r' && $mode != 'w') {
	throw new Exception("Unknown mode '{$mode}', should be 'r' or 'w'.");
	}

	if (self::shouldIsolateAllLiskEffectsToCurrentProcess()) {
	$mode = 'isolate-'.$mode;

	$connection = $this->getEstablishedConnection($mode);
	if (!$connection) {
	$connection = $this->establishIsolatedConnection($mode);
	$this->setEstablishedConnection($mode, $connection);
	}

	return $connection;
	}

	if (self::shouldIsolateAllLiskEffectsToTransactions()) {
	// If we're doing fixture transaction isolation, force the mode to 'w'
	// so we always get the same connection for reads and writes, and thus
	// can see the writes inside the transaction.
	$mode = 'w';
	}

	// TODO: There is currently no protection on 'r' queries against writing.

	$connection = null;
	if (!$force_new) {
	if ($mode == 'r') {
	// If we're requesting a read connection but already have a write
	// connection, reuse the write connection so that reads can take place
	// inside transactions.
	$connection = $this->getEstablishedConnection('w');
	}

	if (!$connection) {
	$connection = $this->getEstablishedConnection($mode);
	}
	}

	if (!$connection) {
	$connection = $this->establishLiveConnection($mode);
	if (self::shouldIsolateAllLiskEffectsToTransactions()) {
	$connection->openTransaction();
	}
	$this->setEstablishedConnection(
	$mode,
	$connection,
	$force_unique = $force_new);
	}

	return $connection;
	}


	/**
	* Convert this object into a property dictionary. This dictionary can be
	* restored into an object by using @{method:loadFromArray} (unless you're
	* using legacy features with CONFIG_CONVERT_CAMELCASE, but in that case you
	* should just go ahead and die in a fire).
	*
	* @return dict Dictionary of object properties.
	*
	* @task info
	*/
	protected function getPropertyValues() {
	$map = array();
	foreach ($this->getProperties() as $p) {
	// We may receive a warning here for properties we've implicitly added
	// through configuration; squelch it.
	$map[$p] = @$this->$p;
	}
	return $map;
	}


	/* -( Writing Objects )---------------------------------------------------- */


	/**
	* Make an object read-only.
	*
	* Making an object ephemeral indicates that you will be changing state in
	* such a way that you would never ever want it to be written back to the
	* storage.
	*/
	public function makeEphemeral() {
	$this->ephemeral = true;
	return $this;
	}

	private function isEphemeralCheck() {
	if ($this->ephemeral) {
	throw new LiskEphemeralObjectException();
	}
	}

	/**
	* Persist this object to the database. In most cases, this is the only
	* method you need to call to do writes. If the object has not yet been
	* inserted this will do an insert; if it has, it will do an update.
	*
	* @return this
	*
	* @task save
	*/
	public function save() {
	if ($this->shouldInsertWhenSaved()) {
	return $this->insert();
	} else {
	return $this->update();
	}
	}


	/**
	* Save this object, forcing the query to use REPLACE regardless of object
	* state.
	*
	* @return this
	*
	* @task save
	*/
	public function replace() {
	$this->isEphemeralCheck();
	return $this->insertRecordIntoDatabase('REPLACE');
	}


	/**
	* Save this object, forcing the query to use INSERT regardless of object
	* state.
	*
	* @return this
	*
	* @task save
	*/
	public function insert() {
	$this->isEphemeralCheck();
	return $this->insertRecordIntoDatabase('INSERT');
	}


	/**
	* Save this object, forcing the query to use UPDATE regardless of object
	* state.
	*
	* @return this
	*
	* @task save
	*/
	public function update() {
	$this->isEphemeralCheck();

	$this->willSaveObject();
	$data = $this->getPropertyValues();
	- if ($this->getConfigOption(self::CONFIG_PARTIAL_OBJECTS)) {
	- $data = array_intersect_key($data, $this->dirtyFields);
	- }
	$this->willWriteData($data);

	$map = array();
	foreach ($data as $k => $v) {
	$map[$k] = $v;
	}

	$conn = $this->establishConnection('w');
	$binary = $this->getBinaryColumns();

	foreach ($map as $key => $value) {
	if (!empty($binary[$key])) {
	$map[$key] = qsprintf($conn, '%C = %nB', $key, $value);
	} else {
	$map[$key] = qsprintf($conn, '%C = %ns', $key, $value);
	}
	}
	$map = implode(', ', $map);

	$id = $this->getID();
	$conn->query(
	'UPDATE %T SET %Q WHERE %C = '.(is_int($id) ? '%d' : '%s'),
	$this->getTableName(),
	$map,
	$this->getIDKeyForUse(),
	$id);
	// We can't detect a missing object because updating an object without
	// changing any values doesn't affect rows. We could jiggle timestamps
	// to catch this for objects which track them if we wanted.

	$this->didWriteData();

	- if ($this->getConfigOption(self::CONFIG_PARTIAL_OBJECTS)) {
	- $this->resetDirtyFields();
	- }
	-
	return $this;
	}


	/**
	* Delete this object, permanently.
	*
	* @return this
	*
	* @task save
	*/
	public function delete() {
	$this->isEphemeralCheck();
	$this->willDelete();

	$conn = $this->establishConnection('w');
	$conn->query(
	'DELETE FROM %T WHERE %C = %d',
	$this->getTableName(),
	$this->getIDKeyForUse(),
	$this->getID());

	$this->didDelete();

	return $this;
	}

	/**
	* Internal implementation of INSERT and REPLACE.
	*
	* @param const Either "INSERT" or "REPLACE", to force the desired mode.
	*
	* @task save
	*/
	protected function insertRecordIntoDatabase($mode) {
	$this->willSaveObject();
	$data = $this->getPropertyValues();

	$conn = $this->establishConnection('w');

	$id_mechanism = $this->getConfigOption(self::CONFIG_IDS);
	switch ($id_mechanism) {
	case self::IDS_AUTOINCREMENT:
	// If we are using autoincrement IDs, let MySQL assign the value for the
	// ID column, if it is empty. If the caller has explicitly provided a
	// value, use it.
	$id_key = $this->getIDKeyForUse();
	if (empty($data[$id_key])) {
	unset($data[$id_key]);
	}
	break;
	case self::IDS_COUNTER:
	// If we are using counter IDs, assign a new ID if we don't already have
	// one.
	$id_key = $this->getIDKeyForUse();
	if (empty($data[$id_key])) {
	$counter_name = $this->getTableName();
	$id = self::loadNextCounterID($conn, $counter_name);
	$this->setID($id);
	$data[$id_key] = $id;
	}
	break;
	case self::IDS_MANUAL:
	break;
	default:
	throw new Exception('Unknown CONFIG_IDs mechanism!');
	}

	$this->willWriteData($data);

	$columns = array_keys($data);
	$binary = $this->getBinaryColumns();

	foreach ($data as $key => $value) {
	try {
	if (!empty($binary[$key])) {
	$data[$key] = qsprintf($conn, '%nB', $value);
	} else {
	$data[$key] = qsprintf($conn, '%ns', $value);
	}
	} catch (AphrontQueryParameterException $parameter_exception) {
	throw new PhutilProxyException(
	pht(
	"Unable to insert or update object of class %s, field '%s' ".
	"has a nonscalar value.",
	get_class($this),
	$key),
	$parameter_exception);
	}
	}
	$data = implode(', ', $data);

	$conn->query(
	'%Q INTO %T (%LC) VALUES (%Q)',
	$mode,
	$this->getTableName(),
	$columns,
	$data);

	// Only use the insert id if this table is using auto-increment ids
	if ($id_mechanism === self::IDS_AUTOINCREMENT) {
	$this->setID($conn->getInsertID());
	}

	$this->didWriteData();

	- if ($this->getConfigOption(self::CONFIG_PARTIAL_OBJECTS)) {
	- $this->resetDirtyFields();
	- }
	-
	return $this;
	}


	/**
	* Method used to determine whether to insert or update when saving.
	*
	* @return bool true if the record should be inserted
	*/
	protected function shouldInsertWhenSaved() {
	$key_type = $this->getConfigOption(self::CONFIG_IDS);

	if ($key_type == self::IDS_MANUAL) {
	throw new Exception(
	'You are using manual IDs. You must override the '.
	'shouldInsertWhenSaved() method to properly detect '.
	'when to insert a new record.');
	} else {
	return !$this->getID();
	}
	}


	/* -( Hooks and Callbacks )------------------------------------------------ */


	/**
	* Retrieve the database table name. By default, this is the class name.
	*
	* @return string Table name for object storage.
	*
	* @task hook
	*/
	public function getTableName() {
	return get_class($this);
	}


	/**
	* Retrieve the primary key column, "id" by default. If you can not
	* reasonably name your ID column "id", override this method.
	*
	* @return string Name of the ID column.
	*
	* @task hook
	*/
	public function getIDKey() {
	return 'id';
	}


	protected function getIDKeyForUse() {
	$id_key = $this->getIDKey();
	if (!$id_key) {
	throw new Exception(
	'This DAO does not have a single-part primary key. The method you '.
	'called requires a single-part primary key.');
	}
	return $id_key;
	}


	/**
	* Generate a new PHID, used by CONFIG_AUX_PHID.
	*
	* @return phid Unique, newly allocated PHID.
	*
	* @task hook
	*/
	protected function generatePHID() {
	throw new Exception(
	'To use CONFIG_AUX_PHID, you need to overload '.
	'generatePHID() to perform PHID generation.');
	}


	/**
	* Hook to apply serialization or validation to data before it is written to
	* the database. See also @{method:willReadData}.
	*
	* @task hook
	*/
	protected function willWriteData(array &$data) {
	$this->applyLiskDataSerialization($data, false);
	}


	/**
	* Hook to perform actions after data has been written to the database.
	*
	* @task hook
	*/
	protected function didWriteData() {}


	/**
	* Hook to make internal object state changes prior to INSERT, REPLACE or
	* UPDATE.
	*
	* @task hook
	*/
	protected function willSaveObject() {
	$use_timestamps = $this->getConfigOption(self::CONFIG_TIMESTAMPS);

	if ($use_timestamps) {
	if (!$this->getDateCreated()) {
	$this->setDateCreated(time());
	}
	$this->setDateModified(time());
	}

	if ($this->getConfigOption(self::CONFIG_AUX_PHID) && !$this->getPHID()) {
	$this->setPHID($this->generatePHID());
	}
	}


	/**
	* Hook to apply serialization or validation to data as it is read from the
	* database. See also @{method:willWriteData}.
	*
	* @task hook
	*/
	protected function willReadData(array &$data) {
	$this->applyLiskDataSerialization($data, $deserialize = true);
	}

	/**
	* Hook to perform an action on data after it is read from the database.
	*
	* @task hook
	*/
	protected function didReadData() {}

	/**
	* Hook to perform an action before the deletion of an object.
	*
	* @task hook
	*/
	protected function willDelete() {}

	/**
	* Hook to perform an action after the deletion of an object.
	*
	* @task hook
	*/
	protected function didDelete() {}

	/**
	* Reads the value from a field. Override this method for custom behavior
	* of @{method:getField} instead of overriding getField directly.
	*
	* @param string Canonical field name
	* @return mixed Value of the field
	*
	* @task hook
	*/
	protected function readField($field) {
	if (isset($this->$field)) {
	return $this->$field;
	}
	return null;
	}

	/**
	* Writes a value to a field. Override this method for custom behavior of
	* setField($value) instead of overriding setField directly.
	*
	* @param string Canonical field name
	* @param mixed Value to write
	*
	* @task hook
	*/
	protected function writeField($field, $value) {
	$this->$field = $value;
	}


	/* -( Manging Transactions )----------------------------------------------- */


	/**
	* Increase transaction stack depth.
	*
	* @return this
	*/
	public function openTransaction() {
	$this->establishConnection('w')->openTransaction();
	return $this;
	}


	/**
	* Decrease transaction stack depth, saving work.
	*
	* @return this
	*/
	public function saveTransaction() {
	$this->establishConnection('w')->saveTransaction();
	return $this;
	}


	/**
	* Decrease transaction stack depth, discarding work.
	*
	* @return this
	*/
	public function killTransaction() {
	$this->establishConnection('w')->killTransaction();
	return $this;
	}


	/**
	* Begins read-locking selected rows with SELECT ... FOR UPDATE, so that
	* other connections can not read them (this is an enormous oversimplification
	* of FOR UPDATE semantics; consult the MySQL documentation for details). To
	* end read locking, call @{method:endReadLocking}. For example:
	*
	* $beach->openTransaction();
	* $beach->beginReadLocking();
	*
	* $beach->reload();
	* $beach->setGrainsOfSand($beach->getGrainsOfSand() + 1);
	* $beach->save();
	*
	* $beach->endReadLocking();
	* $beach->saveTransaction();
	*
	* @return this
	* @task xaction
	*/
	public function beginReadLocking() {
	$this->establishConnection('w')->beginReadLocking();
	return $this;
	}


	/**
	* Ends read-locking that began at an earlier @{method:beginReadLocking} call.
	*
	* @return this
	* @task xaction
	*/
	public function endReadLocking() {
	$this->establishConnection('w')->endReadLocking();
	return $this;
	}

	/**
	* Begins write-locking selected rows with SELECT ... LOCK IN SHARE MODE, so
	* that other connections can not update or delete them (this is an
	* oversimplification of LOCK IN SHARE MODE semantics; consult the
	* MySQL documentation for details). To end write locking, call
	* @{method:endWriteLocking}.
	*
	* @return this
	* @task xaction
	*/
	public function beginWriteLocking() {
	$this->establishConnection('w')->beginWriteLocking();
	return $this;
	}


	/**
	* Ends write-locking that began at an earlier @{method:beginWriteLocking}
	* call.
	*
	* @return this
	* @task xaction
	*/
	public function endWriteLocking() {
	$this->establishConnection('w')->endWriteLocking();
	return $this;
	}


	/* -( Isolation )---------------------------------------------------------- */


	/**
	* @task isolate
	*/
	public static function beginIsolateAllLiskEffectsToCurrentProcess() {
	self::$processIsolationLevel++;
	}

	/**
	* @task isolate
	*/
	public static function endIsolateAllLiskEffectsToCurrentProcess() {
	self::$processIsolationLevel--;
	if (self::$processIsolationLevel < 0) {
	throw new Exception(
	'Lisk process isolation level was reduced below 0.');
	}
	}

	/**
	* @task isolate
	*/
	public static function shouldIsolateAllLiskEffectsToCurrentProcess() {
	return (bool)self::$processIsolationLevel;
	}

	/**
	* @task isolate
	*/
	private function establishIsolatedConnection($mode) {
	$config = array();
	return new AphrontIsolatedDatabaseConnection($config);
	}

	/**
	* @task isolate
	*/
	public static function beginIsolateAllLiskEffectsToTransactions() {
	if (self::$transactionIsolationLevel === 0) {
	self::closeAllConnections();
	}
	self::$transactionIsolationLevel++;
	}

	/**
	* @task isolate
	*/
	public static function endIsolateAllLiskEffectsToTransactions() {
	self::$transactionIsolationLevel--;
	if (self::$transactionIsolationLevel < 0) {
	throw new Exception(
	'Lisk transaction isolation level was reduced below 0.');
	} else if (self::$transactionIsolationLevel == 0) {
	foreach (self::$connections as $key => $conn) {
	if ($conn) {
	$conn->killTransaction();
	}
	}
	self::closeAllConnections();
	}
	}

	/**
	* @task isolate
	*/
	public static function shouldIsolateAllLiskEffectsToTransactions() {
	return (bool)self::$transactionIsolationLevel;
	}

	public static function closeAllConnections() {
	self::$connections = array();
	}

	/* -( Utilities )---------------------------------------------------------- */


	/**
	* Applies configured serialization to a dictionary of values.
	*
	* @task util
	*/
	protected function applyLiskDataSerialization(array &$data, $deserialize) {
	$serialization = $this->getConfigOption(self::CONFIG_SERIALIZATION);
	if ($serialization) {
	foreach (array_intersect_key($serialization, $data) as $col => $format) {
	switch ($format) {
	case self::SERIALIZATION_NONE:
	break;
	case self::SERIALIZATION_PHP:
	if ($deserialize) {
	$data[$col] = unserialize($data[$col]);
	} else {
	$data[$col] = serialize($data[$col]);
	}
	break;
	case self::SERIALIZATION_JSON:
	if ($deserialize) {
	$data[$col] = json_decode($data[$col], true);
	} else {
	$data[$col] = json_encode($data[$col]);
	}
	break;
	default:
	throw new Exception("Unknown serialization format '{$format}'.");
	}
	}
	}
	}

	- /**
	- * Resets the dirty fields (fields which need to be written on next save/
	- * update/insert/replace). If this DAO has timestamps, the modified time
	- * is always a dirty field.
	- *
	- * @task util
	- */
	- private function resetDirtyFields() {
	- $this->dirtyFields = array();
	- if ($this->getConfigOption(self::CONFIG_TIMESTAMPS)) {
	- $this->dirtyFields['dateModified'] = true;
	- }
	- }
	-
	/**
	* Black magic. Builds implied get() and set() for all properties.
	*
	* @param string Method name.
	* @param list Argument vector.
	* @return mixed get() methods return the property value. set() methods
	* return $this.
	* @task util
	*/
	public function __call($method, $args) {
	// NOTE: PHP has a bug that static variables defined in __call() are shared
	// across all children classes. Call a different method to work around this
	// bug.
	return $this->call($method, $args);
	}

	/**
	* @task util
	*/
	final protected function call($method, $args) {
	// NOTE: This method is very performance-sensitive (many thousands of calls
	// per page on some pages), and thus has some silliness in the name of
	// optimizations.

	static $dispatch_map = array();
	- static $partial = null;
	- if ($partial === null) {
	- $partial = $this->getConfigOption(self::CONFIG_PARTIAL_OBJECTS);
	- }

	if ($method[0] === 'g') {
	if (isset($dispatch_map[$method])) {
	$property = $dispatch_map[$method];
	} else {
	if (substr($method, 0, 3) !== 'get') {
	throw new Exception("Unable to resolve method '{$method}'!");
	}
	$property = substr($method, 3);
	if (!($property = $this->checkProperty($property))) {
	throw new Exception("Bad getter call: {$method}");
	}
	$dispatch_map[$method] = $property;
	}

	- if ($partial && isset($this->missingFields[$property])) {
	- throw new Exception("Cannot get field that wasn't loaded: {$property}");
	- }
	-
	return $this->readField($property);
	}

	if ($method[0] === 's') {
	if (isset($dispatch_map[$method])) {
	$property = $dispatch_map[$method];
	} else {
	if (substr($method, 0, 3) !== 'set') {
	throw new Exception("Unable to resolve method '{$method}'!");
	}
	$property = substr($method, 3);
	$property = $this->checkProperty($property);
	if (!$property) {
	throw new Exception("Bad setter call: {$method}");
	}
	$dispatch_map[$method] = $property;
	}
	- if ($partial) {
	- // Accept writes to fields that weren't initially loaded
	- unset($this->missingFields[$property]);
	- $this->dirtyFields[$property] = true;
	- }

	$this->writeField($property, $args[0]);

	return $this;
	}

	throw new Exception("Unable to resolve method '{$method}'.");
	}

	/**
	* Warns against writing to undeclared property.
	*
	* @task util
	*/
	public function __set($name, $value) {
	phlog('Wrote to undeclared property '.get_class($this).'::$'.$name.'.');
	$this->$name = $value;
	}

	/**
	* Increments a named counter and returns the next value.
	*
	* @param AphrontDatabaseConnection Database where the counter resides.
	* @param string Counter name to create or increment.
	* @return int Next counter value.
	*
	* @task util
	*/
	public static function loadNextCounterID(
	AphrontDatabaseConnection $conn_w,
	$counter_name) {

	// NOTE: If an insert does not touch an autoincrement row or call
	// LAST_INSERT_ID(), MySQL normally does not change the value of
	// LAST_INSERT_ID(). This can cause a counter's value to leak to a
	// new counter if the second counter is created after the first one is
	// updated. To avoid this, we insert LAST_INSERT_ID(1), to ensure the
	// LAST_INSERT_ID() is always updated and always set correctly after the
	// query completes.

	queryfx(
	$conn_w,
	'INSERT INTO %T (counterName, counterValue) VALUES
	(%s, LAST_INSERT_ID(1))
	ON DUPLICATE KEY UPDATE
	counterValue = LAST_INSERT_ID(counterValue + 1)',
	self::COUNTER_TABLE_NAME,
	$counter_name);

	return $conn_w->getInsertID();
	}

	private function getBinaryColumns() {
	return $this->getConfigOption(self::CONFIG_BINARY);
	}

	}

File Metadata

Mime Type: text/x-diff
Expires: Tue, Feb 24, 6:41 PM (6 h, 48 m)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 850809
Default Alt Text: (80 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions