Koowa_Database
[ class tree: Koowa_Database ] [ index: Koowa_Database ] [ all elements ]

Source for file abstract.php

Documentation is available at abstract.php

  1. <?php
  2. /**
  3.  * @version        $Id: abstract.php 4628 2012-05-06 19:56:43Z johanjanssens $
  4.  * @package     Koowa_Database
  5.  * @subpackage  Adapter
  6.  * @copyright    Copyright (C) 2007 - 2012 Johan Janssens. All rights reserved.
  7.  * @license        GNU GPLv3 <http://www.gnu.org/licenses/gpl.html>
  8.  * @link         http://www.nooku.org
  9.  */
  10.  
  11. /**
  12.  * Abstract Database Adapter
  13.  *
  14.  * @author        Johan Janssens <johan@nooku.org>
  15.  * @package     Koowa_Database
  16.  * @subpackage  Adapter
  17.  * @uses         KPatternCommandChain
  18.  */
  19. abstract class KDatabaseAdapterAbstract extends KObject implements KDatabaseAdapterInterface
  20. {
  21.     /**
  22.      * Active state of the connection
  23.      *
  24.      * @var boolean 
  25.      */
  26.     protected $_connected = null;
  27.  
  28.     /**
  29.      * The database connection resource
  30.      *
  31.      * @var mixed 
  32.      */
  33.     protected $_connection = null;
  34.  
  35.     /**
  36.      * Last auto-generated insert_id
  37.      *
  38.      * @var integer 
  39.      */
  40.     protected $_insert_id;
  41.  
  42.     /**
  43.      * The affected row count
  44.      *
  45.      * @var int 
  46.      */
  47.     protected $_affected_rows;
  48.  
  49.     /**
  50.      * Schema cache
  51.      *
  52.      * @var array 
  53.      */
  54.     protected $_table_schema = null;
  55.  
  56.     /**
  57.      * The table prefix
  58.      *
  59.      * @var string 
  60.      */
  61.     protected $_table_prefix = '';
  62.  
  63.     /**
  64.      * The table needle
  65.      *
  66.      * @var string 
  67.      */
  68.     protected $_table_needle = '';
  69.  
  70.     /**
  71.      * Quote for named objects
  72.      *
  73.      * @var string 
  74.      */
  75.     protected $_name_quote = '`';
  76.  
  77.     /**
  78.      * The connection options
  79.      *
  80.      * @var KConfig 
  81.      */
  82.     protected $_options = null;
  83.  
  84.     /**
  85.      * Constructor.
  86.      *
  87.      * @param     object     An optional KConfig object with configuration options.
  88.      *  Recognized key values include 'command_chain', 'charset', 'table_prefix',
  89.      *  (this list is not meant to be comprehensive).
  90.      */
  91.     public function __constructKConfig $config null )
  92.     {
  93.         //If no config is passed create it
  94.         if(!isset($config)) $config new KConfig();
  95.  
  96.         // Initialize the options
  97.         parent::__construct($config);
  98.  
  99.         // Set the connection
  100.         $this->setConnection($config->connection);
  101.  
  102.         // Set the default charset. http://dev.mysql.com/doc/refman/5.1/en/charset-connection.html
  103.         if (!empty($config->charset)) {
  104.             //$this->setCharset($config->charset);
  105.         }
  106.  
  107.         // Set the table prefix
  108.         $this->_table_prefix = $config->table_prefix;
  109.  
  110.         // Set the table prefix
  111.         $this->_table_needle = $config->table_needle;
  112.  
  113.         // Set the connection options
  114.         $this->_options = $config->options;
  115.  
  116.          //Set the mixer in the config
  117.         $config->mixer $this;
  118.         
  119.         // Mixin the command interface
  120.         $this->mixin(new KMixinCommand($config));
  121.     }
  122.  
  123.     /**
  124.      * Destructor
  125.      *
  126.      * Free any resources that are open.
  127.      */
  128.     public function __destruct()
  129.     {
  130.         $this->disconnect();
  131.     }
  132.  
  133.       /**
  134.      * Initializes the options for the object
  135.      *
  136.      * Called from {@link __construct()} as a first step of object instantiation.
  137.      *
  138.      * @param     object     An optional KConfig object with configuration options.
  139.      * @return  void 
  140.      */
  141.     protected function _initialize(KConfig $config)
  142.     {
  143.         $config->append(array(
  144.             'options'            => array(),
  145.             'charset'            => 'UTF-8',
  146.                 'table_prefix'      => 'jos_',
  147.             'table_needle'        => '#__',
  148.             'command_chain'     => $this->getService('koowa:command.chain'),
  149.             'dispatch_events'   => true,
  150.             'event_dispatcher'  => $this->getService('koowa:event.dispatcher'),
  151.             'enable_callbacks'     => false,
  152.             'connection'        => null,
  153.         ));
  154.  
  155.         parent::_initialize($config);
  156.     }
  157.  
  158.     /**
  159.      * Get a database query object
  160.      *
  161.      * @return KDatabaseQuery 
  162.      */
  163.     public function getQuery(KConfig $config null)
  164.     {
  165.         if(!isset($config)) {
  166.             $config new KConfig(array('adapter' => $this));
  167.         }
  168.  
  169.         return new KDatabaseQuery($config);
  170.     }
  171.  
  172.     /**
  173.      * Reconnect to the db
  174.      *
  175.      * @return  KDatabaseAdapterAbstract 
  176.      */
  177.     public function reconnect()
  178.     {
  179.         $this->disconnect();
  180.         $this->connect();
  181.  
  182.         return $this;
  183.     }
  184.  
  185.     /**
  186.      * Disconnect from db
  187.      *
  188.      * @return  KDatabaseAdapterAbstract 
  189.      */
  190.     public function disconnect()
  191.     {
  192.         $this->_connection = null;
  193.         $this->_connected  = false;
  194.  
  195.         return $this;
  196.     }
  197.  
  198.     /**
  199.      * Get the database name
  200.      *
  201.      * @return string    The database name
  202.      */
  203.     abstract function getDatabase();
  204.  
  205.     /**
  206.      * Set the database name
  207.      *
  208.      * @param     string     The database name
  209.      * @return  KDatabaseAdapterAbstract 
  210.      */
  211.     abstract function setDatabase($database);
  212.  
  213.     /**
  214.      * Get the connection
  215.      *
  216.      * Provides access to the underlying database connection. Useful for when
  217.      * you need to call a proprietary method such as postgresql's lo_* methods
  218.      *
  219.      * @return resource 
  220.      */
  221.     public function getConnection()
  222.     {
  223.         return $this->_connection;
  224.     }
  225.  
  226.     /**
  227.      * Set the connection
  228.      *
  229.      * @param     resource     The connection resource
  230.      * @return  KDatabaseAdapterAbstract 
  231.      */
  232.     public function setConnection($resource)
  233.     {
  234.         $this->_connection = $resource;
  235.         return $this;
  236.     }
  237.  
  238.     /**
  239.      * Get the insert id of the last insert operation
  240.      *
  241.      * @return mixed The id of the last inserted row(s)
  242.      */
  243.      public function getInsertId()
  244.     {
  245.         return $this->_insert_id;
  246.     }
  247.  
  248.     /**
  249.      * Preforms a select query
  250.      *
  251.      * Use for SELECT and anything that returns rows.
  252.      *
  253.      * If <var>key</var> is not empty then the returned array is indexed by the value
  254.      * of the database key.  Returns <var>null</var> if the query fails.
  255.      *
  256.      * @param    string|object       A full SQL query to run. Data inside the query should be properly escaped.
  257.      * @param   integer            The fetch mode. Controls how the result will be returned to the caller. This
  258.      *                              value must be one of the KDatabase::FETCH_* constants.
  259.      * @param     string             The column name of the index to use
  260.      * @return  mixed             The return value of this function on success depends on the fetch type.
  261.      *                              In all cases, FALSE is returned on failure.
  262.      */
  263.     public function select($query$mode KDatabase::FETCH_ARRAY_LIST$key '')
  264.     {
  265.         $context $this->getCommandContext();
  266.         $context->query         $query;
  267.         $context->operation KDatabase::OPERATION_SELECT;
  268.         $context->mode        $mode;
  269.  
  270.         // Excute the insert operation
  271.         if($this->getCommandChain()->run('before.select'$context!== false)
  272.         {
  273.             if($result $this->execute$context->queryKDatabase::RESULT_USE))
  274.             {
  275.                 switch($context->mode)
  276.                 {
  277.                     case KDatabase::FETCH_ARRAY       :
  278.                         $context->result $this->_fetchArray($result);
  279.                         break;
  280.  
  281.                     case KDatabase::FETCH_ARRAY_LIST  :
  282.                         $context->result $this->_fetchArrayList($result$key);
  283.                         break;
  284.  
  285.                     case KDatabase::FETCH_FIELD       :
  286.                         $context->result $this->_fetchField($result$key);
  287.                         break;
  288.  
  289.                     case KDatabase::FETCH_FIELD_LIST  :
  290.                         $context->result $this->_fetchFieldList($result$key);
  291.                         break;
  292.  
  293.                     case KDatabase::FETCH_OBJECT      :
  294.                         $context->result $this->_fetchObject($result);
  295.                         break;
  296.  
  297.                     case KDatabase::FETCH_OBJECT_LIST :
  298.                         $context->result $this->_fetchObjectList($result$key);
  299.                         break;
  300.  
  301.                     default $result->free();
  302.                 }
  303.             }
  304.  
  305.             $this->getCommandChain()->run('after.select'$context);
  306.         }
  307.  
  308.         return KConfig::unbox($context->result);
  309.     }
  310.  
  311.     /**
  312.      * Preforms a show query
  313.      *
  314.      * @param    string|object       A full SQL query to run. Data inside the query should be properly escaped.
  315.      * @param   integer            The fetch mode. Controls how the result will be returned to the caller. This
  316.      *                              value must be one of the KDatabase::FETCH_* constants.
  317.      * @return  mixed             The return value of this function on success depends on the fetch type.
  318.      *                              In all cases, FALSE is returned on failure.
  319.      */
  320.     public function show($query$mode KDatabase::FETCH_ARRAY_LIST)
  321.     {
  322.         $context $this->getCommandContext();
  323.         $context->query         $query;
  324.         $context->operation KDatabase::OPERATION_SHOW;
  325.         $context->mode        $mode;
  326.  
  327.         // Excute the insert operation
  328.         if($this->getCommandChain()->run('before.show'$context!== false)
  329.         {
  330.             if($result $this->execute$context->queryKDatabase::RESULT_USE))
  331.             {
  332.                 switch($context->mode)
  333.                 {
  334.                     case KDatabase::FETCH_ARRAY       :
  335.                         $context->result $this->_fetchArray($result);
  336.                         break;
  337.  
  338.                     case KDatabase::FETCH_ARRAY_LIST  :
  339.                         $context->result $this->_fetchArrayList($result);
  340.                         break;
  341.  
  342.                     case KDatabase::FETCH_FIELD       :
  343.                         $context->result $this->_fetchField($result);
  344.                         break;
  345.  
  346.                     case KDatabase::FETCH_FIELD_LIST  :
  347.                         $context->result $this->_fetchFieldList($result);
  348.                         break;
  349.  
  350.                     case KDatabase::FETCH_OBJECT      :
  351.                         $context->result $this->_fetchObject($result);
  352.                         break;
  353.  
  354.                     case KDatabase::FETCH_OBJECT_LIST :
  355.                         $context->result $this->_fetchObjectList($result);
  356.                         break;
  357.  
  358.                     default $result->free();
  359.                 }
  360.             }
  361.  
  362.             $this->getCommandChain()->run('after.show'$context);
  363.         }
  364.  
  365.         return KConfig::unbox($context->result);
  366.     }
  367.  
  368.     /**
  369.      * Inserts a row of data into a table.
  370.      *
  371.      * Automatically quotes the data values
  372.      *
  373.      * @param string      The table to insert data into.
  374.      * @param array     An associative array where the key is the colum name and
  375.      *                      the value is the value to insert for that column.
  376.      * @return bool|integer If the insert query was executed returns the number of rows updated, or 0 if
  377.      *                           no rows where updated, or -1 if an error occurred. Otherwise FALSE.
  378.      */
  379.     public function insert($tablearray $data)
  380.     {
  381.         $context $this->getCommandContext();
  382.         $context->table     $table;
  383.         $context->data         $data;
  384.         $context->operation    KDatabase::OPERATION_INSERT;
  385.  
  386.         //Excute the insert operation
  387.         if($this->getCommandChain()->run('before.insert'$context!== false)
  388.         {
  389.             //Check if we have valid data to insert, if not return false
  390.             if(count($context->data))
  391.             {
  392.                 foreach($context->data as $key => $val)
  393.                 {
  394.                     $vals[$this->quoteValue($val);
  395.                     $keys['`'.$key.'`';
  396.                 }
  397.  
  398.                 $context->query 'INSERT INTO '.$this->quoteName($this->getTableNeedle().$context->table )
  399.                      . '('.implode(', '$keys).') VALUES ('.implode(', '$vals).')';
  400.  
  401.                 //Execute the query
  402.                 $context->result $this->execute($context->query);
  403.  
  404.                 $context->affected $this->_affected_rows;
  405.  
  406.                 $this->getCommandChain()->run('after.insert'$context);
  407.             }
  408.             else $context->affected false;
  409.         }
  410.  
  411.         return $context->affected;
  412.     }
  413.  
  414.     /**
  415.      * Updates a table with specified data based on a WHERE clause
  416.      *
  417.      * Automatically quotes the data values
  418.      *
  419.      * @param string     The table to update
  420.      * @param array      An associative array where the key is the column name and
  421.      *                       the value is the value to use ofr that column.
  422.      * @param mixed     A sql string or KDatabaseQuery object to limit which rows are updated.
  423.      * @return integer  If the update query was executed returns the number of rows updated, or 0 if
  424.      *                      no rows where updated, or -1 if an error occurred. Otherwise FALSE.
  425.      */
  426.     public function update($tablearray $data$where null)
  427.     {
  428.         $context $this->getCommandContext();
  429.         $context->table     $table;
  430.         $context->data      $data;
  431.         $context->where       $where;
  432.         $context->operation    KDatabase::OPERATION_UPDATE;
  433.  
  434.         //Excute the update operation
  435.         if($this->getCommandChain()->run('before.update'$context!==  false)
  436.         {
  437.             if(count($context->data))
  438.             {
  439.                 foreach($context->data as $key => $val{
  440.                     $vals['`'.$key.'` = '.$this->quoteValue($val);
  441.                 }
  442.  
  443.                 //Create query statement
  444.                 $context->query 'UPDATE '.$this->quoteName($this->getTableNeedle().$context->table)
  445.                       .' SET '.implode(', '$vals)
  446.                       .' '.$context->where
  447.                 ;
  448.  
  449.                 //Execute the query
  450.                 $context->result $this->execute($context->query);
  451.  
  452.                 $context->affected $this->_affected_rows;
  453.                 $this->getCommandChain()->run('after.update'$context);
  454.             }
  455.             else $context->affected false;
  456.         }
  457.  
  458.         return $context->affected;
  459.     }
  460.  
  461.     /**
  462.      * Deletes rows from the table based on a WHERE clause.
  463.      *
  464.      * @param string     The table to update
  465.      * @param mixed      A query string or a KDatabaseQuery object to limit which rows are updated.
  466.      * @return integer     Number of rows affected, or -1 if an error occured.
  467.      */
  468.     public function delete($table$where)
  469.     {
  470.         $context $this->getCommandContext();
  471.         $context->table     $table;
  472.         $context->data      null;
  473.         $context->where       $where;
  474.         $context->operation    KDatabase::OPERATION_DELETE;
  475.  
  476.         //Excute the delete operation
  477.         if($this->getCommandChain()->run('before.delete'$context!== false)
  478.         {
  479.             //Create query statement
  480.             $context->query 'DELETE FROM '.$this->quoteName($this->getTableNeedle().$context->table)
  481.                   .' '.$context->where
  482.             ;
  483.  
  484.             //Execute the query
  485.             $context->result $this->execute($context->query);
  486.  
  487.             $context->affected $this->_affected_rows;
  488.             $this->getCommandChain()->run('after.delete'$context);
  489.         }
  490.  
  491.         return $context->affected;
  492.     }
  493.  
  494.     /**
  495.      * Use and other queries that don't return rows
  496.      *
  497.      * @param  string     The query to run. Data inside the query should be properly escaped.
  498.      * @param  integer     The result maode, either the constant KDatabase::RESULT_USE or KDatabase::RESULT_STORE
  499.      *                      depending on the desired behavior. By default, KDatabase::RESULT_STORE is used. If you
  500.      *                      use KDatabase::RESULT_USE all subsequent calls will return error Commands out of sync
  501.      *                      unless you free the result first.
  502.      * @throws KDatabaseException
  503.      * @return boolean     For SELECT, SHOW, DESCRIBE or EXPLAIN will return a result object.
  504.      *                      For other successful queries  return TRUE.
  505.      */
  506.     public function execute($sql$mode KDatabase::RESULT_STORE )
  507.     {
  508.         //Replace the database table prefix
  509.         $sql $this->replaceTableNeedle$sql );
  510.  
  511.         $result $this->_connection->query($sql$mode);
  512.  
  513.         if($result === false{
  514.             throw new KDatabaseException($this->_connection->error.' of the following query : '.$sql$this->_connection->errno);
  515.         }
  516.  
  517.         $this->_affected_rows $this->_connection->affected_rows;
  518.         $this->_insert_id     $this->_connection->insert_id;
  519.  
  520.         return $result;
  521.     }
  522.  
  523.     /**
  524.      * Set the table prefix
  525.      *
  526.      * @param string The table prefix
  527.      * @return KDatabaseAdapterAbstract 
  528.      * @see KDatabaseAdapterAbstract::replaceTableNeedle
  529.      */
  530.     public function setTablePrefix($prefix)
  531.     {
  532.         $this->_table_prefix $prefix;
  533.         return $this;
  534.     }
  535.  
  536.      /**
  537.      * Get the table prefix
  538.      *
  539.      * @return string The table prefix
  540.      * @see KDatabaseAdapterAbstract::replaceTableNeedle
  541.      */
  542.     public function getTablePrefix()
  543.     {
  544.         return $this->_table_prefix;
  545.     }
  546.  
  547.     /**
  548.      * Get the table needle
  549.      *
  550.      * @return string The table needle
  551.      * @see KDatabaseAdapterAbstract::replaceTableNeedle
  552.      */
  553.     public function getTableNeedle()
  554.     {
  555.         return $this->_table_needle;
  556.     }
  557.  
  558.     /**
  559.      * This function replaces the table needles in a query string with the actual table prefix.
  560.      *
  561.      * @param  string     The SQL query string
  562.      * @return string    The SQL query string
  563.      */
  564.     public function replaceTableNeedle$sql$replace null)
  565.     {
  566.         $needle  $this->getTableNeedle();
  567.         $replace = isset($replace$replace $this->getTablePrefix();
  568.         $sql     trim$sql );
  569.  
  570.         $pattern "($needle(?=[a-z0-9]))";
  571.         $sql preg_replace($pattern$replace$sql);
  572.  
  573.         return $sql;
  574.     }
  575.  
  576.     /**
  577.      * Safely quotes a value for an SQL statement.
  578.      *
  579.      * If an array is passed as the value, the array values are quoted
  580.      * and then returned as a comma-separated string; this is useful
  581.      * for generating IN() lists.
  582.      *
  583.      * @param   mixed The value to quote.
  584.      * @return string An SQL-safe quoted value (or a string of separated-
  585.      *                 and-quoted values).
  586.      */
  587.     public function quoteValue($value)
  588.     {
  589.         if (is_array($value))
  590.         {
  591.             //Quote array values, not keys, then combine with commas.
  592.             foreach ($value as $k => $v{
  593.                 $value[$k$this->quoteValue($v);
  594.             }
  595.  
  596.             $value implode(', '$value);
  597.         }
  598.         else
  599.         {
  600.             if(is_string($value&& !is_null($value)) {
  601.                 $value $this->_quoteValue($value);
  602.             }
  603.         }
  604.  
  605.         return $value;
  606.     }
  607.  
  608.     /**
  609.      * Quotes a single identifier name (table, table alias, table column,
  610.      * index, sequence).  Ignores empty values.
  611.      *
  612.      * This function requires all SQL statements, operators and functions to be
  613.      * uppercased.
  614.      *
  615.      * @param string|arrayThe identifier name to quote.  If an array, quotes
  616.      *                       each element in the array as an identifier name.
  617.      * @return string|arrayThe quoted identifier name (or array of names).
  618.      *
  619.      * @see _quoteName()
  620.      */
  621.     public function quoteName($spec)
  622.     {
  623.         if (is_array($spec))
  624.         {
  625.             foreach ($spec as $key => $val{
  626.                 $spec[$key$this->quoteName($val);
  627.             }
  628.  
  629.             return $spec;
  630.         }
  631.  
  632.         // String spaces around the identifier
  633.         $spec trim($spec);
  634.  
  635.         // Quote all the lower case parts
  636.         $spec preg_replace_callback('#(?:\b|\#)+(?<!`)([a-z0-9\.\#\-_]+)(?!`)\b#'array($this'_quoteName'$spec);
  637.  
  638.         return $spec;
  639.     }
  640.  
  641.    /**
  642.      * Fetch the first field of the first row
  643.      *
  644.      * @param   mysqli_result   The result object. A result set identifier returned by the select() function
  645.      * @param   integer         The index to use
  646.      * @return The value returned in the query or null if the query failed.
  647.      */
  648.     abstract protected function _fetchField($result$key 0);
  649.  
  650.     /**
  651. /**
  652.      * Fetch an array of single field results
  653.      *
  654.      * @param   mysqli_result   The result object. A result set identifier returned by the select() function
  655.      * @param   integer         The index to use
  656.      * @return  array           A sequential array of returned rows.
  657.      */
  658.     abstract protected function _fetchFieldList($result$key 0);
  659.  
  660.     /**
  661. /**
  662.      * Fetch the first row of a result set as an associative array
  663.      *
  664.      * @param   mysqli_result   The result object. A result set identifier returned by the select() function
  665.      * @return array 
  666.      */
  667.     abstract protected function _fetchArray($sql);
  668.  
  669.     /**
  670. /**
  671.      * Fetch all result rows of a result set as an array of associative arrays
  672.      *
  673.      * If <var>key</var> is not empty then the returned array is indexed by the value
  674.      * of the database key.  Returns <var>null</var> if the query fails.
  675.      *
  676.      * @param   mysqli_result   The result object. A result set identifier returned by the select() function
  677.      * @param   string          The column name of the index to use
  678.      * @return  array   If key is empty as sequential list of returned records.
  679.      */
  680.     abstract protected function _fetchArrayList($result$key '');
  681.  
  682.     /**
  683. /**
  684.      * Fetch the first row of a result set as an object
  685.      *
  686.      * @param   mysqli_result  The result object. A result set identifier returned by the select() function
  687.      * @param object 
  688.      */
  689.     abstract protected function _fetchObject($result);
  690.  
  691.     /**
  692. /**
  693.      * Fetch all rows of a result set as an array of objects
  694.      *
  695.      * If <var>key</var> is not empty then the returned array is indexed by the value
  696.      * of the database key.  Returns <var>null</var> if the query fails.
  697.      *
  698.      * @param   mysqli_result  The result object. A result set identifier returned by the select() function
  699.      * @param   string         The column name of the index to use
  700.      * @return  array   If <var>key</var> is empty as sequential array of returned rows.
  701.      */
  702.     abstract protected function _fetchObjectList($result$key='' );
  703.  
  704.     /**
  705. /**
  706.      * Parse the raw table schema information
  707.      *
  708.      * @param   object  The raw table schema information
  709.      * @return KDatabaseSchemaTable 
  710.      */
  711.     abstract protected function _parseTableInfo($info);
  712.  
  713.     /**
  714. /**
  715.      * Parse the raw column schema information
  716.      *
  717.      * @param   object  The raw column schema information
  718.      * @return KDatabaseSchemaColumn 
  719.      */
  720.     abstract protected function _parseColumnInfo($info);
  721.  
  722.     /**
  723. /**
  724.      * Given a raw column specification, parse into datatype, size, and decimal scope.
  725.      *
  726.      * @param string The column specification; for example,
  727.      *  "VARCHAR(255)" or "NUMERIC(10,2)".
  728.      *
  729.      * @return array A sequential array of the column type, size, and scope.
  730.      */
  731.     abstract protected function _parseColumnType($spec);
  732.  
  733.     /**
  734. /**
  735.      * Safely quotes a value for an SQL statement.
  736.      *
  737.      * @param   mixed   The value to quote
  738.      * @return string An SQL-safe quoted value
  739.      */
  740.     abstract protected function _quoteValue($value);
  741.  
  742.     /**
  743. /**
  744.      * Quotes an identifier name (table, index, etc). Ignores empty values.
  745.      *
  746.      * If the name contains a dot, this method will separately quote the
  747.      * parts before and after the dot.
  748.      *
  749.      * @param string    The identifier name to quote.
  750.      * @return string   The quoted identifier name.
  751.      * @see quoteName()
  752.      */
  753.     protected function _quoteName($name)
  754.     {
  755.         $result =  '';
  756.  
  757.         if(is_array($name)) {
  758.             $name $name[0];
  759.         }
  760.  
  761.         $name   trim($name);
  762.  
  763.         //Special cases
  764.         if ($name == '*' || is_numeric($name)) {
  765.             return $name;
  766.         }
  767.  
  768.         if ($pos strrpos($name'.'))
  769.         {
  770.             $table  $this->_quoteName(substr($name0$pos));
  771.             $column $this->_quoteName(substr($name$pos 1));
  772.  
  773.             $result =  "$table.$column";
  774.         }
  775.         else $result $this->_name_quote$name.$this->_name_quote;
  776.  
  777.         return $result;
  778.     }
  779. }

Documentation generated on Fri, 24 Jan 2014 03:00:18 +0100 by phpDocumentor 1.4.3