From e4a0c04f7b0577c067f258e3f972ac90c0da1dbc Mon Sep 17 00:00:00 2001 From: Jeroen De Dauw Date: Thu, 22 Mar 2012 02:56:32 +0100 Subject: [PATCH] Re-adding dbdataobject stuff which got pulled from core about 2 weeks back due to slush Patch set 4: Move files to includes/db Patch set 5: Update autoloader, pull in DB Change-Id: I2b961e043dd1af9c843995bac7fc77bd671caa5e --- includes/AutoLoader.php | 5 +- includes/db/ORMResult.php | 104 ++++++ includes/db/ORMRow.php | 661 +++++++++++++++++++++++++++++++++++ includes/db/ORMTable.php | 700 ++++++++++++++++++++++++++++++++++++++ 4 files changed, 1468 insertions(+), 2 deletions(-) create mode 100644 includes/db/ORMResult.php create mode 100644 includes/db/ORMRow.php create mode 100644 includes/db/ORMTable.php diff --git a/includes/AutoLoader.php b/includes/AutoLoader.php index 44ed532483..14fef8a612 100644 --- a/includes/AutoLoader.php +++ b/includes/AutoLoader.php @@ -51,8 +51,6 @@ $wgAutoloadLocalClasses = array( 'CookieJar' => 'includes/Cookie.php', 'MWCryptRand' => 'includes/CryptRand.php', 'CurlHttpRequest' => 'includes/HttpFunctions.php', -// 'DBDataObject' => 'includes/DBDataObject.php', -// 'DBTable' => 'includes/DBTable.php', 'DeferrableUpdate' => 'includes/DeferredUpdates.php', 'DeferredUpdates' => 'includes/DeferredUpdates.php', 'DeprecatedGlobal' => 'includes/DeprecatedGlobal.php', @@ -443,6 +441,9 @@ $wgAutoloadLocalClasses = array( 'MySQLMasterPos' => 'includes/db/DatabaseMysql.php', 'ORAField' => 'includes/db/DatabaseOracle.php', 'ORAResult' => 'includes/db/DatabaseOracle.php', + 'ORMResult' => 'includes/db/ORMResult.php', + 'ORMRow' => 'includes/db/ORMRow.php', + 'ORMTable' => 'includes/db/ORMTable.php', 'PostgresField' => 'includes/db/DatabasePostgres.php', 'ResultWrapper' => 'includes/db/DatabaseUtility.php', 'SQLiteField' => 'includes/db/DatabaseSqlite.php', diff --git a/includes/db/ORMResult.php b/includes/db/ORMResult.php new file mode 100644 index 0000000000..bed88092de --- /dev/null +++ b/includes/db/ORMResult.php @@ -0,0 +1,104 @@ + + */ +class ORMResult implements Iterator { + + /** + * @var ResultWrapper + */ + protected $res; + + /** + * @var integer + */ + protected $key; + + /** + * @var ORMRow + */ + protected $current; + + /** + * @var ORMTable + */ + protected $table; + + /** + * @param ORMTable $table + * @param ResultWrapper $res + */ + public function __construct( ORMTable $table, ResultWrapper $res ) { + $this->table = $table; + $this->res = $res; + $this->key = 0; + $this->setCurrent( $this->res->current() ); + } + + /** + * @param $row + */ + protected function setCurrent( $row ) { + if ( $row === false ) { + $this->current = false; + } else { + $this->current = $this->table->newFromDBResult( $row ); + } + } + + /** + * @return integer + */ + public function count() { + return $this->res->numRows(); + } + + /** + * @return boolean + */ + public function isEmpty() { + return $this->res->numRows() === 0; + } + + /** + * @return ORMRow + */ + public function current() { + return $this->current; + } + + /** + * @return integer + */ + public function key() { + return $this->key; + } + + public function next() { + $row = $this->res->next(); + $this->setCurrent( $row ); + $this->key++; + } + + public function rewind() { + $this->res->rewind(); + $this->key = 0; + $this->setCurrent( $this->res->current() ); + } + + /** + * @return boolean + */ + public function valid() { + return $this->current !== false; + } + +} diff --git a/includes/db/ORMRow.php b/includes/db/ORMRow.php new file mode 100644 index 0000000000..a063f7235c --- /dev/null +++ b/includes/db/ORMRow.php @@ -0,0 +1,661 @@ + + */ +abstract class ORMRow { + + /** + * The fields of the object. + * field name (w/o prefix) => value + * + * @since 1.20 + * @var array + */ + protected $fields = array( 'id' => null ); + + /** + * @since 1.20 + * @var ORMTable + */ + protected $table; + + /** + * If the object should update summaries of linked items when changed. + * For example, update the course_count field in universities when a course in courses is deleted. + * Settings this to false can prevent needless updating work in situations + * such as deleting a university, which will then delete all it's courses. + * + * @since 1.20 + * @var bool + */ + protected $updateSummaries = true; + + /** + * Indicates if the object is in summary mode. + * This mode indicates that only summary fields got updated, + * which allows for optimizations. + * + * @since 1.20 + * @var bool + */ + protected $inSummaryMode = false; + + /** + * Constructor. + * + * @since 1.20 + * + * @param ORMTable $table + * @param array|null $fields + * @param boolean $loadDefaults + */ + public function __construct( ORMTable $table, $fields = null, $loadDefaults = false ) { + $this->table = $table; + + if ( !is_array( $fields ) ) { + $fields = array(); + } + + if ( $loadDefaults ) { + $fields = array_merge( $this->table->getDefaults(), $fields ); + } + + $this->setFields( $fields ); + } + + /** + * Load the specified fields from the database. + * + * @since 1.20 + * + * @param array|null $fields + * @param boolean $override + * @param boolean $skipLoaded + * + * @return bool Success indicator + */ + public function loadFields( $fields = null, $override = true, $skipLoaded = false ) { + if ( is_null( $this->getId() ) ) { + return false; + } + + if ( is_null( $fields ) ) { + $fields = array_keys( $this->table->getFields() ); + } + + if ( $skipLoaded ) { + $fields = array_diff( $fields, array_keys( $this->fields ) ); + } + + if ( !empty( $fields ) ) { + $result = $this->table->rawSelectRow( + $this->table->getPrefixedFields( $fields ), + array( $this->table->getPrefixedField( 'id' ) => $this->getId() ), + array( 'LIMIT' => 1 ) + ); + + if ( $result !== false ) { + $this->setFields( $this->table->getFieldsFromDBResult( $result ), $override ); + return true; + } + return false; + } + + return true; + } + + /** + * Gets the value of a field. + * + * @since 1.20 + * + * @param string $name + * @param mixed $default + * + * @throws MWException + * @return mixed + */ + public function getField( $name, $default = null ) { + if ( $this->hasField( $name ) ) { + return $this->fields[$name]; + } elseif ( !is_null( $default ) ) { + return $default; + } else { + throw new MWException( 'Attempted to get not-set field ' . $name ); + } + } + + /** + * Gets the value of a field but first loads it if not done so already. + * + * @since 1.20 + * + * @param string$name + * + * @return mixed + */ + public function loadAndGetField( $name ) { + if ( !$this->hasField( $name ) ) { + $this->loadFields( array( $name ) ); + } + + return $this->getField( $name ); + } + + /** + * Remove a field. + * + * @since 1.20 + * + * @param string $name + */ + public function removeField( $name ) { + unset( $this->fields[$name] ); + } + + /** + * Returns the objects database id. + * + * @since 1.20 + * + * @return integer|null + */ + public function getId() { + return $this->getField( 'id' ); + } + + /** + * Sets the objects database id. + * + * @since 1.20 + * + * @param integer|null $id + */ + public function setId( $id ) { + return $this->setField( 'id', $id ); + } + + /** + * Gets if a certain field is set. + * + * @since 1.20 + * + * @param string $name + * + * @return boolean + */ + public function hasField( $name ) { + return array_key_exists( $name, $this->fields ); + } + + /** + * Gets if the id field is set. + * + * @since 1.20 + * + * @return boolean + */ + public function hasIdField() { + return $this->hasField( 'id' ) + && !is_null( $this->getField( 'id' ) ); + } + + /** + * Sets multiple fields. + * + * @since 1.20 + * + * @param array $fields The fields to set + * @param boolean $override Override already set fields with the provided values? + */ + public function setFields( array $fields, $override = true ) { + foreach ( $fields as $name => $value ) { + if ( $override || !$this->hasField( $name ) ) { + $this->setField( $name, $value ); + } + } + } + + /** + * Gets the fields => values to write to the table. + * + * @since 1.20 + * + * @return array + */ + protected function getWriteValues() { + $values = array(); + + foreach ( $this->table->getFields() as $name => $type ) { + if ( array_key_exists( $name, $this->fields ) ) { + $value = $this->fields[$name]; + + switch ( $type ) { + case 'array': + $value = (array)$value; + case 'blob': + $value = serialize( $value ); + } + + $values[$this->table->getPrefixedField( $name )] = $value; + } + } + + return $values; + } + + /** + * Serializes the object to an associative array which + * can then easily be converted into JSON or similar. + * + * @since 1.20 + * + * @param null|array $fields + * @param boolean $incNullId + * + * @return array + */ + public function toArray( $fields = null, $incNullId = false ) { + $data = array(); + $setFields = array(); + + if ( !is_array( $fields ) ) { + $setFields = $this->getSetFieldNames(); + } else { + foreach ( $fields as $field ) { + if ( $this->hasField( $field ) ) { + $setFields[] = $field; + } + } + } + + foreach ( $setFields as $field ) { + if ( $incNullId || $field != 'id' || $this->hasIdField() ) { + $data[$field] = $this->getField( $field ); + } + } + + return $data; + } + + /** + * Load the default values, via getDefaults. + * + * @since 1.20 + * + * @param boolean $override + */ + public function loadDefaults( $override = true ) { + $this->setFields( $this->table->getDefaults(), $override ); + } + + /** + * Writes the answer to the database, either updating it + * when it already exists, or inserting it when it doesn't. + * + * @since 1.20 + * + * @param string|null $functionName + * + * @return boolean Success indicator + */ + public function save( $functionName = null ) { + if ( $this->hasIdField() ) { + return $this->saveExisting( $functionName ); + } else { + return $this->insert( $functionName ); + } + } + + /** + * Updates the object in the database. + * + * @since 1.20 + * + * @param string|null $functionName + * + * @return boolean Success indicator + */ + protected function saveExisting( $functionName = null ) { + $dbw = wfGetDB( DB_MASTER ); + + $success = $dbw->update( + $this->table->getName(), + $this->getWriteValues(), + $this->table->getPrefixedValues( $this->getUpdateConditions() ), + is_null( $functionName ) ? __METHOD__ : $functionName + ); + + return $success; + } + + /** + * Returns the WHERE considtions needed to identify this object so + * it can be updated. + * + * @since 1.20 + * + * @return array + */ + protected function getUpdateConditions() { + return array( 'id' => $this->getId() ); + } + + /** + * Inserts the object into the database. + * + * @since 1.20 + * + * @param string|null $functionName + * @param array|null $options + * + * @return boolean Success indicator + */ + protected function insert( $functionName = null, array $options = null ) { + $dbw = wfGetDB( DB_MASTER ); + + $result = $dbw->insert( + $this->table->getName(), + $this->getWriteValues(), + is_null( $functionName ) ? __METHOD__ : $functionName, + is_null( $options ) ? array( 'IGNORE' ) : $options + ); + + if ( $result ) { + $this->setField( 'id', $dbw->insertId() ); + } + + return $result; + } + + /** + * Removes the object from the database. + * + * @since 1.20 + * + * @return boolean Success indicator + */ + public function remove() { + $this->beforeRemove(); + + $success = $this->table->delete( array( 'id' => $this->getId() ) ); + + if ( $success ) { + $this->onRemoved(); + } + + return $success; + } + + /** + * Gets called before an object is removed from the database. + * + * @since 1.20 + */ + protected function beforeRemove() { + $this->loadFields( $this->getBeforeRemoveFields(), false, true ); + } + + /** + * Before removal of an object happens, @see beforeRemove gets called. + * This method loads the fields of which the names have been returned by this one (or all fields if null is returned). + * This allows for loading info needed after removal to get rid of linked data and the like. + * + * @since 1.20 + * + * @return array|null + */ + protected function getBeforeRemoveFields() { + return array(); + } + + /** + * Gets called after successfull removal. + * Can be overriden to get rid of linked data. + * + * @since 1.20 + */ + protected function onRemoved() { + $this->setField( 'id', null ); + } + + /** + * Return the names and values of the fields. + * + * @since 1.20 + * + * @return array + */ + public function getFields() { + return $this->fields; + } + + /** + * Return the names of the fields. + * + * @since 1.20 + * + * @return array + */ + public function getSetFieldNames() { + return array_keys( $this->fields ); + } + + /** + * Sets the value of a field. + * Strings can be provided for other types, + * so this method can be called from unserialization handlers. + * + * @since 1.20 + * + * @param string $name + * @param mixed $value + * + * @throws MWException + */ + public function setField( $name, $value ) { + $fields = $this->table->getFields(); + + if ( array_key_exists( $name, $fields ) ) { + switch ( $fields[$name] ) { + case 'int': + $value = (int)$value; + break; + case 'float': + $value = (float)$value; + break; + case 'bool': + if ( is_string( $value ) ) { + $value = $value !== '0'; + } elseif ( is_int( $value ) ) { + $value = $value !== 0; + } + break; + case 'array': + if ( is_string( $value ) ) { + $value = unserialize( $value ); + } + + if ( !is_array( $value ) ) { + $value = array(); + } + break; + case 'blob': + if ( is_string( $value ) ) { + $value = unserialize( $value ); + } + break; + case 'id': + if ( is_string( $value ) ) { + $value = (int)$value; + } + break; + } + + $this->fields[$name] = $value; + } else { + throw new MWException( 'Attempted to set unknown field ' . $name ); + } + } + + /** + * Add an amount (can be negative) to the specified field (needs to be numeric). + * + * @since 1.20 + * + * @param string $field + * @param integer $amount + * + * @return boolean Success indicator + */ + public function addToField( $field, $amount ) { + if ( $amount == 0 ) { + return true; + } + + if ( !$this->hasIdField() ) { + return false; + } + + $absoluteAmount = abs( $amount ); + $isNegative = $amount < 0; + + $dbw = wfGetDB( DB_MASTER ); + + $fullField = $this->table->getPrefixedField( $field ); + + $success = $dbw->update( + $this->table->getName(), + array( "$fullField=$fullField" . ( $isNegative ? '-' : '+' ) . $absoluteAmount ), + array( $this->table->getPrefixedField( 'id' ) => $this->getId() ), + __METHOD__ + ); + + if ( $success && $this->hasField( $field ) ) { + $this->setField( $field, $this->getField( $field ) + $amount ); + } + + return $success; + } + + /** + * Return the names of the fields. + * + * @since 1.20 + * + * @return array + */ + public function getFieldNames() { + return array_keys( $this->table->getFields() ); + } + + /** + * Computes and updates the values of the summary fields. + * + * @since 1.20 + * + * @param array|string|null $summaryFields + */ + public function loadSummaryFields( $summaryFields = null ) { + + } + + /** + * Sets the value for the @see $updateSummaries field. + * + * @since 1.20 + * + * @param boolean $update + */ + public function setUpdateSummaries( $update ) { + $this->updateSummaries = $update; + } + + /** + * Sets the value for the @see $inSummaryMode field. + * + * @since 1.20 + * + * @param boolean $summaryMode + */ + public function setSummaryMode( $summaryMode ) { + $this->inSummaryMode = $summaryMode; + } + + /** + * Return if any fields got changed. + * + * @since 1.20 + * + * @param ORMRow $object + * @param boolean|array $excludeSummaryFields + * When set to true, summary field changes are ignored. + * Can also be an array of fields to ignore. + * + * @return boolean + */ + protected function fieldsChanged( ORMRow $object, $excludeSummaryFields = false ) { + $exclusionFields = array(); + + if ( $excludeSummaryFields !== false ) { + $exclusionFields = is_array( $excludeSummaryFields ) ? $excludeSummaryFields : $this->table->getSummaryFields(); + } + + foreach ( $this->fields as $name => $value ) { + $excluded = $excludeSummaryFields && in_array( $name, $exclusionFields ); + + if ( !$excluded && $object->getField( $name ) !== $value ) { + return true; + } + } + + return false; + } + + /** + * Returns the table this ORMRow is a row in. + * + * @since 1.20 + * + * @return ORMTable + */ + public function getTable() { + return $this->table; + } + +} diff --git a/includes/db/ORMTable.php b/includes/db/ORMTable.php new file mode 100644 index 0000000000..651eadd5c3 --- /dev/null +++ b/includes/db/ORMTable.php @@ -0,0 +1,700 @@ + + */ +abstract class ORMTable { + + /** + * Returns the name of the database table objects of this type are stored in. + * + * @since 1.20 + * + * @return string + */ + public abstract function getName(); + + /** + * Returns the name of a ORMRow deriving class that + * represents single rows in this table. + * + * @since 1.20 + * + * @return string + */ + public abstract function getRowClass(); + + /** + * Gets the db field prefix. + * + * @since 1.20 + * + * @return string + */ + protected abstract function getFieldPrefix(); + + /** + * Returns an array with the fields and their types this object contains. + * This corresponds directly to the fields in the database, without prefix. + * + * field name => type + * + * Allowed types: + * * id + * * str + * * int + * * float + * * bool + * * array + * + * @since 1.20 + * + * @return array + */ + public abstract function getFields(); + + /** + * Cache for instances, used by the singleton method. + * + * @since 1.20 + * @var array of DBTable + */ + protected static $instanceCache = array(); + + /** + * The database connection to use for read operations. + * Can be changed via @see setReadDb. + * + * @since 1.20 + * @var integer DB_ enum + */ + protected $readDb = DB_SLAVE; + + /** + * Returns a list of default field values. + * field name => field value + * + * @since 1.20 + * + * @return array + */ + public function getDefaults() { + return array(); + } + + /** + * Returns a list of the summary fields. + * These are fields that cache computed values, such as the amount of linked objects of $type. + * This is relevant as one might not want to do actions such as log changes when these get updated. + * + * @since 1.20 + * + * @return array + */ + public function getSummaryFields() { + return array(); + } + + /** + * Selects the the specified fields of the records matching the provided + * conditions and returns them as DBDataObject. Field names get prefixed. + * + * @since 1.20 + * + * @param array|string|null $fields + * @param array $conditions + * @param array $options + * @param string|null $functionName + * + * @return ORMResult + */ + public function select( $fields = null, array $conditions = array(), + array $options = array(), $functionName = null ) { + return new ORMResult( $this, $this->rawSelect( $fields, $conditions, $options, $functionName ) ); + } + + /** + * Selects the the specified fields of the records matching the provided + * conditions and returns them as DBDataObject. Field names get prefixed. + * + * @since 1.20 + * + * @param array|string|null $fields + * @param array $conditions + * @param array $options + * @param string|null $functionName + * + * @return array of self + */ + public function selectObjects( $fields = null, array $conditions = array(), + array $options = array(), $functionName = null ) { + $result = $this->selectFields( $fields, $conditions, $options, false, $functionName ); + + $objects = array(); + + foreach ( $result as $record ) { + $objects[] = $this->newFromArray( $record ); + } + + return $objects; + } + + /** + * Do the actual select. + * + * @since 1.20 + * + * @param null|string|array $fields + * @param array $conditions + * @param array $options + * @param null|string $functionName + * + * @return ResultWrapper + */ + public function rawSelect( $fields = null, array $conditions = array(), + array $options = array(), $functionName = null ) { + if ( is_null( $fields ) ) { + $fields = array_keys( $this->getFields() ); + } + else { + $fields = (array)$fields; + } + + return wfGetDB( $this->getReadDb() )->select( + $this->getName(), + $this->getPrefixedFields( $fields ), + $this->getPrefixedValues( $conditions ), + is_null( $functionName ) ? __METHOD__ : $functionName, + $options + ); + } + + /** + * Selects the the specified fields of the records matching the provided + * conditions and returns them as associative arrays. + * Provided field names get prefixed. + * Returned field names will not have a prefix. + * + * When $collapse is true: + * If one field is selected, each item in the result array will be this field. + * If two fields are selected, each item in the result array will have as key + * the first field and as value the second field. + * If more then two fields are selected, each item will be an associative array. + * + * @since 1.20 + * + * @param array|string|null $fields + * @param array $conditions + * @param array $options + * @param boolean $collapse Set to false to always return each result row as associative array. + * @param string|null $functionName + * + * @return array of array + */ + public function selectFields( $fields = null, array $conditions = array(), + array $options = array(), $collapse = true, $functionName = null ) { + $objects = array(); + + $result = $this->rawSelect( $fields, $conditions, $options, $functionName ); + + foreach ( $result as $record ) { + $objects[] = $this->getFieldsFromDBResult( $record ); + } + + if ( $collapse ) { + if ( count( $fields ) === 1 ) { + $objects = array_map( 'array_shift', $objects ); + } + elseif ( count( $fields ) === 2 ) { + $o = array(); + + foreach ( $objects as $object ) { + $o[array_shift( $object )] = array_shift( $object ); + } + + $objects = $o; + } + } + + return $objects; + } + + /** + * Selects the the specified fields of the first matching record. + * Field names get prefixed. + * + * @since 1.20 + * + * @param array|string|null $fields + * @param array $conditions + * @param array $options + * @param string|null $functionName + * + * @return DBObject|bool False on failure + */ + public function selectRow( $fields = null, array $conditions = array(), + array $options = array(), $functionName = null ) { + $options['LIMIT'] = 1; + + $objects = $this->select( $fields, $conditions, $options, $functionName ); + + return $objects->isEmpty() ? false : $objects->current(); + } + + /** + * Selects the the specified fields of the records matching the provided + * conditions. Field names do NOT get prefixed. + * + * @since 1.20 + * + * @param array $fields + * @param array $conditions + * @param array $options + * @param string|null $functionName + * + * @return ResultWrapper + */ + public function rawSelectRow( array $fields, array $conditions = array(), + array $options = array(), $functionName = null ) { + $dbr = wfGetDB( $this->getReadDb() ); + + return $dbr->selectRow( + $this->getName(), + $fields, + $conditions, + is_null( $functionName ) ? __METHOD__ : $functionName, + $options + ); + } + + /** + * Selects the the specified fields of the first record matching the provided + * conditions and returns it as an associative array, or false when nothing matches. + * This method makes use of selectFields and expects the same parameters and + * returns the same results (if there are any, if there are none, this method returns false). + * @see ORMTable::selectFields + * + * @since 1.20 + * + * @param array|string|null $fields + * @param array $conditions + * @param array $options + * @param boolean $collapse Set to false to always return each result row as associative array. + * @param string|null $functionName + * + * @return mixed|array|bool False on failure + */ + public function selectFieldsRow( $fields = null, array $conditions = array(), + array $options = array(), $collapse = true, $functionName = null ) { + $options['LIMIT'] = 1; + + $objects = $this->selectFields( $fields, $conditions, $options, $collapse, $functionName ); + + return empty( $objects ) ? false : $objects[0]; + } + + /** + * Returns if there is at least one record matching the provided conditions. + * Condition field names get prefixed. + * + * @since 1.20 + * + * @param array $conditions + * + * @return boolean + */ + public function has( array $conditions = array() ) { + return $this->selectRow( array( 'id' ), $conditions ) !== false; + } + + /** + * Returns the amount of matching records. + * Condition field names get prefixed. + * + * Note that this can be expensive on large tables. + * In such cases you might want to use DatabaseBase::estimateRowCount instead. + * + * @since 1.20 + * + * @param array $conditions + * @param array $options + * + * @return integer + */ + public function count( array $conditions = array(), array $options = array() ) { + $res = $this->rawSelectRow( + array( 'COUNT(*) AS rowcount' ), + $this->getPrefixedValues( $conditions ), + $options + ); + + return $res->rowcount; + } + + /** + * Removes the object from the database. + * + * @since 1.20 + * + * @param array $conditions + * @param string|null $functionName + * + * @return boolean Success indicator + */ + public function delete( array $conditions, $functionName = null ) { + return wfGetDB( DB_MASTER )->delete( + $this->getName(), + $this->getPrefixedValues( $conditions ), + $functionName + ); + } + + /** + * Get API parameters for the fields supported by this object. + * + * @since 1.20 + * + * @param boolean $requireParams + * @param boolean $setDefaults + * + * @return array + */ + public function getAPIParams( $requireParams = false, $setDefaults = false ) { + $typeMap = array( + 'id' => 'integer', + 'int' => 'integer', + 'float' => 'NULL', + 'str' => 'string', + 'bool' => 'integer', + 'array' => 'string', + 'blob' => 'string', + ); + + $params = array(); + $defaults = $this->getDefaults(); + + foreach ( $this->getFields() as $field => $type ) { + if ( $field == 'id' ) { + continue; + } + + $hasDefault = array_key_exists( $field, $defaults ); + + $params[$field] = array( + ApiBase::PARAM_TYPE => $typeMap[$type], + ApiBase::PARAM_REQUIRED => $requireParams && !$hasDefault + ); + + if ( $type == 'array' ) { + $params[$field][ApiBase::PARAM_ISMULTI] = true; + } + + if ( $setDefaults && $hasDefault ) { + $default = is_array( $defaults[$field] ) ? implode( '|', $defaults[$field] ) : $defaults[$field]; + $params[$field][ApiBase::PARAM_DFLT] = $default; + } + } + + return $params; + } + + /** + * Returns an array with the fields and their descriptions. + * + * field name => field description + * + * @since 1.20 + * + * @return array + */ + public function getFieldDescriptions() { + return array(); + } + + /** + * Get the database type used for read operations. + * + * @since 1.20 + * + * @return integer DB_ enum + */ + public function getReadDb() { + return $this->readDb; + } + + /** + * Set the database type to use for read operations. + * + * @param integer $db + * + * @since 1.20 + */ + public function setReadDb( $db ) { + $this->readDb = $db; + } + + /** + * Update the records matching the provided conditions by + * setting the fields that are keys in the $values param to + * their corresponding values. + * + * @since 1.20 + * + * @param array $values + * @param array $conditions + * + * @return boolean Success indicator + */ + public function update( array $values, array $conditions = array() ) { + $dbw = wfGetDB( DB_MASTER ); + + return $dbw->update( + $this->getName(), + $this->getPrefixedValues( $values ), + $this->getPrefixedValues( $conditions ), + __METHOD__ + ); + } + + /** + * Computes the values of the summary fields of the objects matching the provided conditions. + * + * @since 1.20 + * + * @param array|string|null $summaryFields + * @param array $conditions + */ + public function updateSummaryFields( $summaryFields = null, array $conditions = array() ) { + $this->setReadDb( DB_MASTER ); + + foreach ( $this->select( null, $conditions ) as /* ORMRow */ $item ) { + $item->loadSummaryFields( $summaryFields ); + $item->setSummaryMode( true ); + $item->save(); + } + + $this->setReadDb( DB_SLAVE ); + } + + /** + * Takes in an associative array with field names as keys and + * their values as value. The field names are prefixed with the + * db field prefix. + * + * Field names can also be provided as an array with as first element a table name, such as + * $conditions = array( + * array( array( 'tablename', 'fieldname' ), $value ), + * ); + * + * @since 1.20 + * + * @param array $values + * + * @return array + */ + public function getPrefixedValues( array $values ) { + $prefixedValues = array(); + + foreach ( $values as $field => $value ) { + if ( is_integer( $field ) ) { + if ( is_array( $value ) ) { + $field = $value[0]; + $value = $value[1]; + } + else { + $value = explode( ' ', $value, 2 ); + $value[0] = $this->getPrefixedField( $value[0] ); + $prefixedValues[] = implode( ' ', $value ); + continue; + } + } + + $prefixedValues[$this->getPrefixedField( $field )] = $value; + } + + return $prefixedValues; + } + + /** + * Takes in a field or array of fields and returns an + * array with their prefixed versions, ready for db usage. + * + * @since 1.20 + * + * @param array|string $fields + * + * @return array + */ + public function getPrefixedFields( array $fields ) { + foreach ( $fields as &$field ) { + $field = $this->getPrefixedField( $field ); + } + + return $fields; + } + + /** + * Takes in a field and returns an it's prefixed version, ready for db usage. + * + * @since 1.20 + * + * @param string|array $field + * + * @return string + */ + public function getPrefixedField( $field ) { + return $this->getFieldPrefix() . $field; + } + + /** + * Takes an array of field names with prefix and returns the unprefixed equivalent. + * + * @since 1.20 + * + * @param array $fieldNames + * + * @return array + */ + public function unprefixFieldNames( array $fieldNames ) { + return array_map( array( $this, 'unprefixFieldName' ), $fieldNames ); + } + + /** + * Takes a field name with prefix and returns the unprefixed equivalent. + * + * @since 1.20 + * + * @param string $fieldName + * + * @return string + */ + public function unprefixFieldName( $fieldName ) { + return substr( $fieldName, strlen( $this->getFieldPrefix() ) ); + } + + /** + * Get an instance of this class. + * + * @since 1.20 + * + * @return ORMTable + */ + public static function singleton() { + $class = function_exists( 'get_called_class' ) ? get_called_class() : self::get_called_class(); + + if ( !array_key_exists( $class, self::$instanceCache ) ) { + self::$instanceCache[$class] = new $class; + } + + return self::$instanceCache[$class]; + } + + /** + * Compatibility fallback function so the singleton method works on PHP < 5.3. + * Code borrowed from http://www.php.net/manual/en/function.get-called-class.php#107445 + * + * @since 1.20 + * + * @return string + */ + protected static function get_called_class() { + $bt = debug_backtrace(); + $l = count($bt) - 1; + $matches = array(); + while(empty($matches) && $l > -1){ + $lines = file($bt[$l]['file']); + $callerLine = $lines[$bt[$l]['line']-1]; + preg_match('/([a-zA-Z0-9\_]+)::'.$bt[$l--]['function'].'/', + $callerLine, + $matches); + } + if (!isset($matches[1])) $matches[1]=NULL; //for notices + if ($matches[1] == 'self') { + $line = $bt[$l]['line']-1; + while ($line > 0 && strpos($lines[$line], 'class') === false) { + $line--; + } + preg_match('/class[\s]+(.+?)[\s]+/si', $lines[$line], $matches); + } + return $matches[1]; + } + + /** + * Get an array with fields from a database result, + * that can be fed directly to the constructor or + * to setFields. + * + * @since 1.20 + * + * @param stdClass $result + * + * @return array + */ + public function getFieldsFromDBResult( stdClass $result ) { + $result = (array)$result; + return array_combine( + $this->unprefixFieldNames( array_keys( $result ) ), + array_values( $result ) + ); + } + + /** + * Get a new instance of the class from a database result. + * + * @since 1.20 + * + * @param stdClass $result + * + * @return ORMRow + */ + public function newFromDBResult( stdClass $result ) { + return $this->newFromArray( $this->getFieldsFromDBResult( $result ) ); + } + + /** + * Get a new instance of the class from an array. + * + * @since 1.20 + * + * @param array $data + * @param boolean $loadDefaults + * + * @return ORMRow + */ + public function newFromArray( array $data, $loadDefaults = false ) { + $class = $this->getRowClass(); + return new $class( $this, $data, $loadDefaults ); + } + + /** + * Return the names of the fields. + * + * @since 1.20 + * + * @return array + */ + public function getFieldNames() { + return array_keys( $this->getFields() ); + } + + /** + * Gets if the object can take a certain field. + * + * @since 1.20 + * + * @param string $name + * + * @return boolean + */ + public function canHaveField( $name ) { + return array_key_exists( $name, $this->getFields() ); + } + +} -- 2.20.1