Subversion Repositories PHPX

<?php

namespace PointedEars\PHPX\Db;

use \PointedEars\PHPX\Application;

/**
 * Generic database table model class
 *
 * @author Thomas Lahn
 * @property Database $database
 * @property-read int $lastInsertId
 *   ID of the last inserted row, or the last value from
     a sequence object, depending on the underlying driver.
 */
class Table extends \PointedEars\PHPX\AbstractModel
{
  /**
   * Name of the table
   * @var string
   */
  protected static $_name = '';

  /**
   * Columns definition
   * @var array
         * @see Table::create()
   */
  protected static $_columns;

  /**
   * Indexes definition
   * @var array
         * @see Table::create()
   */
  protected static $_indexes;

  /**
   * Constraints definition
   * @var array
         * @see Table::create()
   */
  protected static $_constraints;

  /**
   * Database of the table
   * @var Database|string
         * @see Table::create()
   */
  protected static $_database;

  /**
   * Name of the primary key column of the table
   * @var string
   */
  protected static $_id = 'id';

  /**
   * Creates a new <code>Table</code> instance.
   *
   * Each of the parameters is optional and can also be given
   * by a protected property where the parameter name is preceded
   * by <code>_</code>.  Parameter values overwrite the default
   * property values.  It is recommended to use default property
   * values of inheriting classes except for small applications
   * and testing purposes.
   *
   * @param Database $database
   *   Database of the table (required in order to use a fitting
   *   query language)
   * @param string $name
   *   Table name
   * @param string $id
   *   Name of the primary key column
   * @throws InvalidArgumentException
   */
  public function __construct ($database = null, $name = '', $id = '')
  {
    if ($database === null)
    {
                /* Call getter to convert to Database if possible */
        if ($this->database === null)
        {
                $this->database = Application::getInstance()->getDefaultDatabase();
        }
    }
    else
    {
      $this->database = $database;
    }

    if ($name !== '')
    {
      $this->name = $name;
    }

    $name = $this->name;
    if (!\is_string($name))
    {
      throw new \InvalidArgumentException(
        'Expected string for table name, saw '
                                . (\is_object($name) ? \get_class($name) : \gettype($name)));
    }

    if ($id !== '')
    {
      $this->id = $id;
    }
  }

  /**
   * @param string $value
   */
  public function setName ($value)
  {
        $class = \get_class($this);
        $class::$_name = (string) $value;
  }

  /**
   * @return string
   */
  public function getName ()
  {
        $class = \get_class($this);
        return $class::$_name;
  }

  /**
   * Returns the database for the table
   * @return Database
   */
  public function getDatabase()
  {
    /* FIXME: What about tables from different databases? */
        $class = \get_class($this);
    if (\is_string($class::$_database))
    {
      /* Call setter to convert to Database */
      $this->setDatabase($class::$_database);
    }

    return $class::$_database;
  }

  /**
   * @param Database|string $value
   * @throws InvalidArgumentException
   */
  public function setDatabase ($value)
  {
        $class = \get_class($this);
        if ($value instanceof Database)
        {
                $class::$_database = $value;
        }
        else if ($value !== null)
        {
                $database = new $value();
                if (!($database instanceof Database))
                {
                        throw new \InvalidArgumentException(
                                'Expected Database instance or string for class name, saw '
                                        . (\is_object($value) ? \get_class($value) : \gettype($value))
                        );
                }

                $class::$_database = $database;
        }
  }

  /**
   * @param string $value
   */
  public function setId ($value)
  {
        $class = \get_class($this);
        $class::$_id = (string) $value;
  }

  /**
   * @return string
   */
  public function getId ()
  {
        $class = \get_class($this);
        return $class::$_id;
  }

  /**
   * Returns the <var>options</var> array for {@link Database::createTable}
   *
   * Should be called and overridden by inheriting classes.
   *
   * @return array
   */
  protected function _createOptions ()
  {
        $options = array();

        foreach (array('indexes', 'constraints') as $option)
        {
                if ($class::${"_$option"})
                {
                        $options[$option] = $class::${"_$option"};
                }
        }

        return $options;
  }

