X-Git-Url: https://git.mxchange.org/?a=blobdiff_plain;f=classes%2FManaged_DataObject.php;h=b324984b7f8e7512d4c8b77606654ca6b10b8ae2;hb=47c83f4c496f9cb9b09cc25123b862f1402aacab;hp=35d52c51208f6949c31672d3d18dbc175d06949b;hpb=b483a0549f115b2d5f2cfb3d447e6cc5c4f469f3;p=quix0rs-gnu-social.git diff --git a/classes/Managed_DataObject.php b/classes/Managed_DataObject.php index 35d52c5120..b324984b7f 100644 --- a/classes/Managed_DataObject.php +++ b/classes/Managed_DataObject.php @@ -28,7 +28,105 @@ abstract class Managed_DataObject extends Memcached_DataObject /** * The One True Thingy that must be defined and declared. */ - public static abstract function schemaDef(); + public static function schemaDef() + { + throw new MethodNotImplementedException(__METHOD__); + } + + /** + * Get an instance by key + * + * @param string $k Key to use to lookup (usually 'id' for this class) + * @param mixed $v Value to lookup + * + * @return get_called_class() object if found, or null for no hits + * + */ + static function getKV($k,$v=NULL) + { + return parent::getClassKV(get_called_class(), $k, $v); + } + + /** + * Get an instance by compound key + * + * This is a utility method to get a single instance with a given set of + * key-value pairs. Usually used for the primary key for a compound key; thus + * the name. + * + * @param array $kv array of key-value mappings + * + * @return get_called_class() object if found, or null for no hits + * + */ + static function pkeyGet(array $kv) + { + return parent::pkeyGetClass(get_called_class(), $kv); + } + + /** + * Get multiple items from the database by key + * + * @param string $keyCol name of column for key + * @param array $keyVals key values to fetch + * @param boolean $skipNulls return only non-null results? + * + * @return array Array of objects, in order + */ + static function multiGet($keyCol, array $keyVals, $skipNulls=true) + { + return parent::multiGetClass(get_called_class(), $keyCol, $keyVals, $skipNulls); + } + + /** + * Get multiple items from the database by key + * + * @param string $keyCol name of column for key + * @param array $keyVals key values to fetch + * @param array $otherCols Other columns to hold fixed + * + * @return array Array mapping $keyVals to objects, or null if not found + */ + static function pivotGet($keyCol, array $keyVals, array $otherCols=array()) + { + return parent::pivotGetClass(get_called_class(), $keyCol, $keyVals, $otherCols); + } + + /** + * Get a multi-instance object + * + * This is a utility method to get multiple instances with a given set of + * values for a specific column. + * + * @param string $keyCol key column name + * @param array $keyVals array of key values + * + * @return get_called_class() object with multiple instances if found, + * Exception is thrown when no entries are found. + * + */ + static function listFind($keyCol, array $keyVals) + { + return parent::listFindClass(get_called_class(), $keyCol, $keyVals); + } + + /** + * Get a multi-instance object separated into an array + * + * This is a utility method to get multiple instances with a given set of + * values for a specific key column. Usually used for the primary key when + * multiple values are desired. Result is an array. + * + * @param string $keyCol key column name + * @param array $keyVals array of key values + * + * @return array with an get_called_class() object for each $keyVals entry + * + */ + static function listGet($keyCol, array $keyVals) + { + return parent::listGetClass(get_called_class(), $keyCol, $keyVals); + } /** * get/set an associative array of table columns @@ -36,11 +134,9 @@ abstract class Managed_DataObject extends Memcached_DataObject * @access public * @return array (associative) */ - function table() + public function table() { - // Hack for PHP 5.2 not supporting late static binding - //$table = static::schemaDef(); - $table = call_user_func(array(get_class($this), 'schemaDef')); + $table = static::schemaDef(); return array_map(array($this, 'columnBitmap'), $table['fields']); } @@ -68,7 +164,7 @@ abstract class Managed_DataObject extends Memcached_DataObject function sequenceKey() { - $table = self::schemaDef(); + $table = static::schemaDef(); foreach ($table['fields'] as $name => $column) { if ($column['type'] == 'serial') { // We have a serial/autoincrement column. @@ -92,8 +188,8 @@ abstract class Managed_DataObject extends Memcached_DataObject function keyTypes() { + $table = static::schemaDef(); $keys = array(); - $table = self::schemaDef(); if (!empty($table['unique keys'])) { foreach ($table['unique keys'] as $idx => $fields) { @@ -152,4 +248,157 @@ abstract class Managed_DataObject extends Memcached_DataObject return $style; } -} \ No newline at end of file + + function links() + { + $links = array(); + + $table = static::schemaDef(); + + foreach ($table['foreign keys'] as $keyname => $keydef) { + if (count($keydef) == 2 && is_string($keydef[0]) && is_array($keydef[1]) && count($keydef[1]) == 1) { + if (isset($keydef[1][0])) { + $links[$keydef[1][0]] = $keydef[0].':'.$keydef[1][1]; + } + } + } + return $links; + } + + /** + * Return a list of all primary/unique keys / vals that will be used for + * caching. This will understand compound unique keys, which + * Memcached_DataObject doesn't have enough info to handle properly. + * + * @return array of strings + */ + function _allCacheKeys() + { + $table = static::schemaDef(); + $ckeys = array(); + + if (!empty($table['unique keys'])) { + $keyNames = $table['unique keys']; + foreach ($keyNames as $idx => $fields) { + $val = array(); + foreach ($fields as $name) { + $val[$name] = self::valueString($this->$name); + } + $ckeys[] = self::multicacheKey($this->tableName(), $val); + } + } + + if (!empty($table['primary key'])) { + $fields = $table['primary key']; + $val = array(); + foreach ($fields as $name) { + $val[$name] = self::valueString($this->$name); + } + $ckeys[] = self::multicacheKey($this->tableName(), $val); + } + return $ckeys; + } + + public function escapedTableName() + { + return common_database_tablename($this->tableName()); + } + + /** + * Returns an ID, checked that it is set and reasonably valid + * + * If this dataobject uses a special id field (not 'id'), just + * implement your ID getting method in the child class. + * + * @return int ID of dataobject + * @throws Exception (when ID is not available or not set yet) + */ + public function getID() + { + // FIXME: Make these exceptions more specific (their own classes) + if (!isset($this->id)) { + throw new Exception('No ID set.'); + } elseif (empty($this->id)) { + throw new Exception('Empty ID for object! (not inserted yet?).'); + } + + // FIXME: How about forcing to return an int? Or will that overflow eventually? + return $this->id; + } + + // 'update' won't write key columns, so we have to do it ourselves. + // This also automatically calls "update" _before_ it sets the keys. + // FIXME: This only works with single-column primary keys so far! Beware! + /** + * @param DB_DataObject &$orig Must be "instanceof" $this + * @param string $pid Primary ID column (no escaping is done on column name!) + */ + public function updateWithKeys(&$orig, $pid='id') + { + if (!$orig instanceof $this) { + throw new ServerException('Tried updating a DataObject with a different class than itself.'); + } + + // do it in a transaction + $this->query('BEGIN'); + + $parts = array(); + foreach ($this->keys() as $k) { + if (strcmp($this->$k, $orig->$k) != 0) { + $parts[] = $k . ' = ' . $this->_quote($this->$k); + } + } + if (count($parts) == 0) { + // No changes to keys, it's safe to run ->update(...) + if ($this->update($orig) === false) { + common_log_db_error($this, 'UPDATE', __FILE__); + // rollback as something bad occurred + $this->query('ROLLBACK'); + throw new ServerException("Could not UPDATE non-keys for {$this->__table}"); + } + $orig->decache(); + $this->encache(); + + // commit our db transaction since we won't reach the COMMIT below + $this->query('COMMIT'); + // @FIXME return true only if something changed (otherwise 0) + return true; + } + + $qry = sprintf('UPDATE %1$s SET %2$s WHERE %3$s = %4$s', + common_database_tablename($this->tableName()), + implode(', ', $parts), + $pid, + $this->_quote($this->$pid)); + + $result = $this->query($qry); + if ($result === false) { + common_log_db_error($this, 'UPDATE', __FILE__); + // rollback as something bad occurred + $this->query('ROLLBACK'); + throw new ServerException("Could not UPDATE key fields for {$this->__table}"); + } + + // Update non-keys too, if the previous endeavour worked. + // The ->update call uses "$this" values for keys, that's why we can't do this until + // the keys are updated (because they might differ from $orig and update the wrong entries). + if ($this->update($orig) === false) { + common_log_db_error($this, 'UPDATE', __FILE__); + // rollback as something bad occurred + $this->query('ROLLBACK'); + throw new ServerException("Could not UPDATE non-keys for {$this->__table}"); + } + $orig->decache(); + $this->encache(); + + // commit our db transaction + $this->query('COMMIT'); + // @FIXME return true only if something changed (otherwise 0) + return $result; + } + + static public function beforeSchemaUpdate() + { + // NOOP + } +}