API tools faq
paste
Advertisement
Guest User

Untitled

a guest
Jul 6th, 2018
111
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
PHP 65.03 KB | None | 0 0
raw download clone embed print report
  1. <?php
  2. /**
  3.  * CodeIgniter
  4.  *
  5.  * An open source application development framework for PHP
  6.  *
  7.  * This content is released under the MIT License (MIT)
  8.  *
  9.  * Copyright (c) 2014 - 2018, British Columbia Institute of Technology
  10.  *
  11.  * Permission is hereby granted, free of charge, to any person obtaining a copy
  12.  * of this software and associated documentation files (the "Software"), to deal
  13.  * in the Software without restriction, including without limitation the rights
  14.  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
  15.  * copies of the Software, and to permit persons to whom the Software is
  16.  * furnished to do so, subject to the following conditions:
  17.  *
  18.  * The above copyright notice and this permission notice shall be included in
  19.  * all copies or substantial portions of the Software.
  20.  *
  21.  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  22.  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  23.  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
  24.  * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  25.  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  26.  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
  27.  * THE SOFTWARE.
  28.  *
  29.  * @package CodeIgniter
  30.  * @author  EllisLab Dev Team
  31.  * @copyright   Copyright (c) 2008 - 2014, EllisLab, Inc. (https://ellislab.com/)
  32.  * @copyright   Copyright (c) 2014 - 2018, British Columbia Institute of Technology (http://bcit.ca/)
  33.  * @license http://opensource.org/licenses/MIT  MIT License
  34.  * @link    https://codeigniter.com
  35.  * @since   Version 1.0.0
  36.  * @filesource
  37.  */
  38. defined('BASEPATH') OR exit('No direct script access allowed');
  39.  
  40. /**
  41.  * Query Builder Class
  42.  *
  43.  * This is the platform-independent base Query Builder implementation class.
  44.  *
  45.  * @package     CodeIgniter
  46.  * @subpackage  Drivers
  47.  * @category    Database
  48.  * @author      EllisLab Dev Team
  49.  * @link        https://codeigniter.com/user_guide/database/
  50.  */
  51.  
  52. abstract class CI_DB_query_builder extends CI_DB_driver {
  53.  
  54.     /**
  55.      * Return DELETE SQL flag
  56.      *
  57.      * @var bool
  58.      */
  59.     protected $return_delete_sql        = FALSE;
  60.  
  61.     /**
  62.      * Reset DELETE data flag
  63.      *
  64.      * @var bool
  65.      */
  66.     protected $reset_delete_data        = FALSE;
  67.  
  68.     /**
  69.      * QB SELECT data
  70.      *
  71.      * @var array
  72.      */
  73.     protected $qb_select            = array();
  74.  
  75.     /**
  76.      * QB DISTINCT flag
  77.      *
  78.      * @var bool
  79.      */
  80.     protected $qb_distinct          = FALSE;
  81.  
  82.     /**
  83.      * QB FROM data
  84.      *
  85.      * @var array
  86.      */
  87.     protected $qb_from          = array();
  88.  
  89.     /**
  90.      * QB JOIN data
  91.      *
  92.      * @var array
  93.      */
  94.     protected $qb_join          = array();
  95.  
  96.     /**
  97.      * QB WHERE data
  98.      *
  99.      * @var array
  100.      */
  101.     protected $qb_where         = array();
  102.  
  103.     /**
  104.      * QB GROUP BY data
  105.      *
  106.      * @var array
  107.      */
  108.     protected $qb_groupby           = array();
  109.  
  110.     /**
  111.      * QB HAVING data
  112.      *
  113.      * @var array
  114.      */
  115.     protected $qb_having            = array();
  116.  
  117.     /**
  118.      * QB keys
  119.      *
  120.      * @var array
  121.      */
  122.     protected $qb_keys          = array();
  123.  
  124.     /**
  125.      * QB LIMIT data
  126.      *
  127.      * @var int
  128.      */
  129.     protected $qb_limit         = FALSE;
  130.  
  131.     /**
  132.      * QB OFFSET data
  133.      *
  134.      * @var int
  135.      */
  136.     protected $qb_offset            = FALSE;
  137.  
  138.     /**
  139.      * QB ORDER BY data
  140.      *
  141.      * @var array
  142.      */
  143.     protected $qb_orderby           = array();
  144.  
  145.     /**
  146.      * QB data sets
  147.      *
  148.      * @var array
  149.      */
  150.     protected $qb_set           = array();
  151.  
  152.     /**
  153.      * QB data set for update_batch()
  154.      *
  155.      * @var array
  156.      */
  157.     protected $qb_set_ub            = array();
  158.  
  159.     /**
  160.      * QB aliased tables list
  161.      *
  162.      * @var array
  163.      */
  164.     protected $qb_aliased_tables        = array();
  165.  
  166.     /**
  167.      * QB WHERE group started flag
  168.      *
  169.      * @var bool
  170.      */
  171.     protected $qb_where_group_started   = FALSE;
  172.  
  173.     /**
  174.      * QB WHERE group count
  175.      *
  176.      * @var int
  177.      */
  178.     protected $qb_where_group_count     = 0;
  179.  
  180.     // Query Builder Caching variables
  181.  
  182.     /**
  183.      * QB Caching flag
  184.      *
  185.      * @var bool
  186.      */
  187.     protected $qb_caching               = FALSE;
  188.  
  189.     /**
  190.      * QB Cache exists list
  191.      *
  192.      * @var array
  193.      */
  194.     protected $qb_cache_exists          = array();
  195.  
  196.     /**
  197.      * QB Cache SELECT data
  198.      *
  199.      * @var array
  200.      */
  201.     protected $qb_cache_select          = array();
  202.  
  203.     /**
  204.      * QB Cache FROM data
  205.      *
  206.      * @var array
  207.      */
  208.     protected $qb_cache_from            = array();
  209.  
  210.     /**
  211.      * QB Cache JOIN data
  212.      *
  213.      * @var array
  214.      */
  215.     protected $qb_cache_join            = array();
  216.  
  217.     /**
  218.      * QB Cache aliased tables list
  219.      *
  220.      * @var array
  221.      */
  222.     protected $qb_cache_aliased_tables          = array();
  223.  
  224.     /**
  225.      * QB Cache WHERE data
  226.      *
  227.      * @var array
  228.      */
  229.     protected $qb_cache_where           = array();
  230.  
  231.     /**
  232.      * QB Cache GROUP BY data
  233.      *
  234.      * @var array
  235.      */
  236.     protected $qb_cache_groupby         = array();
  237.  
  238.     /**
  239.      * QB Cache HAVING data
  240.      *
  241.      * @var array
  242.      */
  243.     protected $qb_cache_having          = array();
  244.  
  245.     /**
  246.      * QB Cache ORDER BY data
  247.      *
  248.      * @var array
  249.      */
  250.     protected $qb_cache_orderby         = array();
  251.  
  252.     /**
  253.      * QB Cache data sets
  254.      *
  255.      * @var array
  256.      */
  257.     protected $qb_cache_set             = array();
  258.  
  259.     /**
  260.      * QB No Escape data
  261.      *
  262.      * @var array
  263.      */
  264.     protected $qb_no_escape             = array();
  265.  
  266.     /**
  267.      * QB Cache No Escape data
  268.      *
  269.      * @var array
  270.      */
  271.     protected $qb_cache_no_escape           = array();
  272.  
  273.     // --------------------------------------------------------------------
  274.  
  275.     /**
  276.      * Select
  277.      *
  278.      * Generates the SELECT portion of the query
  279.      *
  280.      * @param   string
  281.      * @param   mixed
  282.      * @return  CI_DB_query_builder
  283.      */
  284.     public function select($select = '*', $escape = NULL)
  285.     {
  286.         if (is_string($select))
  287.         {
  288.             $select = explode(',', $select);
  289.         }
  290.  
  291.         // If the escape value was not set, we will base it on the global setting
  292.         is_bool($escape) OR $escape = $this->_protect_identifiers;
  293.  
  294.         foreach ($select as $val)
  295.         {
  296.             $val = trim($val);
  297.  
  298.             if ($val !== '')
  299.             {
  300.                 $this->qb_select[] = $val;
  301.                 $this->qb_no_escape[] = $escape;
  302.  
  303.                 if ($this->qb_caching === TRUE)
  304.                 {
  305.                     $this->qb_cache_select[] = $val;
  306.                     $this->qb_cache_exists[] = 'select';
  307.                     $this->qb_cache_no_escape[] = $escape;
  308.                 }
  309.             }
  310.         }
  311.  
  312.         return $this;
  313.     }
  314.  
  315.     // --------------------------------------------------------------------
  316.  
  317.     /**
  318.      * Select Max
  319.      *
  320.      * Generates a SELECT MAX(field) portion of a query
  321.      *
  322.      * @param   string  the field
  323.      * @param   string  an alias
  324.      * @return  CI_DB_query_builder
  325.      */
  326.     public function select_max($select = '', $alias = '')
  327.     {
  328.         return $this->_max_min_avg_sum($select, $alias, 'MAX');
  329.     }
  330.  
  331.     // --------------------------------------------------------------------
  332.  
  333.     /**
  334.      * Select Min
  335.      *
  336.      * Generates a SELECT MIN(field) portion of a query
  337.      *
  338.      * @param   string  the field
  339.      * @param   string  an alias
  340.      * @return  CI_DB_query_builder
  341.      */
  342.     public function select_min($select = '', $alias = '')
  343.     {
  344.         return $this->_max_min_avg_sum($select, $alias, 'MIN');
  345.     }
  346.  
  347.     // --------------------------------------------------------------------
  348.  
  349.     /**
  350.      * Select Average
  351.      *
  352.      * Generates a SELECT AVG(field) portion of a query
  353.      *
  354.      * @param   string  the field
  355.      * @param   string  an alias
  356.      * @return  CI_DB_query_builder
  357.      */
  358.     public function select_avg($select = '', $alias = '')
  359.     {
  360.         return $this->_max_min_avg_sum($select, $alias, 'AVG');
  361.     }
  362.  
  363.     // --------------------------------------------------------------------
  364.  
  365.     /**
  366.      * Select Sum
  367.      *
  368.      * Generates a SELECT SUM(field) portion of a query
  369.      *
  370.      * @param   string  the field
  371.      * @param   string  an alias
  372.      * @return  CI_DB_query_builder
  373.      */
  374.     public function select_sum($select = '', $alias = '')
  375.     {
  376.         return $this->_max_min_avg_sum($select, $alias, 'SUM');
  377.     }
  378.  
  379.     // --------------------------------------------------------------------
  380.  
  381.     /**
  382.      * SELECT [MAX|MIN|AVG|SUM]()
  383.      *
  384.      * @used-by select_max()
  385.      * @used-by select_min()
  386.      * @used-by select_avg()
  387.      * @used-by select_sum()
  388.      *
  389.      * @param   string  $select Field name
  390.      * @param   string  $alias
  391.      * @param   string  $type
  392.      * @return  CI_DB_query_builder
  393.      */
  394.     protected function _max_min_avg_sum($select = '', $alias = '', $type = 'MAX')
  395.     {
  396.         if ( ! is_string($select) OR $select === '')
  397.         {
  398.             $this->display_error('db_invalid_query');
  399.         }
  400.  
  401.         $type = strtoupper($type);
  402.  
  403.         if ( ! in_array($type, array('MAX', 'MIN', 'AVG', 'SUM')))
  404.         {
  405.             show_error('Invalid function type: '.$type);
  406.         }
  407.  
  408.         if ($alias === '')
  409.         {
  410.             $alias = $this->_create_alias_from_table(trim($select));
  411.         }
  412.  
  413.         $sql = $type.'('.$this->protect_identifiers(trim($select)).') AS '.$this->escape_identifiers(trim($alias));
  414.  
  415.         $this->qb_select[] = $sql;
  416.         $this->qb_no_escape[] = NULL;
  417.  
  418.         if ($this->qb_caching === TRUE)
  419.         {
  420.             $this->qb_cache_select[] = $sql;
  421.             $this->qb_cache_exists[] = 'select';
  422.         }
  423.  
  424.         return $this;
  425.     }
  426.  
  427.     // --------------------------------------------------------------------
  428.  
  429.     /**
  430.      * Determines the alias name based on the table
  431.      *
  432.      * @param   string  $item
  433.      * @return  string
  434.      */
  435.     protected function _create_alias_from_table($item)
  436.     {
  437.         if (strpos($item, '.') !== FALSE)
  438.         {
  439.             $item = explode('.', $item);
  440.             return end($item);
  441.         }
  442.  
  443.         return $item;
  444.     }
  445.  
  446.     // --------------------------------------------------------------------
  447.  
  448.     /**
  449.      * DISTINCT
  450.      *
  451.      * Sets a flag which tells the query string compiler to add DISTINCT
  452.      *
  453.      * @param   bool    $val
  454.      * @return  CI_DB_query_builder
  455.      */
  456.     public function distinct($val = TRUE)
  457.     {
  458.         $this->qb_distinct = is_bool($val) ? $val : TRUE;
  459.         return $this;
  460.     }
  461.  
  462.     // --------------------------------------------------------------------
  463.  
  464.     /**
  465.      * From
  466.      *
  467.      * Generates the FROM portion of the query
  468.      *
  469.      * @param   mixed   $from   can be a string or array
  470.      * @return  CI_DB_query_builder
  471.      */
  472.     public function from($from)
  473.     {
  474.         foreach ((array) $from as $val)
  475.         {
  476.             if (strpos($val, ',') !== FALSE)
  477.             {
  478.                 foreach (explode(',', $val) as $v)
  479.                 {
  480.                     $v = trim($v);
  481.                     $this->_track_aliases($v);
  482.  
  483.                     $this->qb_from[] = $v = $this->protect_identifiers($v, TRUE, NULL, FALSE);
  484.  
  485.                     if ($this->qb_caching === TRUE)
  486.                     {
  487.                         $this->qb_cache_from[] = $v;
  488.                         $this->qb_cache_exists[] = 'from';
  489.                     }
  490.                 }
  491.             }
  492.             else
  493.             {
  494.                 $val = trim($val);
  495.  
  496.                 // Extract any aliases that might exist. We use this information
  497.                 // in the protect_identifiers to know whether to add a table prefix
  498.                 $this->_track_aliases($val);
  499.  
  500.                 $this->qb_from[] = $val = $this->protect_identifiers($val, TRUE, NULL, FALSE);
  501.  
  502.                 if ($this->qb_caching === TRUE)
  503.                 {
  504.                     $this->qb_cache_from[] = $val;
  505.                     $this->qb_cache_exists[] = 'from';
  506.                 }
  507.             }
  508.         }
  509.  
  510.         return $this;
  511.     }
  512.  
  513.     // --------------------------------------------------------------------
  514.  
  515.     /**
  516.      * JOIN
  517.      *
  518.      * Generates the JOIN portion of the query
  519.      *
  520.      * @param   string
  521.      * @param   string  the join condition
  522.      * @param   string  the type of join
  523.      * @param   string  whether not to try to escape identifiers
  524.      * @return  CI_DB_query_builder
  525.      */
  526.     public function join($table, $cond, $type = '', $escape = NULL)
  527.     {
  528.         if ($type !== '')
  529.         {
  530.             $type = strtoupper(trim($type));
  531.  
  532.             if ( ! in_array($type, array('LEFT', 'RIGHT', 'OUTER', 'INNER', 'LEFT OUTER', 'RIGHT OUTER'), TRUE))
  533.             {
  534.                 $type = '';
  535.             }
  536.             else
  537.             {
  538.                 $type .= ' ';
  539.             }
  540.         }
  541.  
  542.         // Extract any aliases that might exist. We use this information
  543.         // in the protect_identifiers to know whether to add a table prefix
  544.         $this->_track_aliases($table);
  545.  
  546.         is_bool($escape) OR $escape = $this->_protect_identifiers;
  547.  
  548.         if ( ! $this->_has_operator($cond))
  549.         {
  550.             $cond = ' USING ('.($escape ? $this->escape_identifiers($cond) : $cond).')';
  551.         }
  552.         elseif ($escape === FALSE)
  553.         {
  554.             $cond = ' ON '.$cond;
  555.         }
  556.         else
  557.         {
  558.             // Split multiple conditions
  559.             if (preg_match_all('/\sAND\s|\sOR\s/i', $cond, $joints, PREG_OFFSET_CAPTURE))
  560.             {
  561.                 $conditions = array();
  562.                 $joints = $joints[0];
  563.                 array_unshift($joints, array('', 0));
  564.  
  565.                 for ($i = count($joints) - 1, $pos = strlen($cond); $i >= 0; $i--)
  566.                 {
  567.                     $joints[$i][1] += strlen($joints[$i][0]); // offset
  568.                     $conditions[$i] = substr($cond, $joints[$i][1], $pos - $joints[$i][1]);
  569.                     $pos = $joints[$i][1] - strlen($joints[$i][0]);
  570.                     $joints[$i] = $joints[$i][0];
  571.                 }
  572.             }
  573.             else
  574.             {
  575.                 $conditions = array($cond);
  576.                 $joints = array('');
  577.             }
  578.  
  579.             $cond = ' ON ';
  580.             for ($i = 0, $c = count($conditions); $i < $c; $i++)
  581.             {
  582.                 $operator = $this->_get_operator($conditions[$i]);
  583.                 $cond .= $joints[$i];
  584.                 $cond .= preg_match("/(\(*)?([\[\]\w\.'-]+)".preg_quote($operator)."(.*)/i", $conditions[$i], $match)
  585.                     ? $match[1].$this->protect_identifiers($match[2]).$operator.$this->protect_identifiers($match[3])
  586.                     : $conditions[$i];
  587.             }
  588.         }
  589.  
  590.         // Do we want to escape the table name?
  591.         if ($escape === TRUE)
  592.         {
  593.             $table = $this->protect_identifiers($table, TRUE, NULL, FALSE);
  594.         }
  595.  
  596.         // Assemble the JOIN statement
  597.         $this->qb_join[] = $join = $type.'JOIN '.$table.$cond;
  598.  
  599.         if ($this->qb_caching === TRUE)
  600.         {
  601.             $this->qb_cache_join[] = $join;
  602.             $this->qb_cache_exists[] = 'join';
  603.         }
  604.  
  605.         return $this;
  606.     }
  607.  
  608.     // --------------------------------------------------------------------
  609.  
  610.     /**
  611.      * WHERE
  612.      *
  613.      * Generates the WHERE portion of the query.
  614.      * Separates multiple calls with 'AND'.
  615.      *
  616.      * @param   mixed
  617.      * @param   mixed
  618.      * @param   bool
  619.      * @return  CI_DB_query_builder
  620.      */
  621.     public function where($key, $value = NULL, $escape = NULL)
  622.     {
  623.         return $this->_wh('qb_where', $key, $value, 'AND ', $escape);
  624.     }
  625.  
  626.     // --------------------------------------------------------------------
  627.  
  628.     /**
  629.      * OR WHERE
  630.      *
  631.      * Generates the WHERE portion of the query.
  632.      * Separates multiple calls with 'OR'.
  633.      *
  634.      * @param   mixed
  635.      * @param   mixed
  636.      * @param   bool
  637.      * @return  CI_DB_query_builder
  638.      */
  639.     public function or_where($key, $value = NULL, $escape = NULL)
  640.     {
  641.         return $this->_wh('qb_where', $key, $value, 'OR ', $escape);
  642.     }
  643.  
  644.     // --------------------------------------------------------------------
  645.  
  646.     /**
  647.      * WHERE, HAVING
  648.      *
  649.      * @used-by where()
  650.      * @used-by or_where()
  651.      * @used-by having()
  652.      * @used-by or_having()
  653.      *
  654.      * @param   string  $qb_key 'qb_where' or 'qb_having'
  655.      * @param   mixed   $key
  656.      * @param   mixed   $value
  657.      * @param   string  $type
  658.      * @param   bool    $escape
  659.      * @return  CI_DB_query_builder
  660.      */
  661.     protected function _wh($qb_key, $key, $value = NULL, $type = 'AND ', $escape = NULL)
  662.     {
  663.         $qb_cache_key = ($qb_key === 'qb_having') ? 'qb_cache_having' : 'qb_cache_where';
  664.  
  665.         if ( ! is_array($key))
  666.         {
  667.             $key = array($key => $value);
  668.         }
  669.  
  670.         // If the escape value was not set will base it on the global setting
  671.         is_bool($escape) OR $escape = $this->_protect_identifiers;
  672.  
  673.         foreach ($key as $k => $v)
  674.         {
  675.             $prefix = (count($this->$qb_key) === 0 && count($this->$qb_cache_key) === 0)
  676.                 ? $this->_group_get_type('')
  677.                 : $this->_group_get_type($type);
  678.  
  679.             if ($v !== NULL)
  680.             {
  681.                 if ($escape === TRUE)
  682.                 {
  683.                     $v = $this->escape($v);
  684.                 }
  685.  
  686.                 if ( ! $this->_has_operator($k))
  687.                 {
  688.                     $k .= ' = ';
  689.                 }
  690.             }
  691.             elseif ( ! $this->_has_operator($k))
  692.             {
  693.                 // value appears not to have been set, assign the test to IS NULL
  694.                 $k .= ' IS NULL';
  695.             }
  696.             elseif (preg_match('/\s*(!?=|<>|\sIS(?:\s+NOT)?\s)\s*$/i', $k, $match, PREG_OFFSET_CAPTURE))
  697.             {
  698.                 $k = substr($k, 0, $match[0][1]).($match[1][0] === '=' ? ' IS NULL' : ' IS NOT NULL');
  699.             }
  700.  
  701.             ${$qb_key} = array('condition' => $prefix.$k, 'value' => $v, 'escape' => $escape);
  702.             $this->{$qb_key}[] = ${$qb_key};
  703.             if ($this->qb_caching === TRUE)
  704.             {
  705.                 $this->{$qb_cache_key}[] = ${$qb_key};
  706.                 $this->qb_cache_exists[] = substr($qb_key, 3);
  707.             }
  708.  
  709.         }
  710.  
  711.         return $this;
  712.     }
  713.  
  714.     // --------------------------------------------------------------------
  715.  
  716.     /**
  717.      * WHERE IN
  718.      *
  719.      * Generates a WHERE field IN('item', 'item') SQL query,
  720.      * joined with 'AND' if appropriate.
  721.      *
  722.      * @param   string  $key    The field to search
  723.      * @param   array   $values The values searched on
  724.      * @param   bool    $escape
  725.      * @return  CI_DB_query_builder
  726.      */
  727.     public function where_in($key = NULL, $values = NULL, $escape = NULL)
  728.     {
  729.         return $this->_where_in($key, $values, FALSE, 'AND ', $escape);
  730.     }
  731.  
  732.     // --------------------------------------------------------------------
  733.  
  734.     /**
  735.      * OR WHERE IN
  736.      *
  737.      * Generates a WHERE field IN('item', 'item') SQL query,
  738.      * joined with 'OR' if appropriate.
  739.      *
  740.      * @param   string  $key    The field to search
  741.      * @param   array   $values The values searched on
  742.      * @param   bool    $escape
  743.      * @return  CI_DB_query_builder
  744.      */
  745.     public function or_where_in($key = NULL, $values = NULL, $escape = NULL)
  746.     {
  747.         return $this->_where_in($key, $values, FALSE, 'OR ', $escape);
  748.     }
  749.  
  750.     // --------------------------------------------------------------------
  751.  
  752.     /**
  753.      * WHERE NOT IN
  754.      *
  755.      * Generates a WHERE field NOT IN('item', 'item') SQL query,
  756.      * joined with 'AND' if appropriate.
  757.      *
  758.      * @param   string  $key    The field to search
  759.      * @param   array   $values The values searched on
  760.      * @param   bool    $escape
  761.      * @return  CI_DB_query_builder
  762.      */
  763.     public function where_not_in($key = NULL, $values = NULL, $escape = NULL)
  764.     {
  765.         return $this->_where_in($key, $values, TRUE, 'AND ', $escape);
  766.     }
  767.  
  768.     // --------------------------------------------------------------------
  769.  
  770.     /**
  771.      * OR WHERE NOT IN
  772.      *
  773.      * Generates a WHERE field NOT IN('item', 'item') SQL query,
  774.      * joined with 'OR' if appropriate.
  775.      *
  776.      * @param   string  $key    The field to search
  777.      * @param   array   $values The values searched on
  778.      * @param   bool    $escape
  779.      * @return  CI_DB_query_builder
  780.      */
  781.     public function or_where_not_in($key = NULL, $values = NULL, $escape = NULL)
  782.     {
  783.         return $this->_where_in($key, $values, TRUE, 'OR ', $escape);
  784.     }
  785.  
  786.     // --------------------------------------------------------------------
  787.  
  788.     /**
  789.      * Internal WHERE IN
  790.      *
  791.      * @used-by where_in()
  792.      * @used-by or_where_in()
  793.      * @used-by where_not_in()
  794.      * @used-by or_where_not_in()
  795.      *
  796.      * @param   string  $key    The field to search
  797.      * @param   array   $values The values searched on
  798.      * @param   bool    $not    If the statement would be IN or NOT IN
  799.      * @param   string  $type
  800.      * @param   bool    $escape
  801.      * @return  CI_DB_query_builder
  802.      */
  803.     protected function _where_in($key = NULL, $values = NULL, $not = FALSE, $type = 'AND ', $escape = NULL)
  804.     {
  805.         if ($key === NULL OR $values === NULL)
  806.         {
  807.             return $this;
  808.         }
  809.  
  810.         if ( ! is_array($values))
  811.         {
  812.             $values = array($values);
  813.         }
  814.  
  815.         is_bool($escape) OR $escape = $this->_protect_identifiers;
  816.  
  817.         $not = ($not) ? ' NOT' : '';
  818.  
  819.         if ($escape === TRUE)
  820.         {
  821.             $where_in = array();
  822.             foreach ($values as $value)
  823.             {
  824.                 $where_in[] = $this->escape($value);
  825.             }
  826.         }
  827.         else
  828.         {
  829.             $where_in = array_values($values);
  830.         }
  831.  
  832.         $prefix = (count($this->qb_where) === 0 && count($this->qb_cache_where) === 0)
  833.             ? $this->_group_get_type('')
  834.             : $this->_group_get_type($type);
  835.  
  836.         $where_in = array(
  837.             'condition' => $prefix.$key.$not.' IN('.implode(', ', $where_in).')',
  838.             'value' => NULL,
  839.             'escape' => $escape
  840.         );
  841.  
  842.         $this->qb_where[] = $where_in;
  843.         if ($this->qb_caching === TRUE)
  844.         {
  845.             $this->qb_cache_where[] = $where_in;
  846.             $this->qb_cache_exists[] = 'where';
  847.         }
  848.  
  849.         return $this;
  850.     }
  851.  
  852.     // --------------------------------------------------------------------
  853.  
  854.     /**
  855.      * LIKE
  856.      *
  857.      * Generates a %LIKE% portion of the query.
  858.      * Separates multiple calls with 'AND'.
  859.      *
  860.      * @param   mixed   $field
  861.      * @param   string  $match
  862.      * @param   string  $side
  863.      * @param   bool    $escape
  864.      * @return  CI_DB_query_builder
  865.      */
  866.     public function like($field, $match = '', $side = 'both', $escape = NULL)
  867.     {
  868.         return $this->_like($field, $match, 'AND ', $side, '', $escape);
  869.     }
  870.  
  871.     // --------------------------------------------------------------------
  872.  
  873.     /**
  874.      * NOT LIKE
  875.      *
  876.      * Generates a NOT LIKE portion of the query.
  877.      * Separates multiple calls with 'AND'.
  878.      *
  879.      * @param   mixed   $field
  880.      * @param   string  $match
  881.      * @param   string  $side
  882.      * @param   bool    $escape
  883.      * @return  CI_DB_query_builder
  884.      */
  885.     public function not_like($field, $match = '', $side = 'both', $escape = NULL)
  886.     {
  887.         return $this->_like($field, $match, 'AND ', $side, 'NOT', $escape);
  888.     }
  889.  
  890.     // --------------------------------------------------------------------
  891.  
  892.     /**
  893.      * OR LIKE
  894.      *
  895.      * Generates a %LIKE% portion of the query.
  896.      * Separates multiple calls with 'OR'.
  897.      *
  898.      * @param   mixed   $field
  899.      * @param   string  $match
  900.      * @param   string  $side
  901.      * @param   bool    $escape
  902.      * @return  CI_DB_query_builder
  903.      */
  904.     public function or_like($field, $match = '', $side = 'both', $escape = NULL)
  905.     {
  906.         return $this->_like($field, $match, 'OR ', $side, '', $escape);
  907.     }
  908.  
  909.     // --------------------------------------------------------------------
  910.  
  911.     /**
  912.      * OR NOT LIKE
  913.      *
  914.      * Generates a NOT LIKE portion of the query.
  915.      * Separates multiple calls with 'OR'.
  916.      *
  917.      * @param   mixed   $field
  918.      * @param   string  $match
  919.      * @param   string  $side
  920.      * @param   bool    $escape
  921.      * @return  CI_DB_query_builder
  922.      */
  923.     public function or_not_like($field, $match = '', $side = 'both', $escape = NULL)
  924.     {
  925.         return $this->_like($field, $match, 'OR ', $side, 'NOT', $escape);
  926.     }
  927.  
  928.     // --------------------------------------------------------------------
  929.  
  930.     /**
  931.      * Internal LIKE
  932.      *
  933.      * @used-by like()
  934.      * @used-by or_like()
  935.      * @used-by not_like()
  936.      * @used-by or_not_like()
  937.      *
  938.      * @param   mixed   $field
  939.      * @param   string  $match
  940.      * @param   string  $type
  941.      * @param   string  $side
  942.      * @param   string  $not
  943.      * @param   bool    $escape
  944.      * @return  CI_DB_query_builder
  945.      */
  946.     protected function _like($field, $match = '', $type = 'AND ', $side = 'both', $not = '', $escape = NULL)
  947.     {
  948.         if ( ! is_array($field))
  949.         {
  950.             $field = array($field => $match);
  951.         }
  952.  
  953.         is_bool($escape) OR $escape = $this->_protect_identifiers;
  954.         // lowercase $side in case somebody writes e.g. 'BEFORE' instead of 'before' (doh)
  955.         $side = strtolower($side);
  956.  
  957.         foreach ($field as $k => $v)
  958.         {
  959.             $prefix = (count($this->qb_where) === 0 && count($this->qb_cache_where) === 0)
  960.                 ? $this->_group_get_type('') : $this->_group_get_type($type);
  961.  
  962.             if ($escape === TRUE)
  963.             {
  964.                 $v = $this->escape_like_str($v);
  965.             }
  966.  
  967.             switch ($side)
  968.             {
  969.                 case 'none':
  970.                     $v = "'{$v}'";
  971.                     break;
  972.                 case 'before':
  973.                     $v = "'%{$v}'";
  974.                     break;
  975.                 case 'after':
  976.                     $v = "'{$v}%'";
  977.                     break;
  978.                 case 'both':
  979.                 default:
  980.                     $v = "'%{$v}%'";
  981.                     break;
  982.             }
  983.  
  984.             // some platforms require an escape sequence definition for LIKE wildcards
  985.             if ($escape === TRUE && $this->_like_escape_str !== '')
  986.             {
  987.                 $v .= sprintf($this->_like_escape_str, $this->_like_escape_chr);
  988.             }
  989.  
  990.             $qb_where = array('condition' => "{$prefix} {$k} {$not} LIKE {$v}", 'value' => NULL, 'escape' => $escape);
  991.             $this->qb_where[] = $qb_where;
  992.             if ($this->qb_caching === TRUE)
  993.             {
  994.                 $this->qb_cache_where[] = $qb_where;
  995.                 $this->qb_cache_exists[] = 'where';
  996.             }
  997.         }
  998.  
  999.         return $this;
  1000.     }
  1001.  
  1002.     // --------------------------------------------------------------------
  1003.  
  1004.     /**
  1005.      * Starts a query group.
  1006.      *
  1007.      * @param   string  $not    (Internal use only)
  1008.      * @param   string  $type   (Internal use only)
  1009.      * @return  CI_DB_query_builder
  1010.      */
  1011.     public function group_start($not = '', $type = 'AND ')
  1012.     {
  1013.         $type = $this->_group_get_type($type);
  1014.  
  1015.         $this->qb_where_group_started = TRUE;
  1016.         $prefix = (count($this->qb_where) === 0 && count($this->qb_cache_where) === 0) ? '' : $type;
  1017.         $where = array(
  1018.             'condition' => $prefix.$not.str_repeat(' ', ++$this->qb_where_group_count).' (',
  1019.             'value' => NULL,
  1020.             'escape' => FALSE
  1021.         );
  1022.  
  1023.         $this->qb_where[] = $where;
  1024.         if ($this->qb_caching)
  1025.         {
  1026.             $this->qb_cache_where[] = $where;
  1027.         }
  1028.  
  1029.         return $this;
  1030.     }
  1031.  
  1032.     // --------------------------------------------------------------------
  1033.  
  1034.     /**
  1035.      * Starts a query group, but ORs the group
  1036.      *
  1037.      * @return  CI_DB_query_builder
  1038.      */
  1039.     public function or_group_start()
  1040.     {
  1041.         return $this->group_start('', 'OR ');
  1042.     }
  1043.  
  1044.     // --------------------------------------------------------------------
  1045.  
  1046.     /**
  1047.      * Starts a query group, but NOTs the group
  1048.      *
  1049.      * @return  CI_DB_query_builder
  1050.      */
  1051.     public function not_group_start()
  1052.     {
  1053.         return $this->group_start('NOT ', 'AND ');
  1054.     }
  1055.  
  1056.     // --------------------------------------------------------------------
  1057.  
  1058.     /**
  1059.      * Starts a query group, but OR NOTs the group
  1060.      *
  1061.      * @return  CI_DB_query_builder
  1062.      */
  1063.     public function or_not_group_start()
  1064.     {
  1065.         return $this->group_start('NOT ', 'OR ');
  1066.     }
  1067.  
  1068.     // --------------------------------------------------------------------
  1069.  
  1070.     /**
  1071.      * Ends a query group
  1072.      *
  1073.      * @return  CI_DB_query_builder
  1074.      */
  1075.     public function group_end()
  1076.     {
  1077.         $this->qb_where_group_started = FALSE;
  1078.         $where = array(
  1079.             'condition' => str_repeat(' ', $this->qb_where_group_count--).')',
  1080.             'value' => NULL,
  1081.             'escape' => FALSE
  1082.         );
  1083.  
  1084.         $this->qb_where[] = $where;
  1085.         if ($this->qb_caching)
  1086.         {
  1087.             $this->qb_cache_where[] = $where;
  1088.         }
  1089.  
  1090.         return $this;
  1091.     }
  1092.  
  1093.     // --------------------------------------------------------------------
  1094.  
  1095.     /**
  1096.      * Group_get_type
  1097.      *
  1098.      * @used-by group_start()
  1099.      * @used-by _like()
  1100.      * @used-by _wh()
  1101.      * @used-by _where_in()
  1102.      *
  1103.      * @param   string  $type
  1104.      * @return  string
  1105.      */
  1106.     protected function _group_get_type($type)
  1107.     {
  1108.         if ($this->qb_where_group_started)
  1109.         {
  1110.             $type = '';
  1111.             $this->qb_where_group_started = FALSE;
  1112.         }
  1113.  
  1114.         return $type;
  1115.     }
  1116.  
  1117.     // --------------------------------------------------------------------
  1118.  
  1119.     /**
  1120.      * GROUP BY
  1121.      *
  1122.      * @param   string  $by
  1123.      * @param   bool    $escape
  1124.      * @return  CI_DB_query_builder
  1125.      */
  1126.     public function group_by($by, $escape = NULL)
  1127.     {
  1128.         is_bool($escape) OR $escape = $this->_protect_identifiers;
  1129.  
  1130.         if (is_string($by))
  1131.         {
  1132.             $by = ($escape === TRUE)
  1133.                 ? explode(',', $by)
  1134.                 : array($by);
  1135.         }
  1136.  
  1137.         foreach ($by as $val)
  1138.         {
  1139.             $val = trim($val);
  1140.  
  1141.             if ($val !== '')
  1142.             {
  1143.                 $val = array('field' => $val, 'escape' => $escape);
  1144.  
  1145.                 $this->qb_groupby[] = $val;
  1146.                 if ($this->qb_caching === TRUE)
  1147.                 {
  1148.                     $this->qb_cache_groupby[] = $val;
  1149.                     $this->qb_cache_exists[] = 'groupby';
  1150.                 }
  1151.             }
  1152.         }
  1153.  
  1154.         return $this;
  1155.     }
  1156.  
  1157.     // --------------------------------------------------------------------
  1158.  
  1159.     /**
  1160.      * HAVING
  1161.      *
  1162.      * Separates multiple calls with 'AND'.
  1163.      *
  1164.      * @param   string  $key
  1165.      * @param   string  $value
  1166.      * @param   bool    $escape
  1167.      * @return  CI_DB_query_builder
  1168.      */
  1169.     public function having($key, $value = NULL, $escape = NULL)
  1170.     {
  1171.         return $this->_wh('qb_having', $key, $value, 'AND ', $escape);
  1172.     }
  1173.  
  1174.     // --------------------------------------------------------------------
  1175.  
  1176.     /**
  1177.      * OR HAVING
  1178.      *
  1179.      * Separates multiple calls with 'OR'.
  1180.      *
  1181.      * @param   string  $key
  1182.      * @param   string  $value
  1183.      * @param   bool    $escape
  1184.      * @return  CI_DB_query_builder
  1185.      */
  1186.     public function or_having($key, $value = NULL, $escape = NULL)
  1187.     {
  1188.         return $this->_wh('qb_having', $key, $value, 'OR ', $escape);
  1189.     }
  1190.  
  1191.     // --------------------------------------------------------------------
  1192.  
  1193.     /**
  1194.      * ORDER BY
  1195.      *
  1196.      * @param   string  $orderby
  1197.      * @param   string  $direction  ASC, DESC or RANDOM
  1198.      * @param   bool    $escape
  1199.      * @return  CI_DB_query_builder
  1200.      */
  1201.     public function order_by($orderby, $direction = '', $escape = NULL)
  1202.     {
  1203.         $direction = strtoupper(trim($direction));
  1204.  
  1205.         if ($direction === 'RANDOM')
  1206.         {
  1207.             $direction = '';
  1208.  
  1209.             // Do we have a seed value?
  1210.             $orderby = ctype_digit((string) $orderby)
  1211.                 ? sprintf($this->_random_keyword[1], $orderby)
  1212.                 : $this->_random_keyword[0];
  1213.         }
  1214.         elseif (empty($orderby))
  1215.         {
  1216.             return $this;
  1217.         }
  1218.         elseif ($direction !== '')
  1219.         {
  1220.             $direction = in_array($direction, array('ASC', 'DESC'), TRUE) ? ' '.$direction : '';
  1221.         }
  1222.  
  1223.         is_bool($escape) OR $escape = $this->_protect_identifiers;
  1224.  
  1225.         if ($escape === FALSE)
  1226.         {
  1227.             $qb_orderby[] = array('field' => $orderby, 'direction' => $direction, 'escape' => FALSE);
  1228.         }
  1229.         else
  1230.         {
  1231.             $qb_orderby = array();
  1232.             foreach (explode(',', $orderby) as $field)
  1233.             {
  1234.                 $qb_orderby[] = ($direction === '' && preg_match('/\s+(ASC|DESC)$/i', rtrim($field), $match, PREG_OFFSET_CAPTURE))
  1235.                     ? array('field' => ltrim(substr($field, 0, $match[0][1])), 'direction' => ' '.$match[1][0], 'escape' => TRUE)
  1236.                     : array('field' => trim($field), 'direction' => $direction, 'escape' => TRUE);
  1237.             }
  1238.         }
  1239.  
  1240.         $this->qb_orderby = array_merge($this->qb_orderby, $qb_orderby);
  1241.         if ($this->qb_caching === TRUE)
  1242.         {
  1243.             $this->qb_cache_orderby = array_merge($this->qb_cache_orderby, $qb_orderby);
  1244.             $this->qb_cache_exists[] = 'orderby';
  1245.         }
  1246.  
  1247.         return $this;
  1248.     }
  1249.  
  1250.     // --------------------------------------------------------------------
  1251.  
  1252.     /**
  1253.      * LIMIT
  1254.      *
  1255.      * @param   int $value  LIMIT value
  1256.      * @param   int $offset OFFSET value
  1257.      * @return  CI_DB_query_builder
  1258.      */
  1259.     public function limit($value, $offset = 0)
  1260.     {
  1261.         is_null($value) OR $this->qb_limit = (int) $value;
  1262.         empty($offset) OR $this->qb_offset = (int) $offset;
  1263.  
  1264.         return $this;
  1265.     }
  1266.  
  1267.     // --------------------------------------------------------------------
  1268.  
  1269.     /**
  1270.      * Sets the OFFSET value
  1271.      *
  1272.      * @param   int $offset OFFSET value
  1273.      * @return  CI_DB_query_builder
  1274.      */
  1275.     public function offset($offset)
  1276.     {
  1277.         empty($offset) OR $this->qb_offset = (int) $offset;
  1278.         return $this;
  1279.     }
  1280.  
  1281.     // --------------------------------------------------------------------
  1282.  
  1283.     /**
  1284.      * LIMIT string
  1285.      *
  1286.      * Generates a platform-specific LIMIT clause.
  1287.      *
  1288.      * @param   string  $sql    SQL Query
  1289.      * @return  string
  1290.      */
  1291.     protected function _limit($sql)
  1292.     {
  1293.         return $sql.' LIMIT '.($this->qb_offset ? $this->qb_offset.', ' : '').(int) $this->qb_limit;
  1294.     }
  1295.  
  1296.     // --------------------------------------------------------------------
  1297.  
  1298.     /**
  1299.      * The "set" function.
  1300.      *
  1301.      * Allows key/value pairs to be set for inserting or updating
  1302.      *
  1303.      * @param   mixed
  1304.      * @param   string
  1305.      * @param   bool
  1306.      * @return  CI_DB_query_builder
  1307.      */
  1308.     public function set($key, $value = '', $escape = NULL)
  1309.     {
  1310.         $key = $this->_object_to_array($key);
  1311.  
  1312.         if ( ! is_array($key))
  1313.         {
  1314.             $key = array($key => $value);
  1315.         }
  1316.  
  1317.         is_bool($escape) OR $escape = $this->_protect_identifiers;
  1318.  
  1319.         foreach ($key as $k => $v)
  1320.         {
  1321.             $this->qb_set[$this->protect_identifiers($k, FALSE, $escape)] = ($escape)
  1322.                 ? $this->escape($v) : $v;
  1323.         }
  1324.  
  1325.         return $this;
  1326.     }
  1327.  
  1328.     // --------------------------------------------------------------------
  1329.  
  1330.     /**
  1331.      * Get SELECT query string
  1332.      *
  1333.      * Compiles a SELECT query string and returns the sql.
  1334.      *
  1335.      * @param   string  the table name to select from (optional)
  1336.      * @param   bool    TRUE: resets QB values; FALSE: leave QB values alone
  1337.      * @return  string
  1338.      */
  1339.     public function get_compiled_select($table = '', $reset = TRUE)
  1340.     {
  1341.         if ($table !== '')
  1342.         {
  1343.             $this->_track_aliases($table);
  1344.             $this->from($table);
  1345.         }
  1346.  
  1347.         $select = $this->_compile_select();
  1348.  
  1349.         if ($reset === TRUE)
  1350.         {
  1351.             $this->_reset_select();
  1352.         }
  1353.  
  1354.         return $select;
  1355.     }
  1356.  
  1357.     // --------------------------------------------------------------------
  1358.  
  1359.     /**
  1360.      * Get
  1361.      *
  1362.      * Compiles the select statement based on the other functions called
  1363.      * and runs the query
  1364.      *
  1365.      * @param   string  the table
  1366.      * @param   string  the limit clause
  1367.      * @param   string  the offset clause
  1368.      * @return  CI_DB_result
  1369.      */
  1370.     public function get($table = '', $limit = NULL, $offset = NULL)
  1371.     {
  1372.         if ($table !== '')
  1373.         {
  1374.             $this->_track_aliases($table);
  1375.             $this->from($table);
  1376.         }
  1377.  
  1378.         if ( ! empty($limit))
  1379.         {
  1380.             $this->limit($limit, $offset);
  1381.         }
  1382.  
  1383.         $result = $this->query($this->_compile_select());
  1384.         $this->_reset_select();
  1385.         return $result;
  1386.     }
  1387.  
  1388.     // --------------------------------------------------------------------
  1389.  
  1390.     /**
  1391.      * "Count All Results" query
  1392.      *
  1393.      * Generates a platform-specific query string that counts all records
  1394.      * returned by an Query Builder query.
  1395.      *
  1396.      * @param   string
  1397.      * @param   bool    the reset clause
  1398.      * @return  int
  1399.      */
  1400.     public function count_all_results($table = '', $reset = TRUE)
  1401.     {
  1402.         if ($table !== '')
  1403.         {
  1404.             $this->_track_aliases($table);
  1405.             $this->from($table);
  1406.         }
  1407.  
  1408.         // ORDER BY usage is often problematic here (most notably
  1409.         // on Microsoft SQL Server) and ultimately unnecessary
  1410.         // for selecting COUNT(*) ...
  1411.         $qb_orderby       = $this->qb_orderby;
  1412.         $qb_cache_orderby = $this->qb_cache_orderby;
  1413.         $this->qb_orderby = $this->qb_cache_orderby = array();
  1414.  
  1415.         $result = ($this->qb_distinct === TRUE OR ! empty($this->qb_groupby) OR ! empty($this->qb_cache_groupby) OR $this->qb_limit OR $this->qb_offset)
  1416.             ? $this->query($this->_count_string.$this->protect_identifiers('numrows')."\nFROM (\n".$this->_compile_select()."\n) CI_count_all_results")
  1417.             : $this->query($this->_compile_select($this->_count_string.$this->protect_identifiers('numrows')));
  1418.  
  1419.         if ($reset === TRUE)
  1420.         {
  1421.             $this->_reset_select();
  1422.         }
  1423.         else
  1424.         {
  1425.             $this->qb_orderby       = $qb_orderby;
  1426.             $this->qb_cache_orderby = $qb_cache_orderby;
  1427.         }
  1428.  
  1429.         if ($result->num_rows() === 0)
  1430.         {
  1431.             return 0;
  1432.         }
  1433.  
  1434.         $row = $result->row();
  1435.         return (int) $row->numrows;
  1436.     }
  1437.  
  1438.     // --------------------------------------------------------------------
  1439.  
  1440.     /**
  1441.      * get_where()
  1442.      *
  1443.      * Allows the where clause, limit and offset to be added directly
  1444.      *
  1445.      * @param   string  $table
  1446.      * @param   string  $where
  1447.      * @param   int $limit
  1448.      * @param   int $offset
  1449.      * @return  CI_DB_result
  1450.      */
  1451.     public function get_where($table = '', $where = NULL, $limit = NULL, $offset = NULL)
  1452.     {
  1453.         if ($table !== '')
  1454.         {
  1455.             $this->from($table);
  1456.         }
  1457.  
  1458.         if ($where !== NULL)
  1459.         {
  1460.             $this->where($where);
  1461.         }
  1462.  
  1463.         if ( ! empty($limit))
  1464.         {
  1465.             $this->limit($limit, $offset);
  1466.         }
  1467.  
  1468.         $result = $this->query($this->_compile_select());
  1469.         $this->_reset_select();
  1470.         return $result;
  1471.     }
  1472.  
  1473.     // --------------------------------------------------------------------
  1474.  
  1475.     /**
  1476.      * Insert_Batch
  1477.      *
  1478.      * Compiles batch insert strings and runs the queries
  1479.      *
  1480.      * @param   string  $table  Table to insert into
  1481.      * @param   array   $set    An associative array of insert values
  1482.      * @param   bool    $escape Whether to escape values and identifiers
  1483.      * @return  int Number of rows inserted or FALSE on failure
  1484.      */
  1485.     public function insert_batch($table, $set = NULL, $escape = NULL, $batch_size = 100)
  1486.     {
  1487.         if ($set === NULL)
  1488.         {
  1489.             if (empty($this->qb_set))
  1490.             {
  1491.                 return ($this->db_debug) ? $this->display_error('db_must_use_set') : FALSE;
  1492.             }
  1493.         }
  1494.         else
  1495.         {
  1496.             if (empty($set))
  1497.             {
  1498.                 return ($this->db_debug) ? $this->display_error('insert_batch() called with no data') : FALSE;
  1499.             }
  1500.  
  1501.             $this->set_insert_batch($set, '', $escape);
  1502.         }
  1503.  
  1504.         if (strlen($table) === 0)
  1505.         {
  1506.             if ( ! isset($this->qb_from[0]))
  1507.             {
  1508.                 return ($this->db_debug) ? $this->display_error('db_must_set_table') : FALSE;
  1509.             }
  1510.  
  1511.             $table = $this->qb_from[0];
  1512.         }
  1513.  
  1514.         // Batch this baby
  1515.         $affected_rows = 0;
  1516.         for ($i = 0, $total = count($this->qb_set); $i < $total; $i += $batch_size)
  1517.         {
  1518.             if ($this->query($this->_insert_batch($this->protect_identifiers($table, TRUE, $escape, FALSE), $this->qb_keys, array_slice($this->qb_set, $i, $batch_size))))
  1519.             {
  1520.                 $affected_rows += $this->affected_rows();
  1521.             }
  1522.         }
  1523.  
  1524.         $this->_reset_write();
  1525.         return $affected_rows;
  1526.     }
  1527.  
  1528.     // --------------------------------------------------------------------
  1529.  
  1530.     /**
  1531.      * Insert batch statement
  1532.      *
  1533.      * Generates a platform-specific insert string from the supplied data.
  1534.      *
  1535.      * @param   string  $table  Table name
  1536.      * @param   array   $keys   INSERT keys
  1537.      * @param   array   $values INSERT values
  1538.      * @return  string
  1539.      */
  1540.     protected function _insert_batch($table, $keys, $values)
  1541.     {
  1542.         return 'INSERT INTO '.$table.' ('.implode(', ', $keys).') VALUES '.implode(', ', $values);
  1543.     }
  1544.  
  1545.     // --------------------------------------------------------------------
  1546.  
  1547.     /**
  1548.      * The "set_insert_batch" function.  Allows key/value pairs to be set for batch inserts
  1549.      *
  1550.      * @param   mixed
  1551.      * @param   string
  1552.      * @param   bool
  1553.      * @return  CI_DB_query_builder
  1554.      */
  1555.     public function set_insert_batch($key, $value = '', $escape = NULL)
  1556.     {
  1557.         $key = $this->_object_to_array_batch($key);
  1558.  
  1559.         if ( ! is_array($key))
  1560.         {
  1561.             $key = array($key => $value);
  1562.         }
  1563.  
  1564.         is_bool($escape) OR $escape = $this->_protect_identifiers;
  1565.  
  1566.         $keys = array_keys($this->_object_to_array(reset($key)));
  1567.         sort($keys);
  1568.  
  1569.         foreach ($key as $row)
  1570.         {
  1571.             $row = $this->_object_to_array($row);
  1572.             if (count(array_diff($keys, array_keys($row))) > 0 OR count(array_diff(array_keys($row), $keys)) > 0)
  1573.             {
  1574.                 // batch function above returns an error on an empty array
  1575.                 $this->qb_set[] = array();
  1576.                 return;
  1577.             }
  1578.  
  1579.             ksort($row); // puts $row in the same order as our keys
  1580.  
  1581.             if ($escape !== FALSE)
  1582.             {
  1583.                 $clean = array();
  1584.                 foreach ($row as $value)
  1585.                 {
  1586.                     $clean[] = $this->escape($value);
  1587.                 }
  1588.  
  1589.                 $row = $clean;
  1590.             }
  1591.  
  1592.             $this->qb_set[] = '('.implode(',', $row).')';
  1593.         }
  1594.  
  1595.         foreach ($keys as $k)
  1596.         {
  1597.             $this->qb_keys[] = $this->protect_identifiers($k, FALSE, $escape);
  1598.         }
  1599.  
  1600.         return $this;
  1601.     }
  1602.  
  1603.     // --------------------------------------------------------------------
  1604.  
  1605.     /**
  1606.      * Get INSERT query string
  1607.      *
  1608.      * Compiles an insert query and returns the sql
  1609.      *
  1610.      * @param   string  the table to insert into
  1611.      * @param   bool    TRUE: reset QB values; FALSE: leave QB values alone
  1612.      * @return  string
  1613.      */
  1614.     public function get_compiled_insert($table = '', $reset = TRUE)
  1615.     {
  1616.         if ($this->_validate_insert($table) === FALSE)
  1617.         {
  1618.             return FALSE;
  1619.         }
  1620.  
  1621.         $sql = $this->_insert(
  1622.             $this->protect_identifiers(
  1623.                 $this->qb_from[0], TRUE, NULL, FALSE
  1624.             ),
  1625.             array_keys($this->qb_set),
  1626.             array_values($this->qb_set)
  1627.         );
  1628.  
  1629.         if ($reset === TRUE)
  1630.         {
  1631.             $this->_reset_write();
  1632.         }
  1633.  
  1634.         return $sql;
  1635.     }
  1636.  
  1637.     // --------------------------------------------------------------------
  1638.  
  1639.     /**
  1640.      * Insert
  1641.      *
  1642.      * Compiles an insert string and runs the query
  1643.      *
  1644.      * @param   string  the table to insert data into
  1645.      * @param   array   an associative array of insert values
  1646.      * @param   bool    $escape Whether to escape values and identifiers
  1647.      * @return  bool    TRUE on success, FALSE on failure
  1648.      */
  1649.     public function insert($table = '', $set = NULL, $escape = NULL)
  1650.     {
  1651.         if ($set !== NULL)
  1652.         {
  1653.             $this->set($set, '', $escape);
  1654.         }
  1655.  
  1656.         if ($this->_validate_insert($table) === FALSE)
  1657.         {
  1658.             return FALSE;
  1659.         }
  1660.  
  1661.         $sql = $this->_insert(
  1662.             $this->protect_identifiers(
  1663.                 $this->qb_from[0], TRUE, $escape, FALSE
  1664.             ),
  1665.             array_keys($this->qb_set),
  1666.             array_values($this->qb_set)
  1667.         );
  1668.  
  1669.         $this->_reset_write();
  1670.         return $this->query($sql);
  1671.     }
  1672.  
  1673.     // --------------------------------------------------------------------
  1674.  
  1675.     /**
  1676.      * Validate Insert
  1677.      *
  1678.      * This method is used by both insert() and get_compiled_insert() to
  1679.      * validate that the there data is actually being set and that table
  1680.      * has been chosen to be inserted into.
  1681.      *
  1682.      * @param   string  the table to insert data into
  1683.      * @return  string
  1684.      */
  1685.     protected function _validate_insert($table = '')
  1686.     {
  1687.         if (count($this->qb_set) === 0)
  1688.         {
  1689.             return ($this->db_debug) ? $this->display_error('db_must_use_set') : FALSE;
  1690.         }
  1691.  
  1692.         if ($table !== '')
  1693.         {
  1694.             $this->qb_from[0] = $table;
  1695.         }
  1696.         elseif ( ! isset($this->qb_from[0]))
  1697.         {
  1698.             return ($this->db_debug) ? $this->display_error('db_must_set_table') : FALSE;
  1699.         }
  1700.  
  1701.         return TRUE;
  1702.     }
  1703.  
  1704.     // --------------------------------------------------------------------
  1705.  
  1706.     /**
  1707.      * Replace
  1708.      *
  1709.      * Compiles an replace into string and runs the query
  1710.      *
  1711.      * @param   string  the table to replace data into
  1712.      * @param   array   an associative array of insert values
  1713.      * @return  bool    TRUE on success, FALSE on failure
  1714.      */
  1715.     public function replace($table = '', $set = NULL)
  1716.     {
  1717.         if ($set !== NULL)
  1718.         {
  1719.             $this->set($set);
  1720.         }
  1721.  
  1722.         if (count($this->qb_set) === 0)
  1723.         {
  1724.             return ($this->db_debug) ? $this->display_error('db_must_use_set') : FALSE;
  1725.         }
  1726.  
  1727.         if ($table === '')
  1728.         {
  1729.             if ( ! isset($this->qb_from[0]))
  1730.             {
  1731.                 return ($this->db_debug) ? $this->display_error('db_must_set_table') : FALSE;
  1732.             }
  1733.  
  1734.             $table = $this->qb_from[0];
  1735.         }
  1736.  
  1737.         $sql = $this->_replace($this->protect_identifiers($table, TRUE, NULL, FALSE), array_keys($this->qb_set), array_values($this->qb_set));
  1738.  
  1739.         $this->_reset_write();
  1740.         return $this->query($sql);
  1741.     }
  1742.  
  1743.     // --------------------------------------------------------------------
  1744.  
  1745.     /**
  1746.      * Replace statement
  1747.      *
  1748.      * Generates a platform-specific replace string from the supplied data
  1749.      *
  1750.      * @param   string  the table name
  1751.      * @param   array   the insert keys
  1752.      * @param   array   the insert values
  1753.      * @return  string
  1754.      */
  1755.     protected function _replace($table, $keys, $values)
  1756.     {
  1757.         return 'REPLACE INTO '.$table.' ('.implode(', ', $keys).') VALUES ('.implode(', ', $values).')';
  1758.     }
  1759.  
  1760.     // --------------------------------------------------------------------
  1761.  
  1762.     /**
  1763.      * FROM tables
  1764.      *
  1765.      * Groups tables in FROM clauses if needed, so there is no confusion
  1766.      * about operator precedence.
  1767.      *
  1768.      * Note: This is only used (and overridden) by MySQL and CUBRID.
  1769.      *
  1770.      * @return  string
  1771.      */
  1772.     protected function _from_tables()
  1773.     {
  1774.         return implode(', ', $this->qb_from);
  1775.     }
  1776.  
  1777.     // --------------------------------------------------------------------
  1778.  
  1779.     /**
  1780.      * Get UPDATE query string
  1781.      *
  1782.      * Compiles an update query and returns the sql
  1783.      *
  1784.      * @param   string  the table to update
  1785.      * @param   bool    TRUE: reset QB values; FALSE: leave QB values alone
  1786.      * @return  string
  1787.      */
  1788.     public function get_compiled_update($table = '', $reset = TRUE, $escape = NULL)
  1789.     {
  1790.         // Combine any cached components with the current statements
  1791.         $this->_merge_cache();
  1792.  
  1793.         if ($this->_validate_update($table, $escape) === FALSE)
  1794.         {
  1795.             return FALSE;
  1796.         }
  1797.  
  1798.         $sql = $this->_update($this->qb_from[0], $this->qb_set);
  1799.  
  1800.         if ($reset === TRUE)
  1801.         {
  1802.             $this->_reset_write();
  1803.         }
  1804.  
  1805.         return $sql;
  1806.     }
  1807.  
  1808.     // --------------------------------------------------------------------
  1809.  
  1810.     /**
  1811.      * UPDATE
  1812.      *
  1813.      * Compiles an update string and runs the query.
  1814.      *
  1815.      * @param   string  $table
  1816.      * @param   array   $set    An associative array of update values
  1817.      * @param   mixed   $where
  1818.      * @param   int $limit
  1819.      * @return  bool    TRUE on success, FALSE on failure
  1820.      */
  1821.     public function update($table = '', $set = NULL, $where = NULL, $limit = NULL, $escape = NULL)
  1822.     {
  1823.         // Combine any cached components with the current statements
  1824.         $this->_merge_cache();
  1825.  
  1826.         if ($set !== NULL)
  1827.         {
  1828.             $this->set($set);
  1829.         }
  1830.  
  1831.         if ($this->_validate_update($table, $escape) === FALSE)
  1832.         {
  1833.             return FALSE;
  1834.         }
  1835.  
  1836.         if ($where !== NULL)
  1837.         {
  1838.             $this->where($where);
  1839.         }
  1840.  
  1841.         if ( ! empty($limit))
  1842.         {
  1843.             $this->limit($limit);
  1844.         }
  1845.  
  1846.         $sql = $this->_update($this->qb_from[0], $this->qb_set);
  1847.         $this->_reset_write();
  1848.         return $this->query($sql);
  1849.     }
  1850.  
  1851.     // --------------------------------------------------------------------
  1852.  
  1853.     /**
  1854.      * Validate Update
  1855.      *
  1856.      * This method is used by both update() and get_compiled_update() to
  1857.      * validate that data is actually being set and that a table has been
  1858.      * chosen to be update.
  1859.      *
  1860.      * @param   string  the table to update data on
  1861.      * @return  bool
  1862.      */
  1863.     protected function _validate_update($table, $escape = NULL)
  1864.     {
  1865.         if (count($this->qb_set) === 0)
  1866.         {
  1867.             return ($this->db_debug) ? $this->display_error('db_must_use_set') : FALSE;
  1868.         }
  1869.  
  1870.         if ($table !== '')
  1871.         {
  1872.             $this->qb_from = array($this->protect_identifiers($table, TRUE, $escape, FALSE));
  1873.         }
  1874.         elseif ( ! isset($this->qb_from[0]))
  1875.         {
  1876.             return ($this->db_debug) ? $this->display_error('db_must_set_table') : FALSE;
  1877.         }
  1878.  
  1879.         return TRUE;
  1880.     }
  1881.  
  1882.     // --------------------------------------------------------------------
  1883.  
  1884.     /**
  1885.      * Update_Batch
  1886.      *
  1887.      * Compiles an update string and runs the query
  1888.      *
  1889.      * @param   string  the table to retrieve the results from
  1890.      * @param   array   an associative array of update values
  1891.      * @param   string  the where key
  1892.      * @return  int number of rows affected or FALSE on failure
  1893.      */
  1894.     public function update_batch($table, $set = NULL, $index = NULL, $batch_size = 100)
  1895.     {
  1896.         // Combine any cached components with the current statements
  1897.         $this->_merge_cache();
  1898.  
  1899.         if ($index === NULL)
  1900.         {
  1901.             return ($this->db_debug) ? $this->display_error('db_must_use_index') : FALSE;
  1902.         }
  1903.  
  1904.         if ($set === NULL)
  1905.         {
  1906.             if (empty($this->qb_set_ub))
  1907.             {
  1908.                 return ($this->db_debug) ? $this->display_error('db_must_use_set') : FALSE;
  1909.             }
  1910.         }
  1911.         else
  1912.         {
  1913.             if (empty($set))
  1914.             {
  1915.                 return ($this->db_debug) ? $this->display_error('update_batch() called with no data') : FALSE;
  1916.             }
  1917.  
  1918.             $this->set_update_batch($set, $index);
  1919.         }
  1920.  
  1921.         if (strlen($table) === 0)
  1922.         {
  1923.             if ( ! isset($this->qb_from[0]))
  1924.             {
  1925.                 return ($this->db_debug) ? $this->display_error('db_must_set_table') : FALSE;
  1926.             }
  1927.  
  1928.             $table = $this->qb_from[0];
  1929.         }
  1930.  
  1931.         // Batch this baby
  1932.         $affected_rows = 0;
  1933.         for ($i = 0, $total = count($this->qb_set_ub); $i < $total; $i += $batch_size)
  1934.         {
  1935.             if ($this->query($this->_update_batch($this->protect_identifiers($table, TRUE, NULL, FALSE), array_slice($this->qb_set_ub, $i, $batch_size), $index)))
  1936.             {
  1937.                 $affected_rows += $this->affected_rows();
  1938.             }
  1939.  
  1940.             $this->qb_where = array();
  1941.         }
  1942.  
  1943.         $this->_reset_write();
  1944.         return $affected_rows;
  1945.     }
  1946.  
  1947.     // --------------------------------------------------------------------
  1948.  
  1949.     /**
  1950.      * Update_Batch statement
  1951.      *
  1952.      * Generates a platform-specific batch update string from the supplied data
  1953.      *
  1954.      * @param   string  $table  Table name
  1955.      * @param   array   $values Update data
  1956.      * @param   string  $index  WHERE key
  1957.      * @return  string
  1958.      */
  1959.     protected function _update_batch($table, $values, $index)
  1960.     {
  1961.         $ids = array();
  1962.         foreach ($values as $key => $val)
  1963.         {
  1964.             $ids[] = $val[$index]['value'];
  1965.  
  1966.             foreach (array_keys($val) as $field)
  1967.             {
  1968.                 if ($field !== $index)
  1969.                 {
  1970.                     $final[$val[$field]['field']][] = 'WHEN '.$val[$index]['field'].' = '.$val[$index]['value'].' THEN '.$val[$field]['value'];
  1971.                 }
  1972.             }
  1973.         }
  1974.  
  1975.         $cases = '';
  1976.         foreach ($final as $k => $v)
  1977.         {
  1978.             $cases .= $k." = CASE \n"
  1979.                 .implode("\n", $v)."\n"
  1980.                 .'ELSE '.$k.' END, ';
  1981.         }
  1982.  
  1983.         $this->where($val[$index]['field'].' IN('.implode(',', $ids).')', NULL, FALSE);
  1984.  
  1985.         return 'UPDATE '.$table.' SET '.substr($cases, 0, -2).$this->_compile_wh('qb_where');
  1986.     }
  1987.  
  1988.     // --------------------------------------------------------------------
  1989.  
  1990.     /**
  1991.      * The "set_update_batch" function.  Allows key/value pairs to be set for batch updating
  1992.      *
  1993.      * @param   array
  1994.      * @param   string
  1995.      * @param   bool
  1996.      * @return  CI_DB_query_builder
  1997.      */
  1998.     public function set_update_batch($key, $index = '', $escape = NULL)
  1999.     {
  2000.         $key = $this->_object_to_array_batch($key);
  2001.  
  2002.         if ( ! is_array($key))
  2003.         {
  2004.             // @todo error
  2005.         }
  2006.  
  2007.         is_bool($escape) OR $escape = $this->_protect_identifiers;
  2008.  
  2009.         foreach ($key as $k => $v)
  2010.         {
  2011.             $index_set = FALSE;
  2012.             $clean = array();
  2013.             foreach ($v as $k2 => $v2)
  2014.             {
  2015.                 if ($k2 === $index)
  2016.                 {
  2017.                     $index_set = TRUE;
  2018.                 }
  2019.  
  2020.                 $clean[$k2] = array(
  2021.                     'field'  => $this->protect_identifiers($k2, FALSE, $escape),
  2022.                     'value'  => ($escape === FALSE ? $v2 : $this->escape($v2))
  2023.                 );
  2024.             }
  2025.  
  2026.             if ($index_set === FALSE)
  2027.             {
  2028.                 return $this->display_error('db_batch_missing_index');
  2029.             }
  2030.  
  2031.             $this->qb_set_ub[] = $clean;
  2032.         }
  2033.  
  2034.         return $this;
  2035.     }
  2036.  
  2037.     // --------------------------------------------------------------------
  2038.  
  2039.     /**
  2040.      * Empty Table
  2041.      *
  2042.      * Compiles a delete string and runs "DELETE FROM table"
  2043.      *
  2044.      * @param   string  the table to empty
  2045.      * @return  bool    TRUE on success, FALSE on failure
  2046.      */
  2047.     public function empty_table($table = '')
  2048.     {
  2049.         if ($table === '')
  2050.         {
  2051.             if ( ! isset($this->qb_from[0]))
  2052.             {
  2053.                 return ($this->db_debug) ? $this->display_error('db_must_set_table') : FALSE;
  2054.             }
  2055.  
  2056.             $table = $this->qb_from[0];
  2057.         }
  2058.         else
  2059.         {
  2060.             $table = $this->protect_identifiers($table, TRUE, NULL, FALSE);
  2061.         }
  2062.  
  2063.         $sql = $this->_delete($table);
  2064.         $this->_reset_write();
  2065.         return $this->query($sql);
  2066.     }
  2067.  
  2068.     // --------------------------------------------------------------------
  2069.  
  2070.     /**
  2071.      * Truncate
  2072.      *
  2073.      * Compiles a truncate string and runs the query
  2074.      * If the database does not support the truncate() command
  2075.      * This function maps to "DELETE FROM table"
  2076.      *
  2077.      * @param   string  the table to truncate
  2078.      * @return  bool    TRUE on success, FALSE on failure
  2079.      */
  2080.     public function truncate($table = '')
  2081.     {
  2082.         if ($table === '')
  2083.         {
  2084.             if ( ! isset($this->qb_from[0]))
  2085.             {
  2086.                 return ($this->db_debug) ? $this->display_error('db_must_set_table') : FALSE;
  2087.             }
  2088.  
  2089.             $table = $this->qb_from[0];
  2090.         }
  2091.         else
  2092.         {
  2093.             $table = $this->protect_identifiers($table, TRUE, NULL, FALSE);
  2094.         }
  2095.  
  2096.         $sql = $this->_truncate($table);
  2097.         $this->_reset_write();
  2098.         return $this->query($sql);
  2099.     }
  2100.  
  2101.     // --------------------------------------------------------------------
  2102.  
  2103.     /**
  2104.      * Truncate statement
  2105.      *
  2106.      * Generates a platform-specific truncate string from the supplied data
  2107.      *
  2108.      * If the database does not support the truncate() command,
  2109.      * then this method maps to 'DELETE FROM table'
  2110.      *
  2111.      * @param   string  the table name
  2112.      * @return  string
  2113.      */
  2114.     protected function _truncate($table)
  2115.     {
  2116.         return 'TRUNCATE '.$table;
  2117.     }
  2118.  
  2119.     // --------------------------------------------------------------------
  2120.  
  2121.     /**
  2122.      * Get DELETE query string
  2123.      *
  2124.      * Compiles a delete query string and returns the sql
  2125.      *
  2126.      * @param   string  the table to delete from
  2127.      * @param   bool    TRUE: reset QB values; FALSE: leave QB values alone
  2128.      * @return  string
  2129.      */
  2130.     public function get_compiled_delete($table = '', $reset = TRUE)
  2131.     {
  2132.         $this->return_delete_sql = TRUE;
  2133.         $sql = $this->delete($table, '', NULL, $reset);
  2134.         $this->return_delete_sql = FALSE;
  2135.         return $sql;
  2136.     }
  2137.  
  2138.     // --------------------------------------------------------------------
  2139.  
  2140.     /**
  2141.      * Delete
  2142.      *
  2143.      * Compiles a delete string and runs the query
  2144.      *
  2145.      * @param   mixed   the table(s) to delete from. String or array
  2146.      * @param   mixed   the where clause
  2147.      * @param   mixed   the limit clause
  2148.      * @param   bool
  2149.      * @return  mixed
  2150.      */
  2151.     public function delete($table = '', $where = '', $limit = NULL, $reset_data = TRUE)
  2152.     {
  2153.         // Combine any cached components with the current statements
  2154.         $this->_merge_cache();
  2155.  
  2156.         if ($table === '')
  2157.         {
  2158.             if ( ! isset($this->qb_from[0]))
  2159.             {
  2160.                 return ($this->db_debug) ? $this->display_error('db_must_set_table') : FALSE;
  2161.             }
  2162.  
  2163.             $table = $this->qb_from[0];
  2164.         }
  2165.         elseif (is_array($table))
  2166.         {
  2167.             empty($where) && $reset_data = FALSE;
  2168.  
  2169.             foreach ($table as $single_table)
  2170.             {
  2171.                 $this->delete($single_table, $where, $limit, $reset_data);
  2172.             }
  2173.  
  2174.             return;
  2175.         }
  2176.         else
  2177.         {
  2178.             $table = $this->protect_identifiers($table, TRUE, NULL, FALSE);
  2179.         }
  2180.  
  2181.         if ($where !== '')
  2182.         {
  2183.             $this->where($where);
  2184.         }
  2185.  
  2186.         if ( ! empty($limit))
  2187.         {
  2188.             $this->limit($limit);
  2189.         }
  2190.  
  2191.         if (count($this->qb_where) === 0)
  2192.         {
  2193.             return ($this->db_debug) ? $this->display_error('db_del_must_use_where') : FALSE;
  2194.         }
  2195.  
  2196.         $sql = $this->_delete($table);
  2197.         if ($reset_data)
  2198.         {
  2199.             $this->_reset_write();
  2200.         }
  2201.  
  2202.         return ($this->return_delete_sql === TRUE) ? $sql : $this->query($sql);
  2203.     }
  2204.  
  2205.     // --------------------------------------------------------------------
  2206.  
  2207.     /**
  2208.      * Delete statement
  2209.      *
  2210.      * Generates a platform-specific delete string from the supplied data
  2211.      *
  2212.      * @param   string  the table name
  2213.      * @return  string
  2214.      */
  2215.     protected function _delete($table)
  2216.     {
  2217.         return 'DELETE FROM '.$table.$this->_compile_wh('qb_where')
  2218.             .($this->qb_limit !== FALSE ? ' LIMIT '.$this->qb_limit : '');
  2219.     }
  2220.  
  2221.     // --------------------------------------------------------------------
  2222.  
  2223.     /**
  2224.      * DB Prefix
  2225.      *
  2226.      * Prepends a database prefix if one exists in configuration
  2227.      *
  2228.      * @param   string  the table
  2229.      * @return  string
  2230.      */
  2231.     public function dbprefix($table = '')
  2232.     {
  2233.         if ($table === '')
  2234.         {
  2235.             $this->display_error('db_table_name_required');
  2236.         }
  2237.  
  2238.         return $this->dbprefix.$table;
  2239.     }
  2240.  
  2241.     // --------------------------------------------------------------------
  2242.  
  2243.     /**
  2244.      * Set DB Prefix
  2245.      *
  2246.      * Set's the DB Prefix to something new without needing to reconnect
  2247.      *
  2248.      * @param   string  the prefix
  2249.      * @return  string
  2250.      */
  2251.     public function set_dbprefix($prefix = '')
  2252.     {
  2253.         return $this->dbprefix = $prefix;
  2254.     }
  2255.  
  2256.     // --------------------------------------------------------------------
  2257.  
  2258.     /**
  2259.      * Track Aliases
  2260.      *
  2261.      * Used to track SQL statements written with aliased tables.
  2262.      *
  2263.      * @param   string  The table to inspect
  2264.      * @return  string
  2265.      */
  2266.     protected function _track_aliases($table)
  2267.     {
  2268.         if (is_array($table))
  2269.         {
  2270.             foreach ($table as $t)
  2271.             {
  2272.                 $this->_track_aliases($t);
  2273.             }
  2274.             return;
  2275.         }
  2276.  
  2277.         // Does the string contain a comma?  If so, we need to separate
  2278.         // the string into discreet statements
  2279.         if (strpos($table, ',') !== FALSE)
  2280.         {
  2281.             return $this->_track_aliases(explode(',', $table));
  2282.         }
  2283.  
  2284.         // if a table alias is used we can recognize it by a space
  2285.         if (strpos($table, ' ') !== FALSE)
  2286.         {
  2287.             // if the alias is written with the AS keyword, remove it
  2288.             $table = preg_replace('/\s+AS\s+/i', ' ', $table);
  2289.  
  2290.             // Grab the alias
  2291.             $table = trim(strrchr($table, ' '));
  2292.  
  2293.             // Store the alias, if it doesn't already exist
  2294.             if ( ! in_array($table, $this->qb_aliased_tables, TRUE))
  2295.             {
  2296.                 $this->qb_aliased_tables[] = $table;
  2297.                 if ($this->qb_caching === TRUE && ! in_array($table, $this->qb_cache_aliased_tables, TRUE))
  2298.                 {
  2299.                     $this->qb_cache_aliased_tables[] = $table;
  2300.                     $this->qb_cache_exists[] = 'aliased_tables';
  2301.                 }
  2302.             }
  2303.         }
  2304.     }
  2305.  
  2306.     // --------------------------------------------------------------------
  2307.  
  2308.     /**
  2309.      * Compile the SELECT statement
  2310.      *
  2311.      * Generates a query string based on which functions were used.
  2312.      * Should not be called directly.
  2313.      *
  2314.      * @param   bool    $select_override
  2315.      * @return  string
  2316.      */
  2317.     protected function _compile_select($select_override = FALSE)
  2318.     {
  2319.         // Combine any cached components with the current statements
  2320.         $this->_merge_cache();
  2321.  
  2322.         // Write the "select" portion of the query
  2323.         if ($select_override !== FALSE)
  2324.         {
  2325.             $sql = $select_override;
  2326.         }
  2327.         else
  2328.         {
  2329.             $sql = ( ! $this->qb_distinct) ? 'SELECT ' : 'SELECT DISTINCT ';
  2330.  
  2331.             if (count($this->qb_select) === 0)
  2332.             {
  2333.                 $sql .= '*';
  2334.             }
  2335.             else
  2336.             {
  2337.                 // Cycle through the "select" portion of the query and prep each column name.
  2338.                 // The reason we protect identifiers here rather than in the select() function
  2339.                 // is because until the user calls the from() function we don't know if there are aliases
  2340.                 foreach ($this->qb_select as $key => $val)
  2341.                 {
  2342.                     $no_escape = isset($this->qb_no_escape[$key]) ? $this->qb_no_escape[$key] : NULL;
  2343.                     $this->qb_select[$key] = $this->protect_identifiers($val, FALSE, $no_escape);
  2344.                 }
  2345.  
  2346.                 $sql .= implode(', ', $this->qb_select);
  2347.             }
  2348.         }
  2349.  
  2350.         // Write the "FROM" portion of the query
  2351.         if (count($this->qb_from) > 0)
  2352.         {
  2353.             $sql .= "\nFROM ".$this->_from_tables();
  2354.         }
  2355.  
  2356.         // Write the "JOIN" portion of the query
  2357.         if (count($this->qb_join) > 0)
  2358.         {
  2359.             $sql .= "\n".implode("\n", $this->qb_join);
  2360.         }
  2361.  
  2362.         $sql .= $this->_compile_wh('qb_where')
  2363.             .$this->_compile_group_by()
  2364.             .$this->_compile_wh('qb_having')
  2365.             .$this->_compile_order_by(); // ORDER BY
  2366.  
  2367.         // LIMIT
  2368.         if ($this->qb_limit !== FALSE OR $this->qb_offset)
  2369.         {
  2370.             return $this->_limit($sql."\n");
  2371.         }
  2372.  
  2373.         return $sql;
  2374.     }
  2375.  
  2376.     // --------------------------------------------------------------------
  2377.  
  2378.     /**
  2379.      * Compile WHERE, HAVING statements
  2380.      *
  2381.      * Escapes identifiers in WHERE and HAVING statements at execution time.
  2382.      *
  2383.      * Required so that aliases are tracked properly, regardless of whether
  2384.      * where(), or_where(), having(), or_having are called prior to from(),
  2385.      * join() and dbprefix is added only if needed.
  2386.      *
  2387.      * @param   string  $qb_key 'qb_where' or 'qb_having'
  2388.      * @return  string  SQL statement
  2389.      */
  2390.     protected function _compile_wh($qb_key)
  2391.     {
  2392.         if (count($this->$qb_key) > 0)
  2393.         {
  2394.             for ($i = 0, $c = count($this->$qb_key); $i < $c; $i++)
  2395.             {
  2396.                 // Is this condition already compiled?
  2397.                 if (is_string($this->{$qb_key}[$i]))
  2398.                 {
  2399.                     continue;
  2400.                 }
  2401.                 elseif ($this->{$qb_key}[$i]['escape'] === FALSE)
  2402.                 {
  2403.                     $this->{$qb_key}[$i] = $this->{$qb_key}[$i]['condition'].(isset($this->{$qb_key}[$i]['value']) ? ' '.$this->{$qb_key}[$i]['value'] : '');
  2404.                     continue;
  2405.                 }
  2406.  
  2407.                 // Split multiple conditions
  2408.                 $conditions = preg_split(
  2409.                     '/((?:^|\s+)AND\s+|(?:^|\s+)OR\s+)/i',
  2410.                     $this->{$qb_key}[$i]['condition'],
  2411.                     -1,
  2412.                     PREG_SPLIT_DELIM_CAPTURE | PREG_SPLIT_NO_EMPTY
  2413.                 );
  2414.  
  2415.                 for ($ci = 0, $cc = count($conditions); $ci < $cc; $ci++)
  2416.                 {
  2417.                     if (($op = $this->_get_operator($conditions[$ci])) === FALSE
  2418.                         OR ! preg_match('/^(\(?)(.*)('.preg_quote($op, '/').')\s*(.*(?<!\)))?(\)?)$/i', $conditions[$ci], $matches))
  2419.                     {
  2420.                         continue;
  2421.                     }
  2422.  
  2423.                     // $matches = array(
  2424.                     //  0 => '(test <= foo)',   /* the whole thing */
  2425.                     //  1 => '(',       /* optional */
  2426.                     //  2 => 'test',        /* the field name */
  2427.                     //  3 => ' <= ',        /* $op */
  2428.                     //  4 => 'foo',     /* optional, if $op is e.g. 'IS NULL' */
  2429.                     //  5 => ')'        /* optional */
  2430.                     // );
  2431.  
  2432.                     if ( ! empty($matches[4]))
  2433.                     {
  2434.                         $this->_is_literal($matches[4]) OR $matches[4] = $this->protect_identifiers(trim($matches[4]));
  2435.                         $matches[4] = ' '.$matches[4];
  2436.                     }
  2437.  
  2438.                     $conditions[$ci] = $matches[1].$this->protect_identifiers(trim($matches[2]))
  2439.                         .' '.trim($matches[3]).$matches[4].$matches[5];
  2440.                 }
  2441.  
  2442.                 $this->{$qb_key}[$i] = implode('', $conditions).(isset($this->{$qb_key}[$i]['value']) ? ' '.$this->{$qb_key}[$i]['value'] : '');
  2443.             }
  2444.  
  2445.             return ($qb_key === 'qb_having' ? "\nHAVING " : "\nWHERE ")
  2446.                 .implode("\n", $this->$qb_key);
  2447.         }
  2448.  
  2449.         return '';
  2450.     }
  2451.  
  2452.     // --------------------------------------------------------------------
  2453.  
  2454.     /**
  2455.      * Compile GROUP BY
  2456.      *
  2457.      * Escapes identifiers in GROUP BY statements at execution time.
  2458.      *
  2459.      * Required so that aliases are tracked properly, regardless of whether
  2460.      * group_by() is called prior to from(), join() and dbprefix is added
  2461.      * only if needed.
  2462.      *
  2463.      * @return  string  SQL statement
  2464.      */
  2465.     protected function _compile_group_by()
  2466.     {
  2467.         if (count($this->qb_groupby) > 0)
  2468.         {
  2469.             for ($i = 0, $c = count($this->qb_groupby); $i < $c; $i++)
  2470.             {
  2471.                 // Is it already compiled?
  2472.                 if (is_string($this->qb_groupby[$i]))
  2473.                 {
  2474.                     continue;
  2475.                 }
  2476.  
  2477.                 $this->qb_groupby[$i] = ($this->qb_groupby[$i]['escape'] === FALSE OR $this->_is_literal($this->qb_groupby[$i]['field']))
  2478.                     ? $this->qb_groupby[$i]['field']
  2479.                     : $this->protect_identifiers($this->qb_groupby[$i]['field']);
  2480.             }
  2481.  
  2482.             return "\nGROUP BY ".implode(', ', $this->qb_groupby);
  2483.         }
  2484.  
  2485.         return '';
  2486.     }
  2487.  
  2488.     // --------------------------------------------------------------------
  2489.  
  2490.     /**
  2491.      * Compile ORDER BY
  2492.      *
  2493.      * Escapes identifiers in ORDER BY statements at execution time.
  2494.      *
  2495.      * Required so that aliases are tracked properly, regardless of whether
  2496.      * order_by() is called prior to from(), join() and dbprefix is added
  2497.      * only if needed.
  2498.      *
  2499.      * @return  string  SQL statement
  2500.      */
  2501.     protected function _compile_order_by()
  2502.     {
  2503.         if (empty($this->qb_orderby))
  2504.         {
  2505.             return '';
  2506.         }
  2507.  
  2508.         for ($i = 0, $c = count($this->qb_orderby); $i < $c; $i++)
  2509.         {
  2510.             if (is_string($this->qb_orderby[$i]))
  2511.             {
  2512.                 continue;
  2513.             }
  2514.  
  2515.             if ($this->qb_orderby[$i]['escape'] !== FALSE && ! $this->_is_literal($this->qb_orderby[$i]['field']))
  2516.             {
  2517.                 $this->qb_orderby[$i]['field'] = $this->protect_identifiers($this->qb_orderby[$i]['field']);
  2518.             }
  2519.  
  2520.             $this->qb_orderby[$i] = $this->qb_orderby[$i]['field'].$this->qb_orderby[$i]['direction'];
  2521.         }
  2522.  
  2523.         return "\nORDER BY ".implode(', ', $this->qb_orderby);
  2524.     }
  2525.  
  2526.     // --------------------------------------------------------------------
  2527.  
  2528.     /**
  2529.      * Object to Array
  2530.      *
  2531.      * Takes an object as input and converts the class variables to array key/vals
  2532.      *
  2533.      * @param   object
  2534.      * @return  array
  2535.      */
  2536.     protected function _object_to_array($object)
  2537.     {
  2538.         if ( ! is_object($object))
  2539.         {
  2540.             return $object;
  2541.         }
  2542.  
  2543.         $array = array();
  2544.         foreach (get_object_vars($object) as $key => $val)
  2545.         {
  2546.             // There are some built in keys we need to ignore for this conversion
  2547.             if ( ! is_object($val) && ! is_array($val) && $key !== '_parent_name')
  2548.             {
  2549.                 $array[$key] = $val;
  2550.             }
  2551.         }
  2552.  
  2553.         return $array;
  2554.     }
  2555.  
  2556.     // --------------------------------------------------------------------
  2557.  
  2558.     /**
  2559.      * Object to Array
  2560.      *
  2561.      * Takes an object as input and converts the class variables to array key/vals
  2562.      *
  2563.      * @param   object
  2564.      * @return  array
  2565.      */
  2566.     protected function _object_to_array_batch($object)
  2567.     {
  2568.         if ( ! is_object($object))
  2569.         {
  2570.             return $object;
  2571.         }
  2572.  
  2573.         $array = array();
  2574.         $out = get_object_vars($object);
  2575.         $fields = array_keys($out);
  2576.  
  2577.         foreach ($fields as $val)
  2578.         {
  2579.             // There are some built in keys we need to ignore for this conversion
  2580.             if ($val !== '_parent_name')
  2581.             {
  2582.                 $i = 0;
  2583.                 foreach ($out[$val] as $data)
  2584.                 {
  2585.                     $array[$i++][$val] = $data;
  2586.                 }
  2587.             }
  2588.         }
  2589.  
  2590.         return $array;
  2591.     }
  2592.  
  2593.     // --------------------------------------------------------------------
  2594.  
  2595.     /**
  2596.      * Start Cache
  2597.      *
  2598.      * Starts QB caching
  2599.      *
  2600.      * @return  CI_DB_query_builder
  2601.      */
  2602.     public function start_cache()
  2603.     {
  2604.         $this->qb_caching = TRUE;
  2605.         return $this;
  2606.     }
  2607.  
  2608.     // --------------------------------------------------------------------
  2609.  
  2610.     /**
  2611.      * Stop Cache
  2612.      *
  2613.      * Stops QB caching
  2614.      *
  2615.      * @return  CI_DB_query_builder
  2616.      */
  2617.     public function stop_cache()
  2618.     {
  2619.         $this->qb_caching = FALSE;
  2620.         return $this;
  2621.     }
  2622.  
  2623.     // --------------------------------------------------------------------
  2624.  
  2625.     /**
  2626.      * Flush Cache
  2627.      *
  2628.      * Empties the QB cache
  2629.      *
  2630.      * @return  CI_DB_query_builder
  2631.      */
  2632.     public function flush_cache()
  2633.     {
  2634.         $this->_reset_run(array(
  2635.             'qb_cache_select'       => array(),
  2636.             'qb_cache_from'         => array(),
  2637.             'qb_cache_join'         => array(),
  2638.             'qb_cache_where'        => array(),
  2639.             'qb_cache_groupby'      => array(),
  2640.             'qb_cache_having'       => array(),
  2641.             'qb_cache_orderby'      => array(),
  2642.             'qb_cache_set'          => array(),
  2643.             'qb_cache_exists'       => array(),
  2644.             'qb_cache_no_escape'    => array(),
  2645.             'qb_cache_aliased_tables'   => array()
  2646.         ));
  2647.  
  2648.         return $this;
  2649.     }
  2650.  
  2651.     // --------------------------------------------------------------------
  2652.  
  2653.     /**
  2654.      * Merge Cache
  2655.      *
  2656.      * When called, this function merges any cached QB arrays with
  2657.      * locally called ones.
  2658.      *
  2659.      * @return  void
  2660.      */
  2661.     protected function _merge_cache()
  2662.     {
  2663.         if (count($this->qb_cache_exists) === 0)
  2664.         {
  2665.             return;
  2666.         }
  2667.         elseif (in_array('select', $this->qb_cache_exists, TRUE))
  2668.         {
  2669.             $qb_no_escape = $this->qb_cache_no_escape;
  2670.         }
  2671.  
  2672.         foreach (array_unique($this->qb_cache_exists) as $val) // select, from, etc.
  2673.         {
  2674.             $qb_variable    = 'qb_'.$val;
  2675.             $qb_cache_var   = 'qb_cache_'.$val;
  2676.             $qb_new     = $this->$qb_cache_var;
  2677.  
  2678.             for ($i = 0, $c = count($this->$qb_variable); $i < $c; $i++)
  2679.             {
  2680.                 if ( ! in_array($this->{$qb_variable}[$i], $qb_new, TRUE))
  2681.                 {
  2682.                     $qb_new[] = $this->{$qb_variable}[$i];
  2683.                     if ($val === 'select')
  2684.                     {
  2685.                         $qb_no_escape[] = $this->qb_no_escape[$i];
  2686.                     }
  2687.                 }
  2688.             }
  2689.  
  2690.             $this->$qb_variable = $qb_new;
  2691.             if ($val === 'select')
  2692.             {
  2693.                 $this->qb_no_escape = $qb_no_escape;
  2694.             }
  2695.         }
  2696.     }
  2697.  
  2698.     // --------------------------------------------------------------------
  2699.  
  2700.     /**
  2701.      * Is literal
  2702.      *
  2703.      * Determines if a string represents a literal value or a field name
  2704.      *
  2705.      * @param   string  $str
  2706.      * @return  bool
  2707.      */
  2708.     protected function _is_literal($str)
  2709.     {
  2710.         $str = trim($str);
  2711.  
  2712.         if (empty($str) OR ctype_digit($str) OR (string) (float) $str === $str OR in_array(strtoupper($str), array('TRUE', 'FALSE'), TRUE))
  2713.         {
  2714.             return TRUE;
  2715.         }
  2716.  
  2717.         static $_str;
  2718.  
  2719.         if (empty($_str))
  2720.         {
  2721.             $_str = ($this->_escape_char !== '"')
  2722.                 ? array('"', "'") : array("'");
  2723.         }
  2724.  
  2725.         return in_array($str[0], $_str, TRUE);
  2726.     }
  2727.  
  2728.     // --------------------------------------------------------------------
  2729.  
  2730.     /**
  2731.      * Reset Query Builder values.
  2732.      *
  2733.      * Publicly-visible method to reset the QB values.
  2734.      *
  2735.      * @return  CI_DB_query_builder
  2736.      */
  2737.     public function reset_query()
  2738.     {
  2739.         $this->_reset_select();
  2740.         $this->_reset_write();
  2741.         return $this;
  2742.     }
  2743.  
  2744.     // --------------------------------------------------------------------
  2745.  
  2746.     /**
  2747.      * Resets the query builder values.  Called by the get() function
  2748.      *
  2749.      * @param   array   An array of fields to reset
  2750.      * @return  void
  2751.      */
  2752.     protected function _reset_run($qb_reset_items)
  2753.     {
  2754.         foreach ($qb_reset_items as $item => $default_value)
  2755.         {
  2756.             $this->$item = $default_value;
  2757.         }
  2758.     }
  2759.  
  2760.     // --------------------------------------------------------------------
  2761.  
  2762.     /**
  2763.      * Resets the query builder values.  Called by the get() function
  2764.      *
  2765.      * @return  void
  2766.      */
  2767.     protected function _reset_select()
  2768.     {
  2769.         $this->_reset_run(array(
  2770.             'qb_select'     => array(),
  2771.             'qb_from'       => array(),
  2772.             'qb_join'       => array(),
  2773.             'qb_where'      => array(),
  2774.             'qb_groupby'        => array(),
  2775.             'qb_having'     => array(),
  2776.             'qb_orderby'        => array(),
  2777.             'qb_aliased_tables' => array(),
  2778.             'qb_no_escape'      => array(),
  2779.             'qb_distinct'       => FALSE,
  2780.             'qb_limit'      => FALSE,
  2781.             'qb_offset'     => FALSE
  2782.         ));
  2783.     }
  2784.  
  2785.     // --------------------------------------------------------------------
  2786.  
  2787.     /**
  2788.      * Resets the query builder "write" values.
  2789.      *
  2790.      * Called by the insert() update() insert_batch() update_batch() and delete() functions
  2791.      *
  2792.      * @return  void
  2793.      */
  2794.     protected function _reset_write()
  2795.     {
  2796.         $this->_reset_run(array(
  2797.             'qb_set'    => array(),
  2798.             'qb_set_ub' => array(),
  2799.             'qb_from'   => array(),
  2800.             'qb_join'   => array(),
  2801.             'qb_where'  => array(),
  2802.             'qb_orderby'    => array(),
  2803.             'qb_keys'   => array(),
  2804.             'qb_limit'  => FALSE
  2805.         ));
  2806.     }
  2807.  
  2808. }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!