  /**
   * Creates the table for this model
   *
   * @return bool
   */
  public function create ()
  {
        $class = \get_class($this);
                return $this->database->createTable(
                        $class::$_name, $class::$_columns, $this->_createOptions());
  }

  /**
   * Initiates a transaction
   *
   * @return bool
   * @see Database::beginTransaction()
   */
  public function beginTransaction()
  {
    return $this->database->beginTransaction();
  }

  /**
   * Rolls back a transaction
   *
   * @return bool
   * @see Database::rollBack()
   */
  public function rollBack()
  {
    return $this->database->rollBack();
  }

  /**
   * Commits a transaction
   *
   * @return bool
   * @see Database::commit()
   */
  public function commit()
  {
    return $this->database->commit();
  }

  /**
   * Retrieves all rows from the table
   *
   * @return array
   * @see Database::fetchAll()
   */
  public function fetchAll($fetch_style = null, $column_index = null, array $ctor_args = null)
  {
    return $this->database->fetchAll($this->name, $fetch_style, $column_index, $ctor_args);
  }

  /**
   * Selects data from one or more tables
   *
   * @return array
   * @see Database::select()
   */
  public function select($columns = null, $where = null, $order = null, $limit = null)
  {
    return $this->database->select($this->name, $columns, $where, $order, $limit);
  }

  /**
   * Updates records in one or more tables
   *
   * @return bool
   * @see Database::update()
   */
  public function update($data, $condition)
  {
    return $this->database->update($this->name, $data, $condition);
  }

  /**
   * Inserts a record into the table
   *
   * @return bool
   * @see Database::insert()
   */
  public function insert($data, $cols = null)
  {
    return $this->database->insert($this->name, $data, $cols);
  }

  /**
   * Returns the ID of the last inserted row, or the last value from
   * a sequence object, depending on the underlying driver.
   *
   * @return int
   * @see Database::getLastInsertId()
   */
  public function getLastInsertId()
  {
    return $this->database->lastInsertId;
  }

  /**
   * Delete a record from the table
   *
   * @param int $id
   *   ID of the record to delete.  May be <code>null</code>,
   *   in which case <var>$condition</var> must specify
   *   the records to be deleted.
   * @param array[optional] $condition
   *   Conditions that must be met for a record to be deleted.
   *   Ignored if <var>$id</var> is not <code>null</code>.
   * @return bool
   * @throws InvalidArgumentException if both <var>$id</var> and
   *     <var>$condition</var> are <code>null</code>.
   * @see Database::delete()
   */
  public function delete ($id, array $condition = null)
  {
    if ($id !== null)
    {
      $condition = array($this->id => $id);
    }
    else if ($condition === null)
    {
      throw new InvalidArgumentException(
        '$id and $condition cannot both be null');
    }

    return $this->database->delete($this->name, $condition);
  }

 /**
  * Inserts a row into the table or updates an existing one
  *
  * @param array $data
  *   Associative array of column-value pairs to be updated/inserted
  * @param string|array $condition
  *   If there are no records matching this condition, a row
  *   will be inserted; otherwise matching records are updated.
  * @return bool
  *   The return value of Table::update() or Table::insert()
  * @see Table::update()
  * @see Table::insert()
  */
  public function updateOrInsert($data, array $condition = null)
  {
    if ($this->select($this->id, $condition))
    {
      return $this->update($data, $condition);
    }

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

  /**
   * Finds a record by ID
   *
   * @param mixed $id
   * @return array
   */
  public function find ($id)
  {
    /* DEBUG */
    if (defined('DEBUG') && DEBUG > 0)
    {
      debug($id);
    }

    $result = $this->select(null, array($this->id => $id));

    if ($result)
    {
      $result = $result[0];
    }

    return $result;
  }

  /**
   * Returns the date of last modification of this table.
   *
   * @return int|null
   *   Timestamp of last modification, or <code>null</code> if
   *   unavailable.
   */
  public function getLastModified ()
  {
    return $this->database->getLastModified($this->name);
  }
}