Source for file oracle.php

Documentation is available at oracle.php

  1. <?php
  2. /**
  3.  * @package     Joomla.Platform
  4.  * @subpackage  Database
  5.  *
  6.  * @copyright   Copyright (C) 2005 - 2013 Open Source Matters, Inc. All rights reserved.
  7.  * @license     GNU General Public License version 2 or later; see LICENSE
  8.  */
  9.  
  10. defined('JPATH_PLATFORM') or die;
  11.  
  12. /**
  13.  * Oracle Query Building Class.
  14.  *
  15.  * @package     Joomla.Platform
  16.  * @subpackage  Database
  17.  * @since       12.1
  18.  */
  19. class JDatabaseQueryOracle extends JDatabaseQueryPdo implements JDatabaseQueryPreparable, JDatabaseQueryLimitable
  20. {
  21.     /**
  22.      * @var    integer  The offset for the result set.
  23.      * @since  12.1
  24.      */
  25.     protected $offset;
  26.  
  27.     /**
  28.      * @var    integer  The limit for the result set.
  29.      * @since  12.1
  30.      */
  31.     protected $limit;
  32.  
  33.     /**
  34.      * @var    array  Bounded object array
  35.      * @since  12.1
  36.      */
  37.     protected $bounded = array();
  38.  
  39.     /**
  40.      * Method to add a variable to an internal array that will be bound to a prepared SQL statement before query execution. Also
  41.      * removes a variable that has been bounded from the internal bounded array when the passed in value is null.
  42.      *
  43.      * @param   string|integer $key            The key that will be used in your SQL query to reference the value. Usually of
  44.      *                                           the form ':key', but can also be an integer.
  45.      * @param   mixed           &$value         The value that will be bound. The value is passed by reference to support output
  46.      *                                           parameters such as those possible with stored procedures.
  47.      * @param   integer         $dataType       Constant corresponding to a SQL datatype.
  48.      * @param   integer         $length         The length of the variable. Usually required for OUTPUT parameters.
  49.      * @param   array           $driverOptions  Optional driver options to be used.
  50.      *
  51.      * @return  JDatabaseQueryOracle 
  52.      *
  53.      * @since   12.1
  54.      */
  55.     public function bind($key = null, &$value = null, $dataType = PDO::PARAM_STR, $length = 0, $driverOptions = array())
  56.     {
  57.         // Case 1: Empty Key (reset $bounded array)
  58.         if (empty($key))
  59.         {
  60.             $this->bounded = array();
  61.  
  62.             return $this;
  63.         }
  64.  
  65.         // Case 2: Key Provided, null value (unset key from $bounded array)
  66.         if (is_null($value))
  67.         {
  68.             if (isset($this->bounded[$key]))
  69.             {
  70.                 unset($this->bounded[$key]);
  71.             }
  72.  
  73.             return $this;
  74.         }
  75.  
  76.         $obj = new stdClass;
  77.  
  78.         $obj->value = &$value;
  79.         $obj->dataType = $dataType;
  80.         $obj->length = $length;
  81.         $obj->driverOptions = $driverOptions;
  82.  
  83.         // Case 3: Simply add the Key/Value into the bounded array
  84.         $this->bounded[$key] = $obj;
  85.  
  86.         return $this;
  87.     }
  88.  
  89.     /**
  90.      * Retrieves the bound parameters array when key is null and returns it by reference. If a key is provided then that item is
  91.      * returned.
  92.      *
  93.      * @param   mixed  $key  The bounded variable key to retrieve.
  94.      *
  95.      * @return  mixed 
  96.      *
  97.      * @since   12.1
  98.      */
  99.     public function &getBounded($key = null)
  100.     {
  101.         if (empty($key))
  102.         {
  103.             return $this->bounded;
  104.         }
  105.         else
  106.         {
  107.             if (isset($this->bounded[$key]))
  108.             {
  109.                 return $this->bounded[$key];
  110.             }
  111.         }
  112.     }
  113.  
  114.     /**
  115.      * Clear data from the query or a specific clause of the query.
  116.      *
  117.      * @param   string  $clause  Optionally, the name of the clause to clear, or nothing to clear the whole query.
  118.      *
  119.      * @return  JDatabaseQueryOracle  Returns this object to allow chaining.
  120.      *
  121.      * @since   12.1
  122.      */
  123.     public function clear($clause = null)
  124.     {
  125.         switch ($clause)
  126.         {
  127.             case null:
  128.                 $this->bounded = array();
  129.                 break;
  130.         }
  131.  
  132.         parent::clear($clause);
  133.  
  134.         return $this;
  135.     }
  136.  
  137.     /**
  138.      * Method to modify a query already in string format with the needed
  139.      * additions to make the query limited to a particular number of
  140.      * results, or start at a particular offset. This method is used
  141.      * automatically by the __toString() method if it detects that the
  142.      * query implements the JDatabaseQueryLimitable interface.
  143.      *
  144.      * @param   string   $query   The query in string format
  145.      * @param   integer  $limit   The limit for the result set
  146.      * @param   integer  $offset  The offset for the result set
  147.      *
  148.      * @return  string 
  149.      *
  150.      * @since   12.1
  151.      */
  152.     public function processLimit($query, $limit, $offset = 0)
  153.     {
  154.         // Check if we need to mangle the query.
  155.         if ($limit || $offset)
  156.         {
  157.             $query = "SELECT joomla2.*
  158.                       FROM (
  159.                           SELECT joomla1.*, ROWNUM AS joomla_db_rownum
  160.                           FROM (
  161.                               " . $query . "
  162.                           ) joomla1
  163.                       ) joomla2";
  164.  
  165.             // Check if the limit value is greater than zero.
  166.             if ($limit > 0)
  167.             {
  168.                 $query .= ' WHERE joomla2.joomla_db_rownum BETWEEN ' . ($offset + 1) . ' AND ' . ($offset + $limit);
  169.             }
  170.             else
  171.             {
  172.                 // Check if there is an offset and then use this.
  173.                 if ($offset)
  174.                 {
  175.                     $query .= ' WHERE joomla2.joomla_db_rownum > ' . ($offset + 1);
  176.                 }
  177.             }
  178.         }
  179.  
  180.         return $query;
  181.     }
  182.  
  183.     /**
  184.      * Sets the offset and limit for the result set, if the database driver supports it.
  185.      *
  186.      * Usage:
  187.      * $query->setLimit(100, 0); (retrieve 100 rows, starting at first record)
  188.      * $query->setLimit(50, 50); (retrieve 50 rows, starting at 50th record)
  189.      *
  190.      * @param   integer  $limit   The limit for the result set
  191.      * @param   integer  $offset  The offset for the result set
  192.      *
  193.      * @return  JDatabaseQueryOracle  Returns this object to allow chaining.
  194.      *
  195.      * @since   12.1
  196.      */
  197.     public function setLimit($limit = 0, $offset = 0)
  198.     {
  199.         $this->limit = (int) $limit;
  200.         $this->offset = (int) $offset;
  201.  
  202.         return $this;
  203.     }
  204. }

Documentation generated on Tue, 19 Nov 2013 15:09:49 +0100 by phpDocumentor 1.4.3