system/libraries/drivers/Database/Mysqli.php

   1 <?php defined('SYSPATH') OR die('No direct access allowed.');
   2 /**
   3  * MySQLi Database Driver
   4  *
   5  * $Id: Mysqli.php 3917 2009-01-21 03:06:22Z zombor $
   6  *
   7  * @package    Core
   8  * @author     Kohana Team
   9  * @copyright  (c) 2007-2008 Kohana Team
  10  * @license    http://kohanaphp.com/license.html
  11  */
  12 class Database_Mysqli_Driver extends Database_Mysql_Driver {
  13
  14         // Database connection link
  15         protected $link;
  16         protected $db_config;
  17         protected $statements = array();
  18
  19         /**
  20          * Sets the config for the class.
  21          *
  22          * @param  array  database configuration
  23          */
  24         public function __construct($config)
  25         {
  26                 $this->db_config = $config;
  27
  28                 Kohana::log('debug', 'MySQLi Database Driver Initialized');
  29         }
  30
  31         /**
  32          * Closes the database connection.
  33          */
  34         public function __destruct()
  35         {
  36                 is_object($this->link) and $this->link->close();
  37         }
  38
  39         public function connect()
  40         {
  41                 // Check if link already exists
  42                 if (is_object($this->link))
  43                         return $this->link;
  44
  45                 // Import the connect variables
  46                 extract($this->db_config['connection']);
  47
  48                 // Build the connection info
  49                 $host = isset($host) ? $host : $socket;
  50
  51                 // Make the connection and select the database
  52                 if ($this->link = new mysqli($host, $user, $pass, $database, $port))
  53                 {
  54                         if ($charset = $this->db_config['character_set'])
  55                         {
  56                                 $this->set_charset($charset);
  57                         }
  58
  59                         // Clear password after successful connect
  60                         $this->config['connection']['pass'] = NULL;
  61
  62                         return $this->link;
  63                 }
  64
  65                 return FALSE;
  66         }
  67
  68         public function query($sql)
  69         {
  70                 // Only cache if it's turned on, and only cache if it's not a write statement
  71                 if ($this->db_config['cache'] AND ! preg_match('#\b(?:INSERT|UPDATE|REPLACE|SET)\b#i', $sql))
  72                 {
  73                         $hash = $this->query_hash($sql);
  74
  75                         if ( ! isset(self::$query_cache[$hash]))
  76                         {
  77                                 // Set the cached object
  78                                 self::$query_cache[$hash] = new Kohana_Mysqli_Result($this->link, $this->db_config['object'], $sql);
  79                         }
  80
  81                         // Return the cached query
  82                         return self::$query_cache[$hash];
  83                 }
  84
  85                 return new Kohana_Mysqli_Result($this->link, $this->db_config['object'], $sql);
  86         }
  87
  88         public function set_charset($charset)
  89         {
  90                 if ($this->link->set_charset($charset) === FALSE)
  91                         throw new Kohana_Database_Exception('database.error', $this->show_error());
  92         }
  93
  94         public function stmt_prepare($sql = '')
  95         {
  96                 is_object($this->link) or $this->connect();
  97                 return new Kohana_Mysqli_Statement($sql, $this->link);
  98         }
  99
 100         public function escape_str($str)
 101         {
 102                 if (!$this->db_config['escape'])
 103                         return $str;
 104
 105                 is_object($this->link) or $this->connect();
 106
 107                 return $this->link->real_escape_string($str);
 108         }
 109
 110         public function show_error()
 111         {
 112                 return $this->link->error;
 113         }
 114
 115         public function field_data($table)
 116         {
 117                 $columns = array();
 118                 $query = $this->link->query('SHOW COLUMNS FROM '.$this->escape_table($table));
 119
 120                 if (is_object($query))
 121                 {
 122                         while ($row = $query->fetch_object())
 123                         {
 124                                 $columns[] = $row;
 125                         }
 126                 }
 127
 128                 return $columns;
 129         }
 130
 131 } // End Database_Mysqli_Driver Class
 132
 133 /**
 134  * MySQLi Result
 135  */
 136 class Kohana_Mysqli_Result extends Database_Result {
 137
 138         // Database connection
 139         protected $link;
 140
 141         // Data fetching types
 142         protected $fetch_type  = 'mysqli_fetch_object';
 143         protected $return_type = MYSQLI_ASSOC;
 144
 145         /**
 146          * Sets up the result variables.
 147          *
 148          * @param  object    database link
 149          * @param  boolean   return objects or arrays
 150          * @param  string    SQL query that was run
 151          */
 152         public function __construct($link, $object = TRUE, $sql)
 153         {
 154                 $this->link = $link;
 155
 156                 if ( ! $this->link->multi_query($sql))
 157                 {
 158                         // SQL error
 159                         throw new Kohana_Database_Exception('database.error', $this->link->error.' - '.$sql);
 160                 }
 161                 else
 162                 {
 163                         $this->result = $this->link->store_result();
 164
 165                         // If the query is an object, it was a SELECT, SHOW, DESCRIBE, EXPLAIN query
 166                         if (is_object($this->result))
 167                         {
 168                                 $this->current_row = 0;
 169                                 $this->total_rows  = $this->result->num_rows;
 170                                 $this->fetch_type = ($object === TRUE) ? 'fetch_object' : 'fetch_array';
 171                         }
 172                         elseif ($this->link->error)
 173                         {
 174                                 // SQL error
 175                                 throw new Kohana_Database_Exception('database.error', $this->link->error.' - '.$sql);
 176                         }
 177                         else
 178                         {
 179                                 // Its an DELETE, INSERT, REPLACE, or UPDATE query
 180                                 $this->insert_id  = $this->link->insert_id;
 181                                 $this->total_rows = $this->link->affected_rows;
 182                         }
 183                 }
 184
 185                 // Set result type
 186                 $this->result($object);
 187
 188                 // Store the SQL
 189                 $this->sql = $sql;
 190         }
 191
 192         /**
 193          * Magic __destruct function, frees the result.
 194          */
 195         public function __destruct()
 196         {
 197                 if (is_object($this->result))
 198                 {
 199                         $this->result->free_result();
 200
 201                         // this is kinda useless, but needs to be done to avoid the "Commands out of sync; you
 202                         // can't run this command now" error. Basically, we get all results after the first one
 203                         // (the one we actually need) and free them.
 204                         if (is_resource($this->link) AND $this->link->more_results())
 205                         {
 206                                 do
 207                                 {
 208                                         if ($result = $this->link->store_result())
 209                                         {
 210                                                 $result->free_result();
 211                                         }
 212                                 } while ($this->link->next_result());
 213                         }
 214                 }
 215         }
 216
 217         public function result($object = TRUE, $type = MYSQLI_ASSOC)
 218         {
 219                 $this->fetch_type = ((bool) $object) ? 'fetch_object' : 'fetch_array';
 220
 221                 // This check has to be outside the previous statement, because we do not
 222                 // know the state of fetch_type when $object = NULL
 223                 // NOTE - The class set by $type must be defined before fetching the result,
 224                 // autoloading is disabled to save a lot of stupid overhead.
 225                 if ($this->fetch_type == 'fetch_object')
 226                 {
 227                         $this->return_type = (is_string($type) AND Kohana::auto_load($type)) ? $type : 'stdClass';
 228                 }
 229                 else
 230                 {
 231                         $this->return_type = $type;
 232                 }
 233
 234                 return $this;
 235         }
 236
 237         public function as_array($object = NULL, $type = MYSQLI_ASSOC)
 238         {
 239                 return $this->result_array($object, $type);
 240         }
 241
 242         public function result_array($object = NULL, $type = MYSQLI_ASSOC)
 243         {
 244                 $rows = array();
 245
 246                 if (is_string($object))
 247                 {
 248                         $fetch = $object;
 249                 }
 250                 elseif (is_bool($object))
 251                 {
 252                         if ($object === TRUE)
 253                         {
 254                                 $fetch = 'fetch_object';
 255
 256                                 // NOTE - The class set by $type must be defined before fetching the result,
 257                                 // autoloading is disabled to save a lot of stupid overhead.
 258                                 $type = (is_string($type) AND Kohana::auto_load($type)) ? $type : 'stdClass';
 259                         }
 260                         else
 261                         {
 262                                 $fetch = 'fetch_array';
 263                         }
 264                 }
 265                 else
 266                 {
 267                         // Use the default config values
 268                         $fetch = $this->fetch_type;
 269
 270                         if ($fetch == 'fetch_object')
 271                         {
 272                                 $type = (is_string($type) AND Kohana::auto_load($type)) ? $type : 'stdClass';
 273                         }
 274                 }
 275
 276                 if ($this->result->num_rows)
 277                 {
 278                         // Reset the pointer location to make sure things work properly
 279                         $this->result->data_seek(0);
 280
 281                         while ($row = $this->result->$fetch($type))
 282                         {
 283                                 $rows[] = $row;
 284                         }
 285                 }
 286
 287                 return isset($rows) ? $rows : array();
 288         }
 289
 290         public function list_fields()
 291         {
 292                 $field_names = array();
 293                 while ($field = $this->result->fetch_field())
 294                 {
 295                         $field_names[] = $field->name;
 296                 }
 297
 298                 return $field_names;
 299         }
 300
 301         public function seek($offset)
 302         {
 303                 if ( ! $this->offsetExists($offset))
 304                         return FALSE;
 305
 306                 $this->result->data_seek($offset);
 307
 308                 return TRUE;
 309         }
 310
 311         public function offsetGet($offset)
 312         {
 313                 if ( ! $this->seek($offset))
 314                         return FALSE;
 315
 316                 // Return the row
 317                 $fetch = $this->fetch_type;
 318                 return $this->result->$fetch($this->return_type);
 319         }
 320
 321 } // End Mysqli_Result Class
 322
 323 /**
 324  * MySQLi Prepared Statement (experimental)
 325  */
 326 class Kohana_Mysqli_Statement {
 327
 328         protected $link = NULL;
 329         protected $stmt;
 330         protected $var_names = array();
 331         protected $var_values = array();
 332
 333         public function __construct($sql, $link)
 334         {
 335                 $this->link = $link;
 336
 337                 $this->stmt = $this->link->prepare($sql);
 338
 339                 return $this;
 340         }
 341
 342         public function __destruct()
 343         {
 344                 $this->stmt->close();
 345         }
 346
 347         // Sets the bind parameters
 348         public function bind_params($param_types, $params)
 349         {
 350                 $this->var_names = array_keys($params);
 351                 $this->var_values = array_values($params);
 352                 call_user_func_array(array($this->stmt, 'bind_param'), array_merge($param_types, $var_names));
 353
 354                 return $this;
 355         }
 356
 357         public function bind_result($params)
 358         {
 359                 call_user_func_array(array($this->stmt, 'bind_result'), $params);
 360         }
 361
 362         // Runs the statement
 363         public function execute()
 364         {
 365                 foreach ($this->var_names as $key => $name)
 366                 {
 367                         $$name = $this->var_values[$key];
 368                 }
 369                 $this->stmt->execute();
 370                 return $this->stmt;
 371         }
 372 }