PageRenderTime 126ms CodeModel.GetById 63ms app.highlight 38ms RepoModel.GetById 14ms app.codeStats 0ms

/magehelp/system/database/DB_driver.php

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