libraries/dbi/drizzle.dbi.lib.php

   1 <?php
   2 /* vim: set expandtab sw=4 ts=4 sts=4: */
   3 /**
   4  * Interface to the Drizzle extension
   5  *
   6  * WARNING - EXPERIMENTAL, never use in production, drizzle module segfaults often and when you least expect it to
   7  *
   8  * TODO: This file and drizzle-wrappers.lib.php should be devoid of any segault related hacks.
   9  * TODO: Crashing versions of drizzle module and/or libdrizzle should be blacklisted
  10  *
  11  * @package PhpMyAdmin-DBI-Drizzle
  12  */
  13 if (! defined('PHPMYADMIN')) {
  14     exit;
  15 }
  16
  17 require_once './libraries/logging.lib.php';
  18 require_once './libraries/dbi/drizzle-wrappers.lib.php';
  19
  20 /**
  21  * MySQL client API
  22  */
  23 if (!defined('PMA_MYSQL_CLIENT_API')) {
  24     define('PMA_MYSQL_CLIENT_API', (int)drizzle_version());
  25 }
  26
  27 /**
  28  * Helper function for connecting to the database server
  29  *
  30  * @param   PMA_Drizzle  $drizzle
  31  * @param   string       $host
  32  * @param   int          $port
  33  * @param   string       $uds
  34  * @param   string       $user
  35  * @param   string       $password
  36  * @param   string       $db
  37  * @param   int          $options
  38  * @return  PMA_DrizzleCon
  39  */
  40 function PMA_DBI_real_connect($drizzle, $host, $port, $uds, $user, $password, $db = null, $options = DRIZZLE_CON_NONE)
  41 {
  42     if ($uds) {
  43         $con = $drizzle->addUds($uds, $user, $password, $db, $options);
  44     } else {
  45         $con = $drizzle->addTcp($host, $port, $user, $password, $db, $options);
  46     }
  47
  48     return $con;
  49 }
  50
  51 /**
  52  * connects to the database server
  53  *
  54  * @param   string  $user           drizzle user name
  55  * @param   string  $password       drizzle user password
  56  * @param   bool    $is_controluser
  57  * @param   array   $server host/port/socket
  58  * @param   bool    $auxiliary_connection (when true, don't go back to login if connection fails)
  59  * @return  mixed   false on error or a mysqli object on success
  60  */
  61 function PMA_DBI_connect($user, $password, $is_controluser = false, $server = null, $auxiliary_connection = false)
  62 {
  63     global $cfg;
  64
  65     if ($server) {
  66         $server_port   = (empty($server['port']))
  67             ? false
  68             : (int)$server['port'];
  69         $server_socket = (empty($server['socket']))
  70             ? ''
  71             : $server['socket'];
  72         $server['host'] = (empty($server['host']))
  73             ? 'localhost'
  74             : $server['host'];
  75     } else {
  76         $server_port   = (empty($cfg['Server']['port']))
  77             ? false
  78             : (int) $cfg['Server']['port'];
  79         $server_socket = (empty($cfg['Server']['socket']))
  80             ? null
  81             : $cfg['Server']['socket'];
  82     }
  83
  84     if (strtolower($GLOBALS['cfg']['Server']['connect_type']) == 'tcp') {
  85         $GLOBALS['cfg']['Server']['socket'] = '';
  86     }
  87
  88     $drizzle = new PMA_Drizzle();
  89
  90     $client_flags = 0;
  91
  92     /* Optionally compress connection */
  93     if ($GLOBALS['cfg']['Server']['compress']) {
  94         $client_flags |= DRIZZLE_CAPABILITIES_COMPRESS;
  95     }
  96
  97     /* Optionally enable SSL */
  98     if ($GLOBALS['cfg']['Server']['ssl']) {
  99         $client_flags |= DRIZZLE_CAPABILITIES_SSL;
 100     }
 101
 102     if (!$server) {
 103         $link = @PMA_DBI_real_connect($drizzle, $cfg['Server']['host'], $server_port, $server_socket, $user, $password, false, $client_flags);
 104         // Retry with empty password if we're allowed to
 105         if ($link == false && isset($cfg['Server']['nopassword']) && $cfg['Server']['nopassword'] && !$is_controluser) {
 106             $link = @PMA_DBI_real_connect($drizzle, $cfg['Server']['host'], $server_port, $server_socket, $user, null, false, $client_flags);
 107         }
 108     } else {
 109         $link = @PMA_DBI_real_connect($drizzle, $server['host'], $server_port, $server_socket, $user, $password);
 110     }
 111
 112     if ($link == false) {
 113         if ($is_controluser) {
 114             trigger_error(__('Connection for controluser as defined in your configuration failed.'), E_USER_WARNING);
 115             return false;
 116         }
 117         // we could be calling PMA_DBI_connect() to connect to another
 118         // server, for example in the Synchronize feature, so do not
 119         // go back to main login if it fails
 120         if (! $auxiliary_connection) {
 121             PMA_log_user($user, 'drizzle-denied');
 122             PMA_auth_fails();
 123         } else {
 124             return false;
 125         }
 126     } else {
 127         PMA_DBI_postConnect($link, $is_controluser);
 128     }
 129
 130     return $link;
 131 }
 132
 133 /**
 134  * selects given database
 135  *
 136  * @param string          $dbname  database name to select
 137  * @param PMA_DrizzleCom  $link    connection object
 138  * @return bool
 139  */
 140 function PMA_DBI_select_db($dbname, $link = null)
 141 {
 142     if (empty($link)) {
 143         if (isset($GLOBALS['userlink'])) {
 144             $link = $GLOBALS['userlink'];
 145         } else {
 146             return false;
 147         }
 148     }
 149     return $link->selectDb($dbname);
 150 }
 151
 152 /**
 153  * runs a query and returns the result
 154  *
 155  * @param   string          $query    query to execute
 156  * @param   PMA_DrizzleCon  $link     connection object
 157  * @param   int             $options
 158  * @return  PMA_DrizzleResult
 159  */
 160 function PMA_DBI_real_query($query, $link, $options)
 161 {
 162     $buffer_mode = $options & PMA_DBI_QUERY_UNBUFFERED
 163         ? PMA_Drizzle::BUFFER_ROW
 164         : PMA_Drizzle::BUFFER_RESULT;
 165     $res = $link->query($query, $buffer_mode);
 166     return $res;
 167 }
 168
 169 /**
 170  * returns array of rows with associative and numeric keys from $result
 171  *
 172  * @param   PMA_DrizzleResult  $result
 173  * @return  array
 174  */
 175 function PMA_DBI_fetch_array($result)
 176 {
 177     return $result->fetchRow(PMA_Drizzle::FETCH_BOTH);
 178 }
 179
 180 /**
 181  * returns array of rows with associative keys from $result
 182  *
 183  * @param   PMA_DrizzleResult  $result
 184  * @return  array
 185  */
 186 function PMA_DBI_fetch_assoc($result)
 187 {
 188     return $result->fetchRow(PMA_Drizzle::FETCH_ASSOC);
 189 }
 190
 191 /**
 192  * returns array of rows with numeric keys from $result
 193  *
 194  * @param   PMA_DrizzleResult  $result
 195  * @return  array
 196  */
 197 function PMA_DBI_fetch_row($result)
 198 {
 199     return $result->fetchRow(PMA_Drizzle::FETCH_NUM);
 200 }
 201
 202 /**
 203  * Adjusts the result pointer to an arbitrary row in the result
 204  *
 205  * @param   PMA_DrizzleResult  $result
 206  * @param   int                $offset
 207  * @return  boolean true on success, false on failure
 208  */
 209 function PMA_DBI_data_seek($result, $offset)
 210 {
 211     return $result->seek($offset);
 212 }
 213
 214 /**
 215  * Frees memory associated with the result
 216  *
 217  * @param  PMA_DrizzleResult  $result
 218  */
 219 function PMA_DBI_free_result($result)
 220 {
 221     if ($result instanceof PMA_DrizzleResult) {
 222         $result->free();
 223     }
 224 }
 225
 226 /**
 227  * Check if there are any more query results from a multi query
 228  *
 229  * @return  bool         false
 230  */
 231 function PMA_DBI_more_results() {
 232     // N.B.: PHP's 'mysql' extension does not support
 233     // multi_queries so this function will always
 234     // return false. Use the 'mysqli' extension, if
 235     // you need support for multi_queries.
 236     return false;
 237 }
 238
 239 /**
 240  * Prepare next result from multi_query
 241  *
 242  * @return  bool         false
 243  */
 244 function PMA_DBI_next_result() {
 245     // N.B.: PHP's 'mysql' extension does not support
 246     // multi_queries so this function will always
 247     // return false. Use the 'mysqli' extension, if
 248     // you need support for multi_queries.
 249     return false;
 250 }
 251
 252 /**
 253  * Returns a string representing the type of connection used
 254  * @param   PMA_DrizzleCon  $link   connection object
 255  * @return  string          type of connection used
 256  */
 257 function PMA_DBI_get_host_info($link = null)
 258 {
 259     if (null === $link) {
 260         if (isset($GLOBALS['userlink'])) {
 261             $link = $GLOBALS['userlink'];
 262         } else {
 263             return false;
 264         }
 265     }
 266
 267     $str = $link->port()
 268         ? $link->host() . ':' . $link->port() . ' via TCP/IP'
 269         : 'Localhost via UNIX socket';
 270     return $str;
 271 }
 272
 273 /**
 274  * Returns the version of the Drizzle protocol used
 275  * @param   PMA_DrizzleCon  $link   connection object
 276  * @return  int         version of the Drizzle protocol used
 277  */
 278 function PMA_DBI_get_proto_info($link = null)
 279 {
 280     if (null === $link) {
 281         if (isset($GLOBALS['userlink'])) {
 282             $link = $GLOBALS['userlink'];
 283         } else {
 284             return false;
 285         }
 286     }
 287
 288     return $link->protocolVersion();
 289 }
 290
 291 /**
 292  * returns a string that represents the client library version
 293  * @return  string          Drizzle client library version
 294  */
 295 function PMA_DBI_get_client_info()
 296 {
 297     return 'libdrizzle (Drizzle ' . drizzle_version() . ')';
 298 }
 299
 300 /**
 301  * returns last error message or false if no errors occured
 302  *
 303  * @param   PMA_DrizzleCon  $link  connection object
 304  * @return  string|bool  $error or false
 305  */
 306 function PMA_DBI_getError($link = null)
 307 {
 308     $GLOBALS['errno'] = 0;
 309
 310     /* Treat false same as null because of controllink */
 311     if ($link === false) {
 312         $link = null;
 313     }
 314
 315     if (null === $link && isset($GLOBALS['userlink'])) {
 316         $link =& $GLOBALS['userlink'];
 317         // Do not stop now. We still can get the error code
 318         // with mysqli_connect_errno()
 319 //    } else {
 320 //        return false;
 321     }
 322
 323     if (null !== $link) {
 324         $error_number = drizzle_con_errno($link->getConnectionObject());
 325         $error_message = drizzle_con_error($link->getConnectionObject());
 326     } else {
 327         $error_number = drizzle_errno();
 328         $error_message = drizzle_error();
 329     }
 330     if (0 == $error_number) {
 331         return false;
 332     }
 333
 334     // keep the error number for further check after the call to PMA_DBI_getError()
 335     $GLOBALS['errno'] = $error_number;
 336
 337     return PMA_DBI_formatError($error_number, $error_message);
 338 }
 339
 340 /**
 341  * returns the number of rows returned by last query
 342  *
 343  * @param   PMA_DrizzleResult  $result
 344  * @return  string|int
 345  */
 346 function PMA_DBI_num_rows($result)
 347 {
 348     // see the note for PMA_DBI_try_query();
 349     if (!is_bool($result)) {
 350         return @$result->numRows();
 351     } else {
 352         return 0;
 353     }
 354 }
 355
 356 /**
 357  * returns last inserted auto_increment id for given $link or $GLOBALS['userlink']
 358  *
 359  * @param   PMA_DrizzleCon  $link  connection object
 360  * @return  string|int
 361  */
 362 function PMA_DBI_insert_id($link = null)
 363 {
 364     if (empty($link)) {
 365         if (isset($GLOBALS['userlink'])) {
 366             $link = $GLOBALS['userlink'];
 367         } else {
 368             return false;
 369         }
 370     }
 371
 372     // copied from mysql and mysqli
 373
 374     // When no controluser is defined, using mysqli_insert_id($link)
 375     // does not always return the last insert id due to a mixup with
 376     // the tracking mechanism, but this works:
 377     return PMA_DBI_fetch_value('SELECT LAST_INSERT_ID();', 0, 0, $link);
 378     // Curiously, this problem does not happen with the mysql extension but
 379     // there is another problem with BIGINT primary keys so PMA_DBI_insert_id()
 380     // in the mysql extension also uses this logic.
 381 }
 382
 383 /**
 384  * returns the number of rows affected by last query
 385  *
 386  * @param   PMA_DrizzleResult  $link            connection object
 387  * @param   bool               $get_from_cache
 388  * @return  string|int
 389  */
 390 function PMA_DBI_affected_rows($link = null, $get_from_cache = true)
 391 {
 392     if (empty($link)) {
 393         if (isset($GLOBALS['userlink'])) {
 394             $link = $GLOBALS['userlink'];
 395         } else {
 396             return false;
 397         }
 398     }
 399     if ($get_from_cache) {
 400         return $GLOBALS['cached_affected_rows'];
 401     } else {
 402         return $link->affectedRows();
 403     }
 404 }
 405
 406 /**
 407  * returns metainfo for fields in $result
 408  *
 409  * @param   PMA_DrizzleResult  $result
 410  * @return  array  meta info for fields in $result
 411  */
 412 function PMA_DBI_get_fields_meta($result)
 413 {
 414     // Build an associative array for a type look up
 415     $typeAr = array();
 416     /*$typeAr[DRIZZLE_COLUMN_TYPE_DECIMAL]     = 'real';
 417     $typeAr[DRIZZLE_COLUMN_TYPE_NEWDECIMAL]  = 'real';
 418     $typeAr[DRIZZLE_COLUMN_TYPE_BIT]         = 'int';
 419     $typeAr[DRIZZLE_COLUMN_TYPE_TINY]        = 'int';
 420     $typeAr[DRIZZLE_COLUMN_TYPE_SHORT]       = 'int';
 421     $typeAr[DRIZZLE_COLUMN_TYPE_LONG]        = 'int';
 422     $typeAr[DRIZZLE_COLUMN_TYPE_FLOAT]       = 'real';
 423     $typeAr[DRIZZLE_COLUMN_TYPE_DOUBLE]      = 'real';
 424     $typeAr[DRIZZLE_COLUMN_TYPE_NULL]        = 'null';
 425     $typeAr[DRIZZLE_COLUMN_TYPE_TIMESTAMP]   = 'timestamp';
 426     $typeAr[DRIZZLE_COLUMN_TYPE_LONGLONG]    = 'int';
 427     $typeAr[DRIZZLE_COLUMN_TYPE_INT24]       = 'int';
 428     $typeAr[DRIZZLE_COLUMN_TYPE_DATE]        = 'date';
 429     $typeAr[DRIZZLE_COLUMN_TYPE_TIME]        = 'date';
 430     $typeAr[DRIZZLE_COLUMN_TYPE_DATETIME]    = 'datetime';
 431     $typeAr[DRIZZLE_COLUMN_TYPE_YEAR]        = 'year';
 432     $typeAr[DRIZZLE_COLUMN_TYPE_NEWDATE]     = 'date';
 433     $typeAr[DRIZZLE_COLUMN_TYPE_ENUM]        = 'unknown';
 434     $typeAr[DRIZZLE_COLUMN_TYPE_SET]         = 'unknown';
 435     $typeAr[DRIZZLE_COLUMN_TYPE_VIRTUAL]     = 'unknown';
 436     $typeAr[DRIZZLE_COLUMN_TYPE_TINY_BLOB]   = 'blob';
 437     $typeAr[DRIZZLE_COLUMN_TYPE_MEDIUM_BLOB] = 'blob';
 438     $typeAr[DRIZZLE_COLUMN_TYPE_LONG_BLOB]   = 'blob';
 439     $typeAr[DRIZZLE_COLUMN_TYPE_BLOB]        = 'blob';
 440     $typeAr[DRIZZLE_COLUMN_TYPE_VAR_STRING]  = 'string';
 441     $typeAr[DRIZZLE_COLUMN_TYPE_VARCHAR]     = 'string';
 442     $typeAr[DRIZZLE_COLUMN_TYPE_STRING]      = 'string';
 443     $typeAr[DRIZZLE_COLUMN_TYPE_GEOMETRY]    = 'geometry';*/
 444
 445     $typeAr[DRIZZLE_COLUMN_TYPE_DRIZZLE_BLOB]      = 'blob';
 446     $typeAr[DRIZZLE_COLUMN_TYPE_DRIZZLE_DATE]      = 'date';
 447     $typeAr[DRIZZLE_COLUMN_TYPE_DRIZZLE_DATETIME]  = 'datetime';
 448     $typeAr[DRIZZLE_COLUMN_TYPE_DRIZZLE_DOUBLE]    = 'real';
 449     $typeAr[DRIZZLE_COLUMN_TYPE_DRIZZLE_ENUM]      = 'unknown';
 450     $typeAr[DRIZZLE_COLUMN_TYPE_DRIZZLE_LONG]      = 'int';
 451     $typeAr[DRIZZLE_COLUMN_TYPE_DRIZZLE_LONGLONG]  = 'int';
 452     $typeAr[DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX]       = 'unknown';
 453     $typeAr[DRIZZLE_COLUMN_TYPE_DRIZZLE_NULL]      = 'null';
 454     $typeAr[DRIZZLE_COLUMN_TYPE_DRIZZLE_TIMESTAMP] = 'timestamp';
 455     $typeAr[DRIZZLE_COLUMN_TYPE_DRIZZLE_TINY]      = 'int';
 456     $typeAr[DRIZZLE_COLUMN_TYPE_DRIZZLE_VARCHAR]   = 'string';
 457
 458     // array of DrizzleColumn
 459     $columns = $result->getColumns();
 460     // columns in a standarized format
 461     $std_columns = array();
 462
 463     foreach ($columns as $k => $column) {
 464         $c = new stdClass();
 465         $c->name = $column->name();
 466         $c->orgname = $column->origName();
 467         $c->table = $column->table();
 468         $c->orgtable = $column->origTable();
 469         $c->def = $column->defaultValue();
 470         $c->db = $column->db();
 471         $c->catalog = $column->catalog();
 472         // $column->maxSize() returns always 0 while size() seems
 473         // to return a correct value (drizzle extension v.0.5, API v.7)
 474         $c->max_length = $column->size();
 475         $c->decimals = $column->decimals();
 476         $c->charsetnr = $column->charset();
 477         $c->type = $typeAr[$column->typeDrizzle()];
 478         $c->_type = $column->type();
 479         $c->flags = PMA_DBI_field_flags($result, $k);
 480         $c->_flags = $column->flags();
 481
 482         $c->multiple_key = (int) (bool) ($c->_flags & DRIZZLE_COLUMN_FLAGS_MULTIPLE_KEY);
 483         $c->primary_key =  (int) (bool) ($c->_flags & DRIZZLE_COLUMN_FLAGS_PRI_KEY);
 484         $c->unique_key =   (int) (bool) ($c->_flags & DRIZZLE_COLUMN_FLAGS_UNIQUE_KEY);
 485         $c->not_null =     (int) (bool) ($c->_flags & DRIZZLE_COLUMN_FLAGS_NOT_NULL);
 486         $c->unsigned =     (int) (bool) ($c->_flags & DRIZZLE_COLUMN_FLAGS_UNSIGNED);
 487         $c->zerofill =     (int) (bool) ($c->_flags & DRIZZLE_COLUMN_FLAGS_ZEROFILL);
 488         $c->numeric =      (int) (bool) ($c->_flags & DRIZZLE_COLUMN_FLAGS_NUM);
 489         $c->blob =         (int) (bool) ($c->_flags & DRIZZLE_COLUMN_FLAGS_BLOB);
 490
 491         $std_columns[] = $c;
 492     }
 493
 494     return $std_columns;
 495 }
 496
 497 /**
 498  * return number of fields in given $result
 499  *
 500  * @param   PMA_DrizzleResult  $result
 501  * @return  int  field count
 502  */
 503 function PMA_DBI_num_fields($result)
 504 {
 505     return $result->numColumns();
 506 }
 507
 508 /**
 509  * returns the length of the given field $i in $result
 510  *
 511  * @param   PMA_DrizzleResult  $result
 512  * @param   int                $i       field
 513  * @return  int  length of field
 514  */
 515 function PMA_DBI_field_len($result, $i)
 516 {
 517     $colums = $result->getColumns();
 518     return $colums[$i]->size();
 519 }
 520
 521 /**
 522  * returns name of $i. field in $result
 523  *
 524  * @param   PMA_DrizzleResult  $result
 525  * @param   int                $i       field
 526  * @return  string  name of $i. field in $result
 527  */
 528 function PMA_DBI_field_name($result, $i)
 529 {
 530     $colums = $result->getColumns();
 531     return $colums[$i]->name();
 532 }
 533
 534 /**
 535  * returns concatenated string of human readable field flags
 536  *
 537  * @param   PMA_DrizzleResult  $result
 538  * @param   int                $i       field
 539  * @return  string  field flags
 540  */
 541 function PMA_DBI_field_flags($result, $i)
 542 {
 543     $columns = $result->getColumns();
 544     $f = $columns[$i];
 545     $type = $f->typeDrizzle();
 546     $charsetnr = $f->charset();
 547     $f = $f->flags();
 548     $flags = '';
 549     if ($f & DRIZZLE_COLUMN_FLAGS_UNIQUE_KEY) {
 550         $flags .= 'unique ';
 551     }
 552     if ($f & DRIZZLE_COLUMN_FLAGS_NUM) {
 553         $flags .= 'num ';
 554     }
 555     if ($f & DRIZZLE_COLUMN_FLAGS_PART_KEY) {
 556         $flags .= 'part_key ';
 557     }
 558     if ($f & DRIZZLE_COLUMN_FLAGS_SET) {
 559         $flags .= 'set ';
 560     }
 561     if ($f & DRIZZLE_COLUMN_FLAGS_TIMESTAMP) {
 562         $flags .= 'timestamp ';
 563     }
 564     if ($f & DRIZZLE_COLUMN_FLAGS_AUTO_INCREMENT) {
 565         $flags .= 'auto_increment ';
 566     }
 567     if ($f & DRIZZLE_COLUMN_FLAGS_ENUM) {
 568         $flags .= 'enum ';
 569     }
 570     // See http://dev.mysql.com/doc/refman/6.0/en/c-api-datatypes.html:
 571     // to determine if a string is binary, we should not use MYSQLI_BINARY_FLAG
 572     // but instead the charsetnr member of the MYSQL_FIELD
 573     // structure. Watch out: some types like DATE returns 63 in charsetnr
 574     // so we have to check also the type.
 575     // Unfortunately there is no equivalent in the mysql extension.
 576     if (($type == DRIZZLE_COLUMN_TYPE_DRIZZLE_BLOB || $type == DRIZZLE_COLUMN_TYPE_DRIZZLE_VARCHAR) && 63 == $charsetnr) {
 577         $flags .= 'binary ';
 578     }
 579     if ($f & DRIZZLE_COLUMN_FLAGS_ZEROFILL) {
 580         $flags .= 'zerofill ';
 581     }
 582     if ($f & DRIZZLE_COLUMN_FLAGS_UNSIGNED) {
 583         $flags .= 'unsigned ';
 584     }
 585     if ($f & DRIZZLE_COLUMN_FLAGS_BLOB) {
 586         $flags .= 'blob ';
 587     }
 588     if ($f & DRIZZLE_COLUMN_FLAGS_MULTIPLE_KEY) {
 589         $flags .= 'multiple_key ';
 590     }
 591     if ($f & DRIZZLE_COLUMN_FLAGS_UNIQUE_KEY) {
 592         $flags .= 'unique_key ';
 593     }
 594     if ($f & DRIZZLE_COLUMN_FLAGS_PRI_KEY) {
 595         $flags .= 'primary_key ';
 596     }
 597     if ($f & DRIZZLE_COLUMN_FLAGS_NOT_NULL) {
 598         $flags .= 'not_null ';
 599     }
 600     return trim($flags);
 601 }
 602
 603 ?>