Subversion Repositories PHPX

<?php

require_once 'global.inc';

/* NOTE: Obsolete with autoloader */
//require_once 'Zend/Registry.php';
//require_once 'Zend/Db/Table.php';

/**
 * @property-read array $lastId The last generated ID
 * @property-read array $result The result of the last query
 *
 * @author rvejseli, tlahn
 */
class Database
{
  private $db_host = DB_HOST;
  private $db_user = DB_USER;
  private $db_pass = DB_PASS;
  private $db_name = DB_NAME;

  private $connection = false;
  private $_result = array();

  /**
   * The last inserted ID
   *
   * @var int
   */
  private $_lastId;

  /* Anlegen der Instanz */
  private static $instance = NULL;

  /* Konstruktor private, damit die Klasse nur aus sich selbst heraus instanziiert werden kann. */
  private function __construct()
  {
    $this->connect();
    $this->_resetLastID();
  }

  /**
   * Returns a singleton Database instance
   * @return Database
   */
  public static function getInstance()
  {
    if (self::$instance === NULL)
    {
      self::$instance = new self;
    }

    return self::$instance;
  }

  /* Klonen per 'clone()' von aussen verbieten. */
  private function __clone() {}

  /**
   * Universal getter
   *
   * @param string $name
   */
  public function __get($name)
  {
    switch ($name)
    {
      case 'lastId':
      case 'result':
        return $this->{"_$name"};
    }
  }

  /**
   * Connects to the Database
   */
  public function connect()
  {
    if (!$this->connection)
    {
      $myconn = @mysql_connect($this->db_host, $this->db_user, $this->db_pass);
      if ($myconn)
      {
        $seldb = @mysql_select_db($this->db_name, $myconn);
        if ($seldb)
        {
          $this->connection = true;
          return true;
        }
        else
        {
          return false;
        }
      }
      else
      {
        return false;
      }
    }
    else
    {
      return true;
    }
  }

  /**
   * Resets the last ID to a default value, indicating that no rows where inserted
   */
  private function _resetLastID()
  {
    $this->_lastId = -1;
  }

  public function setDatabase($name)
  {
    if ($this->connection)
    {
      if (@mysql_close())
      {
        $this->connection = false;
        $this->_result = null;
        $this->db_name = $name;
        $this->connect();
      }
    }
  }

  /**
   * Makes an encoding-safe database query
   *
   * @param string $query
   * @param string encoding
   *   The encoding in which the query result should be returned from the DBMS.
   *   The default is 'utf8'.
   * @return resource|null
   *   The query result if successful, <code>null</code> otherwise
   */
  private function _query($query, $encoding = 'utf8')
  {
    $this->_resetLastID();

    if (mysql_query("SET CHARACTER SET $encoding"))
    {
      if (DEBUG > 1)
      {
        echo "<pre>$query</pre>";
      }

      return @mysql_query($query);
    }
    else
    {
      /* DEBUG */
      echo mysql_errno() . ':' . mysql_error();
      exit;
    }

    return null;
  }

  private function _tableExists($table)
  {
    $tablesInDb = $this->_query("SHOW TABLES FROM {$this->db_name} LIKE '{$table}'");
    if ($tablesInDb)
    {
      if (mysql_num_rows($tablesInDb) == 1)
      {
        return true;
      }
      else
      {
        return false;
      }
    }
  }
 
  /**
   * Determines if an array is associative (does not have a '0' key)
   *
   * @param array $a
   * @return boolean
   *   <code>true</code> if <var>$a</var> is associative,
   *   <code>false</code> otherwise
   */
  private function _isAssociativeArray(array $a)
  {
    return !array_key_exists(0, $a);
  }

  /**
   * Escapes an associative array so that its string representation can be used
   * in a query.
   *
   * NOTE: Intentionally does not check whether the array actually is associative!
   *
   * @param array &$array
   *   The array to be escaped
   * @return array
   *   The escaped array
   */
  private function _escapeArray(array &$array)
  {
    foreach ($array as $column => &$value)
    {
      if (is_string($value))
      {
        $value = mysql_real_escape_string($value);
      }

      $value = "`" . mysql_real_escape_string($column) . "`='{$value}'";
    }
   
    return $array;
  }
 
  /**
   * Constructs the WHERE part of a query
   *
   * @param string|array $where Condition
   * @return string
   */
  private function _where($where)
  {
    if (!is_null($where))
    {
      if (is_array($where))
      {
        if (count($where) < 1)
        {
          return '';
        }
       
        if ($this->_isAssociativeArray($where))
        {
          $this->_escapeArray($where);
        }

        $where = '(' . join(') AND (', $where) . ')';
      }

      return ' WHERE ' . $where;
    }
   
    return '';
  }
 
