Source for file QAL.class.php

Documentation is available at QAL.class.php

  1. /**
  2.  * Класс QAL.
  3.  *
  4.  * @package energine
  5.  * @subpackage core
  6.  * @author 1m.dm
  7.  * @copyright ColoCall 2006
  8.  * @version $Id: fsource_energine_core_frameworkQAL.class.php.html,v 1.1 2007/09/17 14:32:34 pavka Exp $
  9.  */
  10.  
  11. require_once 'core/framework/DBA.class.php';
  12.  
  13. /**
  14.  * Query Abstraction Layer.
  15.  *
  16.  * @package energine
  17.  * @subpackage core
  18.  * @final
  19.  */
  20. final class QAL extends DBA {
  21.  
  22.     /**
  23.      * Режимы модифицирующих операций
  24.      */
  25.     const INSERT = 'INSERT';
  26.     const UPDATE = 'UPDATE';
  27.     const DELETE = 'DELETE';
  28.  
  29.     /**
  30.      * Направления сортировки
  31.      */
  32.     const ASC = 'ASC';
  33.     const DESC = 'DESC';
  34.  
  35.     /**
  36.      * Пустая строка
  37.      */
  38.     const EMPTY_STRING = null;
  39.  
  40.     /**
  41.      * Ошибки
  42.      */
  43.     const ERR_BAD_QUERY_FORMAT = 'Bad query format.';
  44.  
  45.     /**
  46.      * Конструктор класса.
  47.      *
  48.      * @access public
  49.      * @param string $dsn 
  50.      * @param string $username 
  51.      * @param string $password 
  52.      * @param object $driverOptions 
  53.      * @return void 
  54.      */
  55.     public function __construct($dsn$username$passwordarray $driverOptions{
  56.         parent::__construct($dsn$username$password$driverOptions);
  57.     }
  58.  
  59.     /**
  60.      * Выполняет простой SELECT-запрос к БД и возвращает результат выборки.
  61.      *
  62.      * Имена полей $fields задаётся одним из трёх способов:
  63.      *     1. массив имён полей;
  64.      *     2. имя одного поля;
  65.      *     3. true, для выборки всех полей таблицы.
  66.      *
  67.      * Условие выборки $condition задаётся массивом вида array(имя_поля => значение),
  68.      * или строкой WHERE-условия типа 'field1 = 4 AND field2 = 8'.
  69.      *
  70.      * Порядок сортировки результа задаётся массивом вида array(имя_поля => порядок_сортировки),
  71.      * или строкой предложения ORDER BY типа 'field1 DESC, field2 ASC'.
  72.      *
  73.      * Лимит выборки задаётся массивом вида array(смещение, кол-во_строк),
  74.      * или строкой предложения LIMIT типа '32'.
  75.      *
  76.      * Возвращает массив результата выборки или true, если результат пустой.
  77.      *
  78.      * @access public
  79.      * @param string $tableName имя таблицы
  80.      * @param mixed $fields массив имен полей ИЛИ имя одного поля ИЛИ true для выборки всех полей таблицы
  81.      * @param mixed $condition условие выборки
  82.      * @param mixed $order порядок сортировки результата
  83.      * @param mixed $limit лимит выборки
  84.      * @return array 
  85.      * @see DBA::selectRequest()
  86.      */
  87.     public function select($tableName$fields true$condition null$order null$limit null{
  88.         //$tableName = strtolower($tableName);
  89.  
  90.         if (is_array($fields&& !empty($fields)) {
  91.             $fields = array_map('strtolower'$fields);
  92.             $fields = implode(', '$fields);
  93.         }
  94.         elseif (is_string($fields)) {
  95.             $fields = strtolower($fields);
  96.         }
  97.         elseif ($fields === true{
  98.             $fields '*';
  99.         }
  100.         else {
  101.             throw new SystemException(self::ERR_BAD_QUERY_FORMATSystemException::ERR_DBarray($tableName$fields$condition$order$limit));
  102.         }
  103.  
  104.         $sqlQuery "SELECT $fields FROM `$tableName`";
  105.  
  106.         if (isset($condition)) {
  107.             $sqlQuery .= $this->buildWhereCondition($condition);
  108.         }
  109.  
  110.         if (isset($order)) {
  111.             $sqlQuery .= $this->buildOrderCondition($order);
  112.         }
  113.  
  114.         if (isset($limit)) {
  115.             if (is_array($limit)) {
  116.                 $sqlQuery .= ' LIMIT '.implode(', '$limit);
  117.             }
  118.             else {
  119.                 $sqlQuery .= " LIMIT $limit";
  120.             }
  121.         }
  122.  
  123.         return $this->selectRequest($sqlQuery);
  124.     }
  125.  
  126.     /**
  127.      * Выполняет простую модифицирующую (INSERT, UPDATE, DELETE) операцию в БД.
  128.      *
  129.      * Режим операции задаётся одной из трёх констант:
  130.      *     1. QAL::INSERT - вставка;
  131.      *     2. QAL::UPDATE - обновление;
  132.      *     3. QAL::DELETE - удаление.
  133.      *
  134.      * Данные для операций типа QAL::INSERT и QAL::UPDATE задаются массивом
  135.      * вида array(имя_поля => значение).
  136.      *
  137.      * Условие операции задаётся массивом вида array(имя_поля => значение),
  138.      * или строкой WHERE-условия типа 'field1 = 4 AND field2 = 8'.
  139.      *
  140.      * В режиме QAL::INSERT метод возвращает последний сгенерированный ID для
  141.      * поля типа AUTO_INCREMENT, или true если такого поля в таблице нет.
  142.      *
  143.      * В режимах QAL::UPDATE и QAL::DELETE при успешном выполнении запроса
  144.      * всегда возвращается true.
  145.      *
  146.      * При ошибке выполнения любого типа операций возвращается false.
  147.      *
  148.      * @access public
  149.      * @param int $mode режим операции
  150.      * @param string $tableName имя таблицы
  151.      * @param array $data данные для операции
  152.      * @param mixed $condition условие операции
  153.      * @return array 
  154.      * @see DBA::modifyRequest()
  155.      */
  156.     public function modify($mode$tableNamearray $data null$condition null{
  157.         if (empty($mode|| empty($tableName)) {
  158.             throw new SystemException(self::ERR_BAD_QUERY_FORMATSystemException::ERR_DB);
  159.         }
  160.  
  161.         $sqlQuery '';
  162.  
  163.         switch ($mode{
  164.             case self::INSERT:
  165.                 if (!empty($data)) {
  166.                     $fieldNames array();
  167.                     $fieldValues array();
  168.                     foreach ($data as $fieldName => $fieldValue{
  169.                         $fieldNames[$fieldName;
  170.                         if ($fieldValue === self::EMPTY_STRING{
  171.                             $fieldValue $this->quote('');
  172.                         }
  173.                         elseif ($fieldValue == ''{
  174.                             $fieldValue 'NULL';
  175.                         }
  176.                         else {
  177.                             $fieldValue $this->quote($fieldValue);
  178.                         }
  179.                         $fieldValues[$fieldValue;
  180.                     }
  181.                     $sqlQuery "INSERT INTO `$tableName` (".implode(', '$fieldNames).') VALUES ('.implode(', '$fieldValues).')';
  182.                 }
  183.                 else {
  184.                     throw new SystemException(self::ERR_BAD_QUERY_FORMATSystemException::ERR_DB);
  185.                 }
  186.                 break;
  187.             case self::UPDATE:
  188.                 if (!empty($data)) {
  189.                     $fields array();
  190.                     foreach ($data as $fieldName => $fieldValue{
  191.                         if ($fieldValue === self::EMPTY_STRING{
  192.                             $fieldValue $this->quote('');
  193.                         }
  194.                         elseif ($fieldValue === ''{
  195.                             $fieldValue 'NULL';
  196.                         }
  197.                         else {
  198.                             $fieldValue $this->quote($fieldValue);
  199.                         }
  200.                         $fields["$fieldName = $fieldValue";
  201.                     }
  202.                     $sqlQuery "UPDATE `$tableName` SET ".implode(', '$fields);
  203.                 }
  204.                 else {
  205.                     throw new SystemException(self::ERR_BAD_QUERY_FORMATSystemException::ERR_DB);
  206.                 }
  207.                 break;
  208.             case self::DELETE:
  209.                 $sqlQuery "DELETE FROM `$tableName`";
  210.                 break;
  211.             default:
  212.                 throw new SystemException(self::ERR_BAD_QUERY_FORMATSystemException::ERR_DB);
  213.         }
  214.  
  215.         if (isset($condition&& $mode != self::INSERT{
  216.             $sqlQuery .= $this->buildWhereCondition($condition);
  217.         }
  218.  
  219.         return $this->modifyRequest($sqlQuery);
  220.     }
  221.  
  222.     /**
  223.      * Строит WHERE-условие для SQL-запроса.
  224.      *
  225.      * @access public
  226.      * @param mixed $condition 
  227.      * @return string 
  228.      * @see QAL::selectRequest()
  229.      */
  230.     public function buildWhereCondition($condition{
  231.         $whereCond ' WHERE ';
  232.  
  233.         if (is_array($condition)) {
  234.             $cond array();
  235.             foreach ($condition as $fieldName => $value{
  236.                 //$fieldName = strtolower($fieldName);
  237.                 if (is_null($value)) {
  238.                     $cond["$fieldName IS NULL";
  239.                 }
  240.                 elseif (empty($fieldName)) {
  241.                     $cond[$value;
  242.                 }
  243.                 elseif (is_array($value)) {
  244.                     $cond[$fieldName.' IN ('.implode(',',$value).')';
  245.                 }
  246.                 else {
  247.                     $cond["$fieldName = ".$this->quote($value);
  248.                 }
  249.             }
  250.             $whereCond .= implode(' AND '$cond);
  251.         }
  252.         else {
  253.             $whereCond .= $condition;
  254.         }
  255.  
  256.         return $whereCond;
  257.     }
  258.  
  259.     /**
  260.      * Строит предложение ORDER BY для SQL-запроса.
  261.      *
  262.      * @access public
  263.      * @param mixed $order 
  264.      * @return string 
  265.      * @see QAL::selectRequest()
  266.      */
  267.     public function buildOrderCondition($clause{
  268.         $orderClause ' ORDER BY ';
  269.  
  270.         if (is_array($clause)) {
  271.             $cls array();
  272.             foreach ($clause as $fieldName => $direction{
  273.                 //$fieldName = strtolower($fieldName);
  274.                 $cls["$fieldName ".constant("self::$direction");
  275.             }
  276.             $orderClause .= implode(', '$cls);
  277.         }
  278.         else {
  279.             $orderClause .= $clause;
  280.         }
  281.  
  282.         return $orderClause;
  283.     }
  284.  
  285.     /**
  286.      * Строит предложение LIMIT для SQL-запроса.
  287.      *
  288.      * @access public
  289.      * @param mixed $limit 
  290.      * @return string 
  291.      * @see QAL::selectRequest()
  292.      */
  293.     public function buildLimitStatement($clause{
  294.         $limitClause '';
  295.         if (is_array($clause)) {
  296.             $limitClause " LIMIT {$clause[0]}";
  297.             if (isset($clause[1])) {
  298.                 $limitClause .= ", {$clause[1]}";
  299.             }
  300.         }
  301.  
  302.         return $limitClause;
  303.     }
  304. }

Documentation generated on Mon, 17 Sep 2007 13:30:59 +0300 by phpDocumentor 1.4.0a2