ORMTable.php

Go to the documentation of this file.

<?php
abstract class ORMTable implements IORMTable {

        protected abstract function getFieldPrefix();

        protected static $instanceCache = array();

        protected $readDb = DB_SLAVE;

        public function getDefaults() {
                return array();
        }

        public function getSummaryFields() {
                return array();
        }

        public function select( $fields = null, array $conditions = array(),
                                                        array $options = array(), $functionName  = null ) {
                return new ORMResult( $this, $this->rawSelect( $fields, $conditions, $options, $functionName ) );
        }

        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->newRow( $record );
                }

                return $objects;
        }

        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
                );
        }

        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;
        }

        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();
        }

        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
                );
        }

        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];
        }

        public function has( array $conditions = array() ) {
                return $this->selectRow( array( 'id' ), $conditions ) !== false;
        }

        public function count( array $conditions = array(), array $options = array() ) {
                $res = $this->rawSelectRow(
                        array( 'rowcount' => 'COUNT(*)' ),
                        $this->getPrefixedValues( $conditions ),
                        $options
                );

                return $res->rowcount;
        }

        public function delete( array $conditions, $functionName = null ) {
                return wfGetDB( DB_MASTER )->delete(
                        $this->getName(),
                        $conditions === array() ? '*' : $this->getPrefixedValues( $conditions ),
                        $functionName
                ) !== false; // DatabaseBase::delete does not always return true for success as documented...
        }
        
        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;
        }

        public function getFieldDescriptions() {
                return array();
        }

        public function getReadDb() {
                return $this->readDb;
        }

        public function setReadDb( $db ) {
                $this->readDb = $db;
        }

        public function update( array $values, array $conditions = array() ) {
                $dbw = wfGetDB( DB_MASTER );

                return $dbw->update(
                        $this->getName(),
                        $this->getPrefixedValues( $values ),
                        $this->getPrefixedValues( $conditions ),
                        __METHOD__
                ) !== false; // DatabaseBase::update does not always return true for success as documented...
        }

        public function updateSummaryFields( $summaryFields = null, array $conditions = array() ) {
                $this->setReadDb( DB_MASTER );

                foreach ( $this->select( null, $conditions ) as $item ) {
                        $item->loadSummaryFields( $summaryFields );
                        $item->setSummaryMode( true );
                        $item->save();
                }

                $this->setReadDb( DB_SLAVE );
        }

        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;
        }

        public function getPrefixedFields( array $fields ) {
                foreach ( $fields as &$field ) {
                        $field = $this->getPrefixedField( $field );
                }

                return $fields;
        }

        public function getPrefixedField( $field ) {
                return $this->getFieldPrefix() . $field;
        }

        public function unprefixFieldNames( array $fieldNames ) {
                return array_map( array( $this, 'unprefixFieldName' ), $fieldNames );
        }

        public function unprefixFieldName( $fieldName ) {
                return substr( $fieldName, strlen( $this->getFieldPrefix() ) );
        }

        public static function singleton() {
                $class = get_called_class();

                if ( !array_key_exists( $class, self::$instanceCache ) ) {
                        self::$instanceCache[$class] = new $class;
                }

                return self::$instanceCache[$class];
        }

        public function getFieldsFromDBResult( stdClass $result ) {
                $result = (array)$result;
                return array_combine(
                        $this->unprefixFieldNames( array_keys( $result ) ),
                        array_values( $result )
                );
        }

        public function newFromDBResult( stdClass $result ) {
                return self::newRowFromDBResult( $result );
        }

        public function newRowFromDBResult( stdClass $result ) {
                return $this->newRow( $this->getFieldsFromDBResult( $result ) );
        }

        public function newFromArray( array $data, $loadDefaults = false ) {
                return static::newRow( $data, $loadDefaults );
        }

        public function newRow( array $data, $loadDefaults = false ) {
                $class = $this->getRowClass();
                return new $class( $this, $data, $loadDefaults );
        }

        public function getFieldNames() {
                return array_keys( $this->getFields() );
        }

        public function canHaveField( $name ) {
                return array_key_exists( $name, $this->getFields() );
        }

}