  /**
   * Selects data from one or more tables; the resulting records are stored
   * in the <code>result</code> property.
   *
   * @param string|array[string] $tables Table(s) to select from
   * @param string|array[string] $columns Column(s) to select from (optional)
   * @param string|array $where Condition (optional)
   * @param string $order Sort order (optional)
   * @param string $limit Limit (optional)
   * @return bool
   * @throws <code>Exception</code> if the query fails
   */
  public function select($tables, $columns = null, $where = null, $order = null, $limit = null)
  {
    $this->_result = array();

    if (is_null($columns))
    {
      $columns = array('*');
    }
   
    if (!is_array($columns))
    {
      $columns = array($columns);
    }

    $columns = join(',', $columns);
   
    if (!is_array($tables))
    {
      $tables = array($tables);
    }

    $tables = join(',', $tables);

    $q = "SELECT $columns FROM $tables" . $this->_where($where);

    if (!is_null($order))
    {
      $q .= " ORDER BY $order";
    }

    if (!is_null($limit))
    {
      $q .= " LIMIT $limit";
    }
   
    if (DEBUG > 1)
    {
      echo "<pre>$q</pre>";
    }

    /* DEBUG */
//    debug($q);

    $_result = $this->_query($q);
    if ($_result)
    {
      $this->numResults = mysql_num_rows($_result);
      for ($i = 0, $len = $this->numResults; $i < $len; ++$i)
      {
        $_results = mysql_fetch_array($_result);

        /* DEBUG */
        //        debug($_results);

        $keys = array_keys($_results);
        foreach ($keys as $key)
        {
          if (!is_int($key))
          {
            if (mysql_num_rows($_result) > 0)
            {
              $this->_result[$i][$key] = $_results[$key];
            }
            else if (mysql_num_rows($_result) < 1)
            {
              $this->_result = null;
            }
          }
        }
      }

      return $q;
    }
    else
    {
      throw new Exception(mysql_error() . ". Query: " . $q);
    }
  }

  /**
   * Inserts a record into a table.<p>The AUTO_INCREMENT value of the inserted
   * row, if any (> 0), is stored in the {@link $lastId} property of
   * the <code>Database</code> instance.</p>
   *
   * @param string $table
   *   Table name
   * @param array|string $values
   *   Associative array of column-value pairs, indexed array,
   *   or comma-separated list of values.  If <var>$values</var> is not
   *   an associative array, <var>$cols</var> must be passed if the
   *   values are not in column order (see below).
   * @param array|string $cols
   *   Indexed array, or comma-separated list of column names.
   *   Needs only be passed if <var>$values</var> is not an associative array
   *   and the values are not in column order (default: <code>null</code>);
   *   is ignored otherwise.  <strong>You SHOULD NOT rely on column order.</strong>
   * @return bool
   *   <code>true</code> if successful, <code>false</code> otherwise
   */
  public function insert($table, $values, $cols = null)
  {
    if ($cols != null)
    {
      $cols = ' ('
      . (is_array($cols)
      ? join(',', array_map(create_function('$s', 'return "`$s`";'), $cols))
      : $cols) . ')';
    }
    else
    {
      $cols = '';
    }

    /* DEBUG */
    //          debug($values);

    if ($this->_isAssociativeArray($values))
    {
      $this->_escapeArray($values);

      $cols = '';
      $values = 'SET ' . join(', ', $values);
    }
    else
    {
      foreach ($values as &$value)
      {
        if (is_string($value))
        {
          $value = "'" . mysql_real_escape_string($value) . "'";
        }
      }
       
      $values = ' VALUES (' . join(', ', $values) . ')';
    }

    $insert = "INSERT INTO `{$table}` {$cols} {$values}";

    /* DEBUG */
//    echo "Insert:<br>";
//    debug($insert);

    $ins = $this->_query($insert);
    $this->_lastId = mysql_insert_id();

    if ($ins)
    {
      return true;
    }
    else
    {
      return false;
    }
  }

  /**
   * Deletes records from a table
   *
   * @param string $table
   * @param string|array|null $where  Condition for deletion
   * @return bool
   */
  public function delete($table, $where = null)
  {
    $delete = "DELETE FROM `{$table}`" . $this->_where($where);

    /* DEBUG */
                // debug($delete);
    // $result = true;

    $result = $this->_query($delete);

    return ($result) ? true : false;
  }

  /**
   * Updates one or more records
   *
   * @param string|array $tables
   *   Table name
   * @param array $values
   *   Associative array of column-value pairs
   * @param array|string $where
   *   Only the records matching this condition are updated
   * @return string|bool
   */
  public function update($tables, $updates, $where = null)
  {
    if (!$tables)
    {
      throw new InvalidArgumentException('No table specified');
    }
     
    if (is_array($tables))
    {
      $tables = join(',', $tables);
    }
     
    if (!$updates)
    {
      throw new InvalidArgumentException('No values specified');
    }
     
    $updates = join(',', $this->_escapeArray($updates));
         
    $query = "UPDATE {$tables} SET {$updates}" . $this->_where($where);
   
    /* DEBUG */
//    echo "Update:<br>";
//    debug($query);
   
    $_result = $this->_query($query);

    if (!$_result)
    {
      //debug(mysql_error());
      return false;
    }

    return $query;
  }

  /**
   * Inserts a row into a table or updates an existing one
   *
   * @param string $sTable
   *   Table name
   * @param array $aValues
   *   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 mixed
   */
  public function updateOrInsert($sTable, $aValues, $condition)
  {
    $result = $this->select($sTable, '*', $condition);
    if (!$result)
    {
      exit;
    }

    //    debug($this->result);
    if (count($this->result) > 0)
    {
      $result = $this->update($sTable, $aValues, $condition);
    }
    else
    {
      $result = $this->insert($sTable, $aValues);
    }

    return $result;
  }

  /**
   * @see Database::updateOrInsert()
   */
  public function insertOrUpdate($sTable, $aValues, $condition)
  {
    return $this->updateOrInsert($sTable, $aValues, $condition);
  }

  public function getResult()
  {
    return $this->result;
  }
}
?>