database/DB_driver.php

   1 <?php  if ( ! defined('BASEPATH')) exit('No direct script access allowed');
   2 /**
   3  * CodeIgniter
   4  *
   5  * An open source application development framework for PHP 4.3.2 or newer
   6  *
   7  * @package             CodeIgniter
   8  * @author              ExpressionEngine Dev Team
   9  * @copyright   Copyright (c) 2008, EllisLab, Inc.
  10  * @license             http://codeigniter.com/user_guide/license.html
  11  * @link                http://codeigniter.com
  12  * @since               Version 1.0
  13  * @filesource
  14  */
  15
  16 // ------------------------------------------------------------------------
  17
  18 /**
  19  * Database Driver Class
  20  *
  21  * This is the platform-independent base DB implementation class.
  22  * This class will not be called directly. Rather, the adapter
  23  * class for the specific database will extend and instantiate it.
  24  *
  25  * @package             CodeIgniter
  26  * @subpackage  Drivers
  27  * @category    Database
  28  * @author              ExpressionEngine Dev Team
  29  * @link                http://codeigniter.com/user_guide/database/
  30  */
  31 class CI_DB_driver {
  32
  33         var $username;
  34         var $password;
  35         var $hostname;
  36         var $database;
  37         var $dbdriver           = 'mysql';
  38         var $dbprefix           = '';
  39         var $char_set           = 'utf8';
  40         var $dbcollat           = 'utf8_general_ci';
  41         var $autoinit           = TRUE; // Whether to automatically initialize the DB
  42         var $swap_pre           = '';
  43         var $port                       = '';
  44         var $pconnect           = FALSE;
  45         var $conn_id            = FALSE;
  46         var $result_id          = FALSE;
  47         var $db_debug           = FALSE;
  48         var $benchmark          = 0;
  49         var $query_count        = 0;
  50         var $bind_marker        = '?';
  51         var $save_queries       = TRUE;
  52         var $queries            = array();
  53         var $query_times        = array();
  54         var $data_cache         = array();
  55         var $trans_enabled      = TRUE;
  56         var $trans_strict       = TRUE;
  57         var $_trans_depth       = 0;
  58         var $_trans_status      = TRUE; // Used with transactions to determine if a rollback should occur
  59         var $cache_on           = FALSE;
  60         var $cachedir           = '';
  61         var $cache_autodel      = FALSE;
  62         var $CACHE; // The cache class object
  63
  64         // Private variables
  65         var $_protect_identifiers       = TRUE;
  66         var $_reserved_identifiers      = array('*'); // Identifiers that should NOT be escaped
  67
  68         // These are use with Oracle
  69         var $stmt_id;
  70         var $curs_id;
  71         var $limit_used;
  72
  73
  74
  75         /**
  76          * Constructor.  Accepts one parameter containing the database
  77          * connection settings.
  78          *
  79          * @param array
  80          */
  81         function CI_DB_driver($params)
  82         {
  83                 if (is_array($params))
  84                 {
  85                         foreach ($params as $key => $val)
  86                         {
  87                                 $this->$key = $val;
  88                         }
  89                 }
  90
  91                 log_message('debug', 'Database Driver Class Initialized');
  92         }
  93
  94         // --------------------------------------------------------------------
  95
  96         /**
  97          * Initialize Database Settings
  98          *
  99          * @access      private Called by the constructor
 100          * @param       mixed
 101          * @return      void
 102          */
 103         function initialize()
 104         {
 105                 // If an existing connection resource is available
 106                 // there is no need to connect and select the database
 107                 if (is_resource($this->conn_id) OR is_object($this->conn_id))
 108                 {
 109                         return TRUE;
 110                 }
 111
 112                 // ----------------------------------------------------------------
 113
 114                 // Connect to the database and set the connection ID
 115                 $this->conn_id = ($this->pconnect == FALSE) ? $this->db_connect() : $this->db_pconnect();
 116
 117                 // No connection resource?  Throw an error
 118                 if ( ! $this->conn_id)
 119                 {
 120                         log_message('error', 'Unable to connect to the database');
 121
 122                         if ($this->db_debug)
 123                         {
 124                                 $this->display_error('db_unable_to_connect');
 125                         }
 126                         return FALSE;
 127                 }
 128
 129                 // ----------------------------------------------------------------
 130
 131                 // Select the DB... assuming a database name is specified in the config file
 132                 if ($this->database != '')
 133                 {
 134                         if ( ! $this->db_select())
 135                         {
 136                                 log_message('error', 'Unable to select database: '.$this->database);
 137
 138                                 if ($this->db_debug)
 139                                 {
 140                                         $this->display_error('db_unable_to_select', $this->database);
 141                                 }
 142                                 return FALSE;
 143                         }
 144                         else
 145                         {
 146                                 // We've selected the DB. Now we set the character set
 147                                 if ( ! $this->db_set_charset($this->char_set, $this->dbcollat))
 148                                 {
 149                                         return FALSE;
 150                                 }
 151
 152                                 return TRUE;
 153                         }
 154                 }
 155
 156                 return TRUE;
 157         }
 158
 159         // --------------------------------------------------------------------
 160
 161         /**
 162          * Set client character set
 163          *
 164          * @access      public
 165          * @param       string
 166          * @param       string
 167          * @return      resource
 168          */
 169         function db_set_charset($charset, $collation)
 170         {
 171                 if ( ! $this->_db_set_charset($this->char_set, $this->dbcollat))
 172                 {
 173                         log_message('error', 'Unable to set database connection charset: '.$this->char_set);
 174
 175                         if ($this->db_debug)
 176                         {
 177                                 $this->display_error('db_unable_to_set_charset', $this->char_set);
 178                         }
 179
 180                         return FALSE;
 181                 }
 182
 183                 return TRUE;
 184         }
 185
 186         // --------------------------------------------------------------------
 187
 188         /**
 189          * The name of the platform in use (mysql, mssql, etc...)
 190          *
 191          * @access      public
 192          * @return      string
 193          */
 194         function platform()
 195         {
 196                 return $this->dbdriver;
 197         }
 198
 199         // --------------------------------------------------------------------
 200
 201         /**
 202          * Database Version Number.  Returns a string containing the
 203          * version of the database being used
 204          *
 205          * @access      public
 206          * @return      string
 207          */
 208         function version()
 209         {
 210                 if (FALSE === ($sql = $this->_version()))
 211                 {
 212                         if ($this->db_debug)
 213                         {
 214                                 return $this->display_error('db_unsupported_function');
 215                         }
 216                         return FALSE;
 217                 }
 218
 219                 if ($this->dbdriver == 'oci8')
 220                 {
 221                         return $sql;
 222                 }
 223
 224                 $query = $this->query($sql);
 225                 return $query->row('ver');
 226         }
 227
 228         // --------------------------------------------------------------------
 229
 230         /**
 231          * Execute the query
 232          *
 233          * Accepts an SQL string as input and returns a result object upon
 234          * successful execution of a "read" type query.  Returns boolean TRUE
 235          * upon successful execution of a "write" type query. Returns boolean
 236          * FALSE upon failure, and if the $db_debug variable is set to TRUE
 237          * will raise an error.
 238          *
 239          * @access      public
 240          * @param       string  An SQL query string
 241          * @param       array   An array of binding data
 242          * @return      mixed
 243          */
 244         function query($sql, $binds = FALSE, $return_object = TRUE)
 245         {
 246                 if ($sql == '')
 247                 {
 248                         if ($this->db_debug)
 249                         {
 250                                 log_message('error', 'Invalid query: '.$sql);
 251                                 return $this->display_error('db_invalid_query');
 252                         }
 253                         return FALSE;
 254                 }
 255
 256                 // Verify table prefix and replace if necessary
 257                 if ( ($this->dbprefix != '' AND $this->swap_pre != '') AND ($this->dbprefix != $this->swap_pre) )
 258                 {
 259                         $sql = preg_replace("/(\W)".$this->swap_pre."(\S+?)/", "\\1".$this->dbprefix."\\2", $sql);
 260                 }
 261
 262                 // Is query caching enabled?  If the query is a "read type"
 263                 // we will load the caching class and return the previously
 264                 // cached query if it exists
 265                 if ($this->cache_on == TRUE AND stristr($sql, 'SELECT'))
 266                 {
 267                         if ($this->_cache_init())
 268                         {
 269                                 $this->load_rdriver();
 270                                 if (FALSE !== ($cache = $this->CACHE->read($sql)))
 271                                 {
 272                                         return $cache;
 273                                 }
 274                         }
 275                 }
 276
 277                 // Compile binds if needed
 278                 if ($binds !== FALSE)
 279                 {
 280                         $sql = $this->compile_binds($sql, $binds);
 281                 }
 282
 283                 // Save the  query for debugging
 284                 if ($this->save_queries == TRUE)
 285                 {
 286                         $this->queries[] = $sql;
 287                 }
 288
 289                 // Start the Query Timer
 290                 $time_start = list($sm, $ss) = explode(' ', microtime());
 291
 292                 // Run the Query
 293                 if (FALSE === ($this->result_id = $this->simple_query($sql)))
 294                 {
 295                         if ($this->save_queries == TRUE)
 296                         {
 297                                 $this->query_times[] = 0;
 298                         }
 299
 300                         // This will trigger a rollback if transactions are being used
 301                         $this->_trans_status = FALSE;
 302
 303                         if ($this->db_debug)
 304                         {
 305                                 // grab the error number and message now, as we might run some
 306                                 // additional queries before displaying the error
 307                                 $error_no = $this->_error_number();
 308                                 $error_msg = $this->_error_message();
 309
 310                                 // We call this function in order to roll-back queries
 311                                 // if transactions are enabled.  If we don't call this here
 312                                 // the error message will trigger an exit, causing the
 313                                 // transactions to remain in limbo.
 314                                 $this->trans_complete();
 315
 316                                 // Log and display errors
 317                                 log_message('error', 'Query error: '.$error_msg);
 318                                 return $this->display_error(
 319                                                                                 array(
 320                                                                                                 'Error Number: '.$error_no,
 321                                                                                                 $error_msg,
 322                                                                                                 $sql
 323                                                                                         )
 324                                                                                 );
 325                         }
 326
 327                         return FALSE;
 328                 }
 329
 330                 // Stop and aggregate the query time results
 331                 $time_end = list($em, $es) = explode(' ', microtime());
 332                 $this->benchmark += ($em + $es) - ($sm + $ss);
 333
 334                 if ($this->save_queries == TRUE)
 335                 {
 336                         $this->query_times[] = ($em + $es) - ($sm + $ss);
 337                 }
 338
 339                 // Increment the query counter
 340                 $this->query_count++;
 341
 342                 // Was the query a "write" type?
 343                 // If so we'll simply return true
 344                 if ($this->is_write_type($sql) === TRUE)
 345                 {
 346                         // If caching is enabled we'll auto-cleanup any
 347                         // existing files related to this particular URI
 348                         if ($this->cache_on == TRUE AND $this->cache_autodel == TRUE AND $this->_cache_init())
 349                         {
 350                                 $this->CACHE->delete();
 351                         }
 352
 353                         return TRUE;
 354                 }
 355
 356                 // Return TRUE if we don't need to create a result object
 357                 // Currently only the Oracle driver uses this when stored
 358                 // procedures are used
 359                 if ($return_object !== TRUE)
 360                 {
 361                         return TRUE;
 362                 }
 363
 364                 // Load and instantiate the result driver
 365
 366                 $driver                 = $this->load_rdriver();
 367                 $RES                    = new $driver();
 368                 $RES->conn_id   = $this->conn_id;
 369                 $RES->result_id = $this->result_id;
 370
 371                 if ($this->dbdriver == 'oci8')
 372                 {
 373                         $RES->stmt_id           = $this->stmt_id;
 374                         $RES->curs_id           = NULL;
 375                         $RES->limit_used        = $this->limit_used;
 376                         $this->stmt_id          = FALSE;
 377                 }
 378
 379                 // oci8 vars must be set before calling this
 380                 $RES->num_rows  = $RES->num_rows();
 381
 382                 // Is query caching enabled?  If so, we'll serialize the
 383                 // result object and save it to a cache file.
 384                 if ($this->cache_on == TRUE AND $this->_cache_init())
 385                 {
 386                         // We'll create a new instance of the result object
 387                         // only without the platform specific driver since
 388                         // we can't use it with cached data (the query result
 389                         // resource ID won't be any good once we've cached the
 390                         // result object, so we'll have to compile the data
 391                         // and save it)
 392                         $CR = new CI_DB_result();
 393                         $CR->num_rows           = $RES->num_rows();
 394                         $CR->result_object      = $RES->result_object();
 395                         $CR->result_array       = $RES->result_array();
 396
 397                         // Reset these since cached objects can not utilize resource IDs.
 398                         $CR->conn_id            = NULL;
 399                         $CR->result_id          = NULL;
 400
 401                         $this->CACHE->write($sql, $CR);
 402                 }
 403
 404                 return $RES;
 405         }
 406
 407         // --------------------------------------------------------------------
 408
 409         /**
 410          * Load the result drivers
 411          *
 412          * @access      public
 413          * @return      string  the name of the result class
 414          */
 415         function load_rdriver()
 416         {
 417                 $driver = 'CI_DB_'.$this->dbdriver.'_result';
 418
 419                 if ( ! class_exists($driver))
 420                 {
 421                         include_once(BASEPATH.'database/DB_result'.EXT);
 422                         include_once(BASEPATH.'database/drivers/'.$this->dbdriver.'/'.$this->dbdriver.'_result'.EXT);
 423                 }
 424
 425                 return $driver;
 426         }
 427
 428         // --------------------------------------------------------------------
 429
 430         /**
 431          * Simple Query
 432          * This is a simplified version of the query() function.  Internally
 433          * we only use it when running transaction commands since they do
 434          * not require all the features of the main query() function.
 435          *
 436          * @access      public
 437          * @param       string  the sql query
 438          * @return      mixed
 439          */
 440         function simple_query($sql)
 441         {
 442                 if ( ! $this->conn_id)
 443                 {
 444                         $this->initialize();
 445                 }
 446
 447                 return $this->_execute($sql);
 448         }
 449
 450         // --------------------------------------------------------------------
 451
 452         /**
 453          * Disable Transactions
 454          * This permits transactions to be disabled at run-time.
 455          *
 456          * @access      public
 457          * @return      void
 458          */
 459         function trans_off()
 460         {
 461                 $this->trans_enabled = FALSE;
 462         }
 463
 464         // --------------------------------------------------------------------
 465
 466         /**
 467          * Enable/disable Transaction Strict Mode
 468          * When strict mode is enabled, if you are running multiple groups of
 469          * transactions, if one group fails all groups will be rolled back.
 470          * If strict mode is disabled, each group is treated autonomously, meaning
 471          * a failure of one group will not affect any others
 472          *
 473          * @access      public
 474          * @return      void
 475          */
 476         function trans_strict($mode = TRUE)
 477         {
 478                 $this->trans_strict = is_bool($mode) ? $mode : TRUE;
 479         }
 480
 481         // --------------------------------------------------------------------
 482
 483         /**
 484          * Start Transaction
 485          *
 486          * @access      public
 487          * @return      void
 488          */
 489         function trans_start($test_mode = FALSE)
 490         {
 491                 if ( ! $this->trans_enabled)
 492                 {
 493                         return FALSE;
 494                 }
 495
 496                 // When transactions are nested we only begin/commit/rollback the outermost ones
 497                 if ($this->_trans_depth > 0)
 498                 {
 499                         $this->_trans_depth += 1;
 500                         return;
 501                 }
 502
 503                 $this->trans_begin($test_mode);
 504         }
 505
 506         // --------------------------------------------------------------------
 507
 508         /**
 509          * Complete Transaction
 510          *
 511          * @access      public
 512          * @return      bool
 513          */
 514         function trans_complete()
 515         {
 516                 if ( ! $this->trans_enabled)
 517                 {
 518                         return FALSE;
 519                 }
 520
 521                 // When transactions are nested we only begin/commit/rollback the outermost ones
 522                 if ($this->_trans_depth > 1)
 523                 {
 524                         $this->_trans_depth -= 1;
 525                         return TRUE;
 526                 }
 527
 528                 // The query() function will set this flag to FALSE in the event that a query failed
 529                 if ($this->_trans_status === FALSE)
 530                 {
 531                         $this->trans_rollback();
 532
 533                         // If we are NOT running in strict mode, we will reset
 534                         // the _trans_status flag so that subsequent groups of transactions
 535                         // will be permitted.
 536                         if ($this->trans_strict === FALSE)
 537                         {
 538                                 $this->_trans_status = TRUE;
 539                         }
 540
 541                         log_message('debug', 'DB Transaction Failure');
 542                         return FALSE;
 543                 }
 544
 545                 $this->trans_commit();
 546                 return TRUE;
 547         }
 548
 549         // --------------------------------------------------------------------
 550
 551         /**
 552          * Lets you retrieve the transaction flag to determine if it has failed
 553          *
 554          * @access      public
 555          * @return      bool
 556          */
 557         function trans_status()
 558         {
 559                 return $this->_trans_status;
 560         }
 561
 562         // --------------------------------------------------------------------
 563
 564         /**
 565          * Compile Bindings
 566          *
 567          * @access      public
 568          * @param       string  the sql statement
 569          * @param       array   an array of bind data
 570          * @return      string
 571          */
 572         function compile_binds($sql, $binds)
 573         {
 574                 if (strpos($sql, $this->bind_marker) === FALSE)
 575                 {
 576                         return $sql;
 577                 }
 578
 579                 if ( ! is_array($binds))
 580                 {
 581                         $binds = array($binds);
 582                 }
 583
 584                 // Get the sql segments around the bind markers
 585                 $segments = explode($this->bind_marker, $sql);
 586
 587                 // The count of bind should be 1 less then the count of segments
 588                 // If there are more bind arguments trim it down
 589                 if (count($binds) >= count($segments)) {
 590                         $binds = array_slice($binds, 0, count($segments)-1);
 591                 }
 592
 593                 // Construct the binded query
 594                 $result = $segments[0];
 595                 $i = 0;
 596                 foreach ($binds as $bind)
 597                 {
 598                         $result .= $this->escape($bind);
 599                         $result .= $segments[++$i];
 600                 }
 601
 602                 return $result;
 603         }
 604
 605         // --------------------------------------------------------------------
 606
 607         /**
 608          * Determines if a query is a "write" type.
 609          *
 610          * @access      public
 611          * @param       string  An SQL query string
 612          * @return      boolean
 613          */
 614         function is_write_type($sql)
 615         {
 616                 if ( ! preg_match('/^\s*"?(SET|INSERT|UPDATE|DELETE|REPLACE|CREATE|DROP|LOAD DATA|COPY|ALTER|GRANT|REVOKE|LOCK|UNLOCK)\s+/i', $sql))
 617                 {
 618                         return FALSE;
 619                 }
 620                 return TRUE;
 621         }
 622
 623         // --------------------------------------------------------------------
 624
 625         /**
 626          * Calculate the aggregate query elapsed time
 627          *
 628          * @access      public
 629          * @param       integer The number of decimal places
 630          * @return      integer
 631          */
 632         function elapsed_time($decimals = 6)
 633         {
 634                 return number_format($this->benchmark, $decimals);
 635         }
 636
 637         // --------------------------------------------------------------------
 638
 639         /**
 640          * Returns the total number of queries
 641          *
 642          * @access      public
 643          * @return      integer
 644          */
 645         function total_queries()
 646         {
 647                 return $this->query_count;
 648         }
 649
 650         // --------------------------------------------------------------------
 651
 652         /**
 653          * Returns the last query that was executed
 654          *
 655          * @access      public
 656          * @return      void
 657          */
 658         function last_query()
 659         {
 660                 return end($this->queries);
 661         }
 662
 663         // --------------------------------------------------------------------
 664
 665         /**
 666          * "Smart" Escape String
 667          *
 668          * Escapes data based on type
 669          * Sets boolean and null types
 670          *
 671          * @access      public
 672          * @param       string
 673          * @return      integer
 674          */
 675         function escape($str)
 676         {
 677                 switch (gettype($str))
 678                 {
 679                         case 'string'   :       $str = "'".$this->escape_str($str)."'";
 680                                 break;
 681                         case 'boolean'  :       $str = ($str === FALSE) ? 0 : 1;
 682                                 break;
 683                         default                 :       $str = ($str === NULL) ? 'NULL' : $str;
 684                                 break;
 685                 }
 686
 687                 return $str;
 688         }
 689
 690         // --------------------------------------------------------------------
 691
 692         /**
 693          * Primary
 694          *
 695          * Retrieves the primary key.  It assumes that the row in the first
 696          * position is the primary key
 697          *
 698          * @access      public
 699          * @param       string  the table name
 700          * @return      string
 701          */
 702         function primary($table = '')
 703         {
 704                 $fields = $this->list_fields($table);
 705
 706                 if ( ! is_array($fields))
 707                 {
 708                         return FALSE;
 709                 }
 710
 711                 return current($fields);
 712         }
 713
 714         // --------------------------------------------------------------------
 715
 716         /**
 717          * Returns an array of table names
 718          *
 719          * @access      public
 720          * @return      array
 721          */
 722         function list_tables($constrain_by_prefix = FALSE)
 723         {
 724                 // Is there a cached result?
 725                 if (isset($this->data_cache['table_names']))
 726                 {
 727                         return $this->data_cache['table_names'];
 728                 }
 729
 730                 if (FALSE === ($sql = $this->_list_tables($constrain_by_prefix)))
 731                 {
 732                         if ($this->db_debug)
 733                         {
 734                                 return $this->display_error('db_unsupported_function');
 735                         }
 736                         return FALSE;
 737                 }
 738
 739                 $retval = array();
 740                 $query = $this->query($sql);
 741
 742                 if ($query->num_rows() > 0)
 743                 {
 744                         foreach($query->result_array() as $row)
 745                         {
 746                                 if (isset($row['TABLE_NAME']))
 747                                 {
 748                                         $retval[] = $row['TABLE_NAME'];
 749                                 }
 750                                 else
 751                                 {
 752                                         $retval[] = array_shift($row);
 753                                 }
 754                         }
 755                 }
 756
 757                 $this->data_cache['table_names'] = $retval;
 758                 return $this->data_cache['table_names'];
 759         }
 760
 761         // --------------------------------------------------------------------
 762
 763         /**
 764          * Determine if a particular table exists
 765          * @access      public
 766          * @return      boolean
 767          */
 768         function table_exists($table_name)
 769         {
 770                 return ( ! in_array($this->_protect_identifiers($table_name, TRUE, FALSE, FALSE), $this->list_tables())) ? FALSE : TRUE;
 771         }
 772
 773         // --------------------------------------------------------------------
 774
 775         /**
 776          * Fetch MySQL Field Names
 777          *
 778          * @access      public
 779          * @param       string  the table name
 780          * @return      array
 781          */
 782         function list_fields($table = '')
 783         {
 784                 // Is there a cached result?
 785                 if (isset($this->data_cache['field_names'][$table]))
 786                 {
 787                         return $this->data_cache['field_names'][$table];
 788                 }
 789
 790                 if ($table == '')
 791                 {
 792                         if ($this->db_debug)
 793                         {
 794                                 return $this->display_error('db_field_param_missing');
 795                         }
 796                         return FALSE;
 797                 }
 798
 799                 if (FALSE === ($sql = $this->_list_columns($this->_protect_identifiers($table, TRUE, NULL, FALSE))))
 800                 {
 801                         if ($this->db_debug)
 802                         {
 803                                 return $this->display_error('db_unsupported_function');
 804                         }
 805                         return FALSE;
 806                 }
 807
 808                 $query = $this->query($sql);
 809
 810                 $retval = array();
 811                 foreach($query->result_array() as $row)
 812                 {
 813                         if (isset($row['COLUMN_NAME']))
 814                         {
 815                                 $retval[] = $row['COLUMN_NAME'];
 816                         }
 817                         else
 818                         {
 819                                 $retval[] = current($row);
 820                         }
 821                 }
 822
 823                 $this->data_cache['field_names'][$table] = $retval;
 824                 return $this->data_cache['field_names'][$table];
 825         }
 826
 827         // --------------------------------------------------------------------
 828
 829         /**
 830          * Determine if a particular field exists
 831          * @access      public
 832          * @param       string
 833          * @param       string
 834          * @return      boolean
 835          */
 836         function field_exists($field_name, $table_name)
 837         {
 838                 return ( ! in_array($field_name, $this->list_fields($table_name))) ? FALSE : TRUE;
 839         }
 840
 841         // --------------------------------------------------------------------
 842
 843         /**
 844          * Returns an object with field data
 845          *
 846          * @access      public
 847          * @param       string  the table name
 848          * @return      object
 849          */
 850         function field_data($table = '')
 851         {
 852                 if ($table == '')
 853                 {
 854                         if ($this->db_debug)
 855                         {
 856                                 return $this->display_error('db_field_param_missing');
 857                         }
 858                         return FALSE;
 859                 }
 860
 861                 $query = $this->query($this->_field_data($this->_protect_identifiers($table, TRUE, NULL, FALSE)));
 862
 863                 return $query->field_data();
 864         }
 865
 866         // --------------------------------------------------------------------
 867
 868         /**
 869          * Generate an insert string
 870          *
 871          * @access      public
 872          * @param       string  the table upon which the query will be performed
 873          * @param       array   an associative array data of key/values
 874          * @return      string
 875          */
 876         function insert_string($table, $data)
 877         {
 878                 $fields = array();
 879                 $values = array();
 880
 881                 foreach($data as $key => $val)
 882                 {
 883                         $fields[] = $this->_escape_identifiers($key);
 884                         $values[] = $this->escape($val);
 885                 }
 886
 887                 return $this->_insert($this->_protect_identifiers($table, TRUE, NULL, FALSE), $fields, $values);
 888         }
 889
 890         // --------------------------------------------------------------------
 891
 892         /**
 893          * Generate an update string
 894          *
 895          * @access      public
 896          * @param       string  the table upon which the query will be performed
 897          * @param       array   an associative array data of key/values
 898          * @param       mixed   the "where" statement
 899          * @return      string
 900          */
 901         function update_string($table, $data, $where)
 902         {
 903                 if ($where == '')
 904                 {
 905                         return false;
 906                 }
 907
 908                 $fields = array();
 909                 foreach($data as $key => $val)
 910                 {
 911                         $fields[$this->_protect_identifiers($key)] = $this->escape($val);
 912                 }
 913
 914                 if ( ! is_array($where))
 915                 {
 916                         $dest = array($where);
 917                 }
 918                 else
 919                 {
 920                         $dest = array();
 921                         foreach ($where as $key => $val)
 922                         {
 923                                 $prefix = (count($dest) == 0) ? '' : ' AND ';
 924
 925                                 if ($val !== '')
 926                                 {
 927                                         if ( ! $this->_has_operator($key))
 928                                         {
 929                                                 $key .= ' =';
 930                                         }
 931
 932                                         $val = ' '.$this->escape($val);
 933                                 }
 934
 935                                 $dest[] = $prefix.$key.$val;
 936                         }
 937                 }
 938
 939                 return $this->_update($this->_protect_identifiers($table, TRUE, NULL, FALSE), $fields, $dest);
 940         }
 941
 942         // --------------------------------------------------------------------
 943
 944         /**
 945          * Tests whether the string has an SQL operator
 946          *
 947          * @access      private
 948          * @param       string
 949          * @return      bool
 950          */
 951         function _has_operator($str)
 952         {
 953                 $str = trim($str);
 954                 if ( ! preg_match("/(\s|<|>|!|=|is null|is not null)/i", $str))
 955                 {
 956                         return FALSE;
 957                 }
 958
 959                 return TRUE;
 960         }
 961
 962         // --------------------------------------------------------------------
 963
 964         /**
 965          * Enables a native PHP function to be run, using a platform agnostic wrapper.
 966          *
 967          * @access      public
 968          * @param       string  the function name
 969          * @param       mixed   any parameters needed by the function
 970          * @return      mixed
 971          */
 972         function call_function($function)
 973         {
 974                 $driver = ($this->dbdriver == 'postgre') ? 'pg_' : $this->dbdriver.'_';
 975
 976                 if (FALSE === strpos($driver, $function))
 977                 {
 978                         $function = $driver.$function;
 979                 }
 980
 981                 if ( ! function_exists($function))
 982                 {
 983                         if ($this->db_debug)
 984                         {
 985                                 return $this->display_error('db_unsupported_function');
 986                         }
 987                         return FALSE;
 988                 }
 989                 else
 990                 {
 991                         $args = (func_num_args() > 1) ? array_splice(func_get_args(), 1) : null;
 992
 993                         return call_user_func_array($function, $args);
 994                 }
 995         }
 996
 997         // --------------------------------------------------------------------
 998
 999         /**
1000          * Set Cache Directory Path
1001          *
1002          * @access      public
1003          * @param       string  the path to the cache directory
1004          * @return      void
1005          */
1006         function cache_set_path($path = '')
1007         {
1008                 $this->cachedir = $path;
1009         }
1010
1011         // --------------------------------------------------------------------
1012
1013         /**
1014          * Enable Query Caching
1015          *
1016          * @access      public
1017          * @return      void
1018          */
1019         function cache_on()
1020         {
1021                 $this->cache_on = TRUE;
1022                 return TRUE;
1023         }
1024
1025         // --------------------------------------------------------------------
1026
1027         /**
1028          * Disable Query Caching
1029          *
1030          * @access      public
1031          * @return      void
1032          */
1033         function cache_off()
1034         {
1035                 $this->cache_on = FALSE;
1036                 return FALSE;
1037         }
1038
1039
1040         // --------------------------------------------------------------------
1041
1042         /**
1043          * Delete the cache files associated with a particular URI
1044          *
1045          * @access      public
1046          * @return      void
1047          */
1048         function cache_delete($segment_one = '', $segment_two = '')
1049         {
1050                 if ( ! $this->_cache_init())
1051                 {
1052                         return FALSE;
1053                 }
1054                 return $this->CACHE->delete($segment_one, $segment_two);
1055         }
1056
1057         // --------------------------------------------------------------------
1058
1059         /**
1060          * Delete All cache files
1061          *
1062          * @access      public
1063          * @return      void
1064          */
1065         function cache_delete_all()
1066         {
1067                 if ( ! $this->_cache_init())
1068                 {
1069                         return FALSE;
1070                 }
1071
1072                 return $this->CACHE->delete_all();
1073         }
1074
1075         // --------------------------------------------------------------------
1076
1077         /**
1078          * Initialize the Cache Class
1079          *
1080          * @access      private
1081          * @return      void
1082          */
1083         function _cache_init()
1084         {
1085                 if (is_object($this->CACHE) AND class_exists('CI_DB_Cache'))
1086                 {
1087                         return TRUE;
1088                 }
1089
1090                 if ( ! @include(BASEPATH.'database/DB_cache'.EXT))
1091                 {
1092                         return $this->cache_off();
1093                 }
1094
1095                 $this->CACHE = new CI_DB_Cache($this); // pass db object to support multiple db connections and returned db objects
1096                 return TRUE;
1097         }
1098
1099         // --------------------------------------------------------------------
1100
1101         /**
1102          * Close DB Connection
1103          *
1104          * @access      public
1105          * @return      void
1106          */
1107         function close()
1108         {
1109                 if (is_resource($this->conn_id) OR is_object($this->conn_id))
1110                 {
1111                         $this->_close($this->conn_id);
1112                 }
1113                 $this->conn_id = FALSE;
1114         }
1115
1116         // --------------------------------------------------------------------
1117
1118         /**
1119          * Display an error message
1120          *
1121          * @access      public
1122          * @param       string  the error message
1123          * @param       string  any "swap" values
1124          * @param       boolean whether to localize the message
1125          * @return      string  sends the application/error_db.php template
1126          */
1127         function display_error($error = '', $swap = '', $native = FALSE)
1128         {
1129                 $LANG =& load_class('Language');
1130                 $LANG->load('db');
1131
1132                 $heading = $LANG->line('db_error_heading');
1133
1134                 if ($native == TRUE)
1135                 {
1136                         $message = $error;
1137                 }
1138                 else
1139                 {
1140                         $message = ( ! is_array($error)) ? array(str_replace('%s', $swap, $LANG->line($error))) : $error;
1141                 }
1142
1143                 $error =& load_class('Exceptions');
1144                 echo $error->show_error($heading, $message, 'error_db');
1145                 exit;
1146         }
1147
1148         // --------------------------------------------------------------------
1149
1150         /**
1151          * Protect Identifiers
1152          *
1153          * This function adds backticks if appropriate based on db type
1154          *
1155          * @access      private
1156          * @param       mixed   the item to escape
1157          * @return      mixed   the item with backticks
1158          */
1159         function protect_identifiers($item, $prefix_single = FALSE)
1160         {
1161                 return $this->_protect_identifiers($item, $prefix_single);
1162         }
1163
1164         // --------------------------------------------------------------------
1165
1166         /**
1167          * Protect Identifiers
1168          *
1169          * This function is used extensively by the Active Record class, and by
1170          * a couple functions in this class.
1171          * It takes a column or table name (optionally with an alias) and inserts
1172          * the table prefix onto it.  Some logic is necessary in order to deal with
1173          * column names that include the path.  Consider a query like this:
1174          *
1175          * SELECT * FROM hostname.database.table.column AS c FROM hostname.database.table
1176          *
1177          * Or a query with aliasing:
1178          *
1179          * SELECT m.member_id, m.member_name FROM members AS m
1180          *
1181          * Since the column name can include up to four segments (host, DB, table, column)
1182          * or also have an alias prefix, we need to do a bit of work to figure this out and
1183          * insert the table prefix (if it exists) in the proper position, and escape only
1184          * the correct identifiers.
1185          *
1186          * @access      private
1187          * @param       string
1188          * @param       bool
1189          * @param       mixed
1190          * @param       bool
1191          * @return      string
1192          */
1193         function _protect_identifiers($item, $prefix_single = FALSE, $protect_identifiers = NULL, $field_exists = TRUE)
1194         {
1195                 if ( ! is_bool($protect_identifiers))
1196                 {
1197                         $protect_identifiers = $this->_protect_identifiers;
1198                 }
1199
1200                 // Convert tabs or multiple spaces into single spaces
1201                 $item = preg_replace('/[\t| ]+/', ' ', $item);
1202
1203                 // If the item has an alias declaration we remove it and set it aside.
1204                 // Basically we remove everything to the right of the first space
1205                 $alias = '';
1206                 if (strpos($item, ' ') !== FALSE)
1207                 {
1208                         $alias = strstr($item, " ");
1209                         $item = substr($item, 0, - strlen($alias));
1210                 }
1211
1212                 // Break the string apart if it contains periods, then insert the table prefix
1213                 // in the correct location, assuming the period doesn't indicate that we're dealing
1214                 // with an alias. While we're at it, we will escape the components
1215                 if (strpos($item, '.') !== FALSE)
1216                 {
1217                         $parts  = explode('.', $item);
1218
1219                         // Does the first segment of the exploded item match
1220                         // one of the aliases previously identified?  If so,
1221                         // we have nothing more to do other then escape the item
1222                         if (in_array($parts[0], $this->ar_aliased_tables))
1223                         {
1224                                 if ($protect_identifiers === TRUE)
1225                                 {
1226                                         foreach ($parts as $key => $val)
1227                                         {
1228                                                 if ( ! in_array($val, $this->_reserved_identifiers))
1229                                                 {
1230                                                         $parts[$key] = $this->_escape_identifiers($val);
1231                                                 }
1232                                         }
1233
1234                                         $item = implode('.', $parts);
1235                                 }
1236                                 return $item.$alias;
1237                         }
1238
1239                         // Is there a table prefix defined in the config file?  If not, no need to do anything
1240                         if ($this->dbprefix != '')
1241                         {
1242                                 // We now add the table prefix based on some logic.
1243                                 // Do we have 4 segments (hostname.database.table.column)?
1244                                 // If so, we add the table prefix to the column name in the 3rd segment.
1245                                 if (isset($parts[3]))
1246                                 {
1247                                         $i = 2;
1248                                 }
1249                                 // Do we have 3 segments (database.table.column)?
1250                                 // If so, we add the table prefix to the column name in 2nd position
1251                                 elseif (isset($parts[2]))
1252                                 {
1253                                         $i = 1;
1254                                 }
1255                                 // Do we have 2 segments (table.column)?
1256                                 // If so, we add the table prefix to the column name in 1st segment
1257                                 else
1258                                 {
1259                                         $i = 0;
1260                                 }
1261
1262                                 // This flag is set when the supplied $item does not contain a field name.
1263                                 // This can happen when this function is being called from a JOIN.
1264                                 if ($field_exists == FALSE)
1265                                 {
1266                                         $i++;
1267                                 }
1268
1269                                 // We only add the table prefix if it does not already exist
1270                                 if (substr($parts[$i], 0, strlen($this->dbprefix)) != $this->dbprefix)
1271                                 {
1272                                         $parts[$i] = $this->dbprefix.$parts[$i];
1273                                 }
1274
1275                                 // Put the parts back together
1276                                 $item = implode('.', $parts);
1277                         }
1278
1279                         if ($protect_identifiers === TRUE)
1280                         {
1281                                 $item = $this->_escape_identifiers($item);
1282                         }
1283
1284                         return $item.$alias;
1285                 }
1286
1287                 // This is basically a bug fix for queries that use MAX, MIN, etc.
1288                 // If a parenthesis is found we know that we do not need to
1289                 // escape the data or add a prefix.  There's probably a more graceful
1290                 // way to deal with this, but I'm not thinking of it -- Rick
1291                 if (strpos($item, '(') !== FALSE)
1292                 {
1293                         return $item.$alias;
1294                 }
1295
1296                 // Is there a table prefix?  If not, no need to insert it
1297                 if ($this->dbprefix != '')
1298                 {
1299                         // Do we prefix an item with no segments?
1300                         if ($prefix_single == TRUE AND substr($item, 0, strlen($this->dbprefix)) != $this->dbprefix)
1301                         {
1302                                 $item = $this->dbprefix.$item;
1303                         }
1304                 }
1305
1306                 if ($protect_identifiers === TRUE AND ! in_array($item, $this->_reserved_identifiers))
1307                 {
1308                         $item = $this->_escape_identifiers($item);
1309                 }
1310
1311                 return $item.$alias;
1312         }
1313
1314
1315 }
1316
1317
1318 /* End of file DB_driver.php */
1319 /* Location: ./system/database/DB_driver.php */