Search moodle.org's
Developer Documentation
Developer Documentation
- Bug fixes for general core bugs in 3.10.x will end 8 November 2021 (12 months).
- Bug fixes for security issues in 3.10.x will end 9 May 2022 (18 months).
- PHP version: minimum PHP 7.2.0 Note: minimum PHP version has increased since Moodle 3.8. PHP 7.3.x and 7.4.x are supported too.
/lib/dml/ -> pgsql_native_moodle_database.php (source)
Differences Between: [Versions 310 and 311] [Versions 310 and 400] [Versions 310 and 401] [Versions 310 and 402] [Versions 310 and 403] [Versions 39 and 310]
1 <?php 2 // This file is part of Moodle - http://moodle.org/ 3 // 4 // Moodle is free software: you can redistribute it and/or modify 5 // it under the terms of the GNU General Public License as published by 6 // the Free Software Foundation, either version 3 of the License, or 7 // (at your option) any later version. 8 // 9 // Moodle is distributed in the hope that it will be useful, 10 // but WITHOUT ANY WARRANTY; without even the implied warranty of 11 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 12 // GNU General Public License for more details. 13 // 14 // You should have received a copy of the GNU General Public License 15 // along with Moodle. If not, see <http://www.gnu.org/licenses/>. 16 17 /** 18 * Native pgsql class representing moodle database interface. 19 * 20 * @package core_dml 21 * @copyright 2008 Petr Skoda (http://skodak.org) 22 * @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later 23 */ 24 25 defined('MOODLE_INTERNAL') || die(); 26 27 require_once (__DIR__.'/moodle_database.php'); 28 require_once (__DIR__.'/moodle_read_slave_trait.php'); 29 require_once (__DIR__.'/pgsql_native_moodle_recordset.php'); 30 require_once (__DIR__.'/pgsql_native_moodle_temptables.php'); 31 32 /** 33 * Native pgsql class representing moodle database interface. 34 * 35 * @package core_dml 36 * @copyright 2008 Petr Skoda (http://skodak.org) 37 * @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later 38 */ 39 class pgsql_native_moodle_database extends moodle_database { 40 use moodle_read_slave_trait { 41 select_db_handle as read_slave_select_db_handle; 42 can_use_readonly as read_slave_can_use_readonly; 43 query_start as read_slave_query_start; 44 } 45 46 /** @var array $dbhcursor keep track of open cursors */ 47 private $dbhcursor = []; 48 49 /** @var resource $pgsql database resource */ 50 protected $pgsql = null; 51 52 protected $last_error_reporting; // To handle pgsql driver default verbosity 53 54 /** @var bool savepoint hack for MDL-35506 - workaround for automatic transaction rollback on error */ 55 protected $savepointpresent = false; 56 57 /** @var int Number of cursors used (for constructing a unique ID) */ 58 protected $cursorcount = 0; 59 60 /** @var int Default number of rows to fetch at a time when using recordsets with cursors */ 61 const DEFAULT_FETCH_BUFFER_SIZE = 100000; 62 63 /** 64 * Detects if all needed PHP stuff installed. 65 * Note: can be used before connect() 66 * @return mixed true if ok, string if something 67 */ 68 public function driver_installed() { 69 if (!extension_loaded('pgsql')) { 70 return get_string('pgsqlextensionisnotpresentinphp', 'install'); 71 } 72 return true; 73 } 74 75 /** 76 * Returns database family type - describes SQL dialect 77 * Note: can be used before connect() 78 * @return string db family name (mysql, postgres, mssql, oracle, etc.) 79 */ 80 public function get_dbfamily() { 81 return 'postgres'; 82 } 83 84 /** 85 * Returns more specific database driver type 86 * Note: can be used before connect() 87 * @return string db type mysqli, pgsql, oci, mssql, sqlsrv 88 */ 89 protected function get_dbtype() { 90 return 'pgsql'; 91 } 92 93 /** 94 * Returns general database library name 95 * Note: can be used before connect() 96 * @return string db type pdo, native 97 */ 98 protected function get_dblibrary() { 99 return 'native'; 100 } 101 102 /** 103 * Returns localised database type name 104 * Note: can be used before connect() 105 * @return string 106 */ 107 public function get_name() { 108 return get_string('nativepgsql', 'install'); 109 } 110 111 /** 112 * Returns localised database configuration help. 113 * Note: can be used before connect() 114 * @return string 115 */ 116 public function get_configuration_help() { 117 return get_string('nativepgsqlhelp', 'install'); 118 } 119 120 /** 121 * Connect to db 122 * @param string $dbhost The database host. 123 * @param string $dbuser The database username. 124 * @param string $dbpass The database username's password. 125 * @param string $dbname The name of the database being connected to. 126 * @param mixed $prefix string means moodle db prefix, false used for external databases where prefix not used 127 * @param array $dboptions driver specific options 128 * @return bool true 129 * @throws dml_connection_exception if error 130 */ 131 public function raw_connect(string $dbhost, string $dbuser, string $dbpass, string $dbname, $prefix, array $dboptions=null): bool { 132 if ($prefix == '' and !$this->external) { 133 //Enforce prefixes for everybody but mysql 134 throw new dml_exception('prefixcannotbeempty', $this->get_dbfamily()); 135 } 136 137 $driverstatus = $this->driver_installed(); 138 139 if ($driverstatus !== true) { 140 throw new dml_exception('dbdriverproblem', $driverstatus); 141 } 142 143 $this->store_settings($dbhost, $dbuser, $dbpass, $dbname, $prefix, $dboptions); 144 145 $pass = addcslashes($this->dbpass, "'\\"); 146 147 // Unix socket connections should have lower overhead 148 if (!empty($this->dboptions['dbsocket']) and ($this->dbhost === 'localhost' or $this->dbhost === '127.0.0.1')) { 149 $connection = "user='$this->dbuser' password='$pass' dbname='$this->dbname'"; 150 if (strpos($this->dboptions['dbsocket'], '/') !== false) { 151 // A directory was specified as the socket location. 152 $connection .= " host='".$this->dboptions['dbsocket']."'"; 153 } 154 if (!empty($this->dboptions['dbport'])) { 155 // A port as specified, add it to the connection as it's used as part of the socket path. 156 $connection .= " port ='".$this->dboptions['dbport']."'"; 157 } 158 } else { 159 $this->dboptions['dbsocket'] = ''; 160 if (empty($this->dbname)) { 161 // probably old style socket connection - do not add port 162 $port = ""; 163 } else if (empty($this->dboptions['dbport'])) { 164 $port = "port ='5432'"; 165 } else { 166 $port = "port ='".$this->dboptions['dbport']."'"; 167 } 168 $connection = "host='$this->dbhost' $port user='$this->dbuser' password='$pass' dbname='$this->dbname'"; 169 } 170 171 if (!empty($this->dboptions['connecttimeout'])) { 172 $connection .= " connect_timeout=".$this->dboptions['connecttimeout']; 173 } 174 175 if (empty($this->dboptions['dbhandlesoptions'])) { 176 // ALTER USER and ALTER DATABASE are overridden by these settings. 177 $options = array('--client_encoding=utf8', '--standard_conforming_strings=on'); 178 // Select schema if specified, otherwise the first one wins. 179 if (!empty($this->dboptions['dbschema'])) { 180 $options[] = "-c search_path=" . addcslashes($this->dboptions['dbschema'], "'\\"); 181 } 182 183 $connection .= " options='" . implode(' ', $options) . "'"; 184 } 185 186 ob_start(); 187 if (empty($this->dboptions['dbpersist'])) { 188 $this->pgsql = pg_connect($connection, PGSQL_CONNECT_FORCE_NEW); 189 } else { 190 $this->pgsql = pg_pconnect($connection, PGSQL_CONNECT_FORCE_NEW); 191 } 192 $dberr = ob_get_contents(); 193 ob_end_clean(); 194 195 $status = pg_connection_status($this->pgsql); 196 197 if ($status === false or $status === PGSQL_CONNECTION_BAD) { 198 $this->pgsql = null; 199 throw new dml_connection_exception($dberr); 200 } 201 202 if (!empty($this->dboptions['dbpersist'])) { 203 // There are rare situations (such as PHP out of memory errors) when open cursors may 204 // not be closed at the end of a connection. When using persistent connections, the 205 // cursors remain open and 'get in the way' of future connections. To avoid this 206 // problem, close all cursors here. 207 $result = pg_query($this->pgsql, 'CLOSE ALL'); 208 if ($result) { 209 pg_free_result($result); 210 } 211 } 212 213 if (!empty($this->dboptions['dbhandlesoptions'])) { 214 /* We don't trust people who just set the dbhandlesoptions, this code checks up on them. 215 * These functions do not talk to the server, they use the client library knowledge to determine state. 216 */ 217 if (!empty($this->dboptions['dbschema'])) { 218 throw new dml_connection_exception('You cannot specify a schema with dbhandlesoptions, use the database to set it.'); 219 } 220 if (pg_client_encoding($this->pgsql) != 'UTF8') { 221 throw new dml_connection_exception('client_encoding = UTF8 not set, it is: ' . pg_client_encoding($this->pgsql)); 222 } 223 if (pg_escape_string($this->pgsql, '\\') != '\\') { 224 throw new dml_connection_exception('standard_conforming_strings = on, must be set at the database.'); 225 } 226 } 227 228 // Connection stabilised and configured, going to instantiate the temptables controller 229 $this->temptables = new pgsql_native_moodle_temptables($this); 230 231 return true; 232 } 233 234 /** 235 * Close database connection and release all resources 236 * and memory (especially circular memory references). 237 * Do NOT use connect() again, create a new instance if needed. 238 */ 239 public function dispose() { 240 parent::dispose(); // Call parent dispose to write/close session and other common stuff before closing connection 241 if ($this->pgsql) { 242 pg_close($this->pgsql); 243 $this->pgsql = null; 244 } 245 } 246 247 /** 248 * Gets db handle currently used with queries 249 * @return resource 250 */ 251 protected function get_db_handle() { 252 return $this->pgsql; 253 } 254 255 /** 256 * Sets db handle to be used with subsequent queries 257 * @param resource $dbh 258 * @return void 259 */ 260 protected function set_db_handle($dbh): void { 261 $this->pgsql = $dbh; 262 } 263 264 /** 265 * Select appropriate db handle - readwrite or readonly 266 * @param int $type type of query 267 * @param string $sql 268 * @return void 269 */ 270 protected function select_db_handle(int $type, string $sql): void { 271 $this->read_slave_select_db_handle($type, $sql); 272 273 if (preg_match('/^DECLARE (crs\w*) NO SCROLL CURSOR/', $sql, $match)) { 274 $cursor = $match[1]; 275 $this->dbhcursor[$cursor] = $this->pgsql; 276 } 277 if (preg_match('/^(?:FETCH \d+ FROM|CLOSE) (crs\w*)\b/', $sql, $match)) { 278 $cursor = $match[1]; 279 $this->pgsql = $this->dbhcursor[$cursor]; 280 } 281 } 282 283 /** 284 * Check if The query qualifies for readonly connection execution 285 * Logging queries are exempt, those are write operations that circumvent 286 * standard query_start/query_end paths. 287 * @param int $type type of query 288 * @param string $sql 289 * @return bool 290 */ 291 protected function can_use_readonly(int $type, string $sql): bool { 292 // ... pg_*lock queries always go to master. 293 if (preg_match('/\bpg_\w*lock/', $sql)) { 294 return false; 295 } 296 297 // ... a nuisance - temptables use this. 298 if (preg_match('/\bpg_catalog/', $sql) && $this->temptables->get_temptables()) { 299 return false; 300 } 301 302 return $this->read_slave_can_use_readonly($type, $sql); 303 304 } 305 306 /** 307 * Called before each db query. 308 * @param string $sql 309 * @param array array of parameters 310 * @param int $type type of query 311 * @param mixed $extrainfo driver specific extra information 312 * @return void 313 */ 314 protected function query_start($sql, array $params=null, $type, $extrainfo=null) { 315 $this->read_slave_query_start($sql, $params, $type, $extrainfo); 316 // pgsql driver tends to send debug to output, we do not need that. 317 $this->last_error_reporting = error_reporting(0); 318 } 319 320 /** 321 * Called immediately after each db query. 322 * @param mixed db specific result 323 * @return void 324 */ 325 protected function query_end($result) { 326 // reset original debug level 327 error_reporting($this->last_error_reporting); 328 try { 329 parent::query_end($result); 330 if ($this->savepointpresent and $this->last_type != SQL_QUERY_AUX and $this->last_type != SQL_QUERY_SELECT) { 331 $res = @pg_query($this->pgsql, "RELEASE SAVEPOINT moodle_pg_savepoint; SAVEPOINT moodle_pg_savepoint"); 332 if ($res) { 333 pg_free_result($res); 334 } 335 } 336 } catch (Exception $e) { 337 if ($this->savepointpresent) { 338 $res = @pg_query($this->pgsql, "ROLLBACK TO SAVEPOINT moodle_pg_savepoint; SAVEPOINT moodle_pg_savepoint"); 339 if ($res) { 340 pg_free_result($res); 341 } 342 } 343 throw $e; 344 } 345 } 346 347 /** 348 * Returns database server info array 349 * @return array Array containing 'description' and 'version' info 350 */ 351 public function get_server_info() { 352 static $info; 353 if (!$info) { 354 $this->query_start("--pg_version()", null, SQL_QUERY_AUX); 355 $info = pg_version($this->pgsql); 356 $this->query_end(true); 357 } 358 return array('description'=>$info['server'], 'version'=>$info['server']); 359 } 360 361 /** 362 * Returns supported query parameter types 363 * @return int bitmask of accepted SQL_PARAMS_* 364 */ 365 protected function allowed_param_types() { 366 return SQL_PARAMS_DOLLAR; 367 } 368 369 /** 370 * Returns last error reported by database engine. 371 * @return string error message 372 */ 373 public function get_last_error() { 374 return pg_last_error($this->pgsql); 375 } 376 377 /** 378 * Return tables in database WITHOUT current prefix. 379 * @param bool $usecache if true, returns list of cached tables. 380 * @return array of table names in lowercase and without prefix 381 */ 382 public function get_tables($usecache=true) { 383 if ($usecache and $this->tables !== null) { 384 return $this->tables; 385 } 386 $this->tables = array(); 387 $prefix = str_replace('_', '|_', $this->prefix); 388 $sql = "SELECT c.relname 389 FROM pg_catalog.pg_class c 390 JOIN pg_catalog.pg_namespace as ns ON ns.oid = c.relnamespace 391 WHERE c.relname LIKE '$prefix%' ESCAPE '|' 392 AND c.relkind = 'r' 393 AND (ns.nspname = current_schema() OR ns.oid = pg_my_temp_schema())"; 394 $this->query_start($sql, null, SQL_QUERY_AUX); 395 $result = pg_query($this->pgsql, $sql); 396 $this->query_end($result); 397 398 if ($result) { 399 while ($row = pg_fetch_row($result)) { 400 $tablename = reset($row); 401 if ($this->prefix !== false && $this->prefix !== '') { 402 if (strpos($tablename, $this->prefix) !== 0) { 403 continue; 404 } 405 $tablename = substr($tablename, strlen($this->prefix)); 406 } 407 $this->tables[$tablename] = $tablename; 408 } 409 pg_free_result($result); 410 } 411 return $this->tables; 412 } 413 414 /** 415 * Return table indexes - everything lowercased. 416 * @param string $table The table we want to get indexes from. 417 * @return array of arrays 418 */ 419 public function get_indexes($table) { 420 $indexes = array(); 421 $tablename = $this->prefix.$table; 422 423 $sql = "SELECT i.* 424 FROM pg_catalog.pg_indexes i 425 JOIN pg_catalog.pg_namespace as ns ON ns.nspname = i.schemaname 426 WHERE i.tablename = '$tablename' 427 AND (i.schemaname = current_schema() OR ns.oid = pg_my_temp_schema())"; 428 429 $this->query_start($sql, null, SQL_QUERY_AUX); 430 $result = pg_query($this->pgsql, $sql); 431 $this->query_end($result); 432 433 if ($result) { 434 while ($row = pg_fetch_assoc($result)) { 435 // The index definition could be generated schema-qualifying the target table name 436 // for safety, depending on the pgsql version (CVE-2018-1058). 437 if (!preg_match('/CREATE (|UNIQUE )INDEX ([^\s]+) ON (|'.$row['schemaname'].'\.)'.$tablename.' USING ([^\s]+) \(([^\)]+)\)/i', $row['indexdef'], $matches)) { 438 continue; 439 } 440 if ($matches[5] === 'id') { 441 continue; 442 } 443 $columns = explode(',', $matches[5]); 444 foreach ($columns as $k=>$column) { 445 $column = trim($column); 446 if ($pos = strpos($column, ' ')) { 447 // index type is separated by space 448 $column = substr($column, 0, $pos); 449 } 450 $columns[$k] = $this->trim_quotes($column); 451 } 452 $indexes[$row['indexname']] = array('unique'=>!empty($matches[1]), 453 'columns'=>$columns); 454 } 455 pg_free_result($result); 456 } 457 return $indexes; 458 } 459 460 /** 461 * Returns detailed information about columns in table. 462 * 463 * @param string $table name 464 * @return database_column_info[] array of database_column_info objects indexed with column names 465 */ 466 protected function fetch_columns(string $table): array { 467 $structure = array(); 468 469 $tablename = $this->prefix.$table; 470 471 $sql = "SELECT a.attnum, a.attname AS field, t.typname AS type, a.attlen, a.atttypmod, a.attnotnull, a.atthasdef, 472 CASE WHEN a.atthasdef THEN pg_catalog.pg_get_expr(d.adbin, d.adrelid) END AS adsrc 473 FROM pg_catalog.pg_class c 474 JOIN pg_catalog.pg_namespace as ns ON ns.oid = c.relnamespace 475 JOIN pg_catalog.pg_attribute a ON a.attrelid = c.oid 476 JOIN pg_catalog.pg_type t ON t.oid = a.atttypid 477 LEFT JOIN pg_catalog.pg_attrdef d ON (d.adrelid = c.oid AND d.adnum = a.attnum) 478 WHERE relkind = 'r' AND c.relname = '$tablename' AND c.reltype > 0 AND a.attnum > 0 479 AND (ns.nspname = current_schema() OR ns.oid = pg_my_temp_schema()) 480 ORDER BY a.attnum"; 481 482 $this->query_start($sql, null, SQL_QUERY_AUX); 483 $result = pg_query($this->pgsql, $sql); 484 $this->query_end($result); 485 486 if (!$result) { 487 return array(); 488 } 489 while ($rawcolumn = pg_fetch_object($result)) { 490 491 $info = new stdClass(); 492 $info->name = $rawcolumn->field; 493 $matches = null; 494 495 if ($rawcolumn->type === 'varchar') { 496 $info->type = 'varchar'; 497 $info->meta_type = 'C'; 498 $info->max_length = $rawcolumn->atttypmod - 4; 499 $info->scale = null; 500 $info->not_null = ($rawcolumn->attnotnull === 't'); 501 $info->has_default = ($rawcolumn->atthasdef === 't'); 502 if ($info->has_default) { 503 $parts = explode('::', $rawcolumn->adsrc); 504 if (count($parts) > 1) { 505 $info->default_value = reset($parts); 506 $info->default_value = trim($info->default_value, "'"); 507 } else { 508 $info->default_value = $rawcolumn->adsrc; 509 } 510 } else { 511 $info->default_value = null; 512 } 513 $info->primary_key = false; 514 $info->binary = false; 515 $info->unsigned = null; 516 $info->auto_increment= false; 517 $info->unique = null; 518 519 } else if (preg_match('/int(\d)/i', $rawcolumn->type, $matches)) { 520 $info->type = 'int'; 521 if (strpos($rawcolumn->adsrc, 'nextval') === 0) { 522 $info->primary_key = true; 523 $info->meta_type = 'R'; 524 $info->unique = true; 525 $info->auto_increment= true; 526 $info->has_default = false; 527 } else { 528 $info->primary_key = false; 529 $info->meta_type = 'I'; 530 $info->unique = null; 531 $info->auto_increment= false; 532 $info->has_default = ($rawcolumn->atthasdef === 't'); 533 } 534 // Return number of decimals, not bytes here. 535 if ($matches[1] >= 8) { 536 $info->max_length = 18; 537 } else if ($matches[1] >= 4) { 538 $info->max_length = 9; 539 } else if ($matches[1] >= 2) { 540 $info->max_length = 4; 541 } else if ($matches[1] >= 1) { 542 $info->max_length = 2; 543 } else { 544 $info->max_length = 0; 545 } 546 $info->scale = null; 547 $info->not_null = ($rawcolumn->attnotnull === 't'); 548 if ($info->has_default) { 549 // PG 9.5+ uses ::<TYPE> syntax for some defaults. 550 $parts = explode('::', $rawcolumn->adsrc); 551 if (count($parts) > 1) { 552 $info->default_value = reset($parts); 553 } else { 554 $info->default_value = $rawcolumn->adsrc; 555 } 556 $info->default_value = trim($info->default_value, "()'"); 557 } else { 558 $info->default_value = null; 559 } 560 $info->binary = false; 561 $info->unsigned = false; 562 563 } else if ($rawcolumn->type === 'numeric') { 564 $info->type = $rawcolumn->type; 565 $info->meta_type = 'N'; 566 $info->primary_key = false; 567 $info->binary = false; 568 $info->unsigned = null; 569 $info->auto_increment= false; 570 $info->unique = null; 571 $info->not_null = ($rawcolumn->attnotnull === 't'); 572 $info->has_default = ($rawcolumn->atthasdef === 't'); 573 if ($info->has_default) { 574 // PG 9.5+ uses ::<TYPE> syntax for some defaults. 575 $parts = explode('::', $rawcolumn->adsrc); 576 if (count($parts) > 1) { 577 $info->default_value = reset($parts); 578 } else { 579 $info->default_value = $rawcolumn->adsrc; 580 } 581 $info->default_value = trim($info->default_value, "()'"); 582 } else { 583 $info->default_value = null; 584 } 585 $info->max_length = $rawcolumn->atttypmod >> 16; 586 $info->scale = ($rawcolumn->atttypmod & 0xFFFF) - 4; 587 588 } else if (preg_match('/float(\d)/i', $rawcolumn->type, $matches)) { 589 $info->type = 'float'; 590 $info->meta_type = 'N'; 591 $info->primary_key = false; 592 $info->binary = false; 593 $info->unsigned = null; 594 $info->auto_increment= false; 595 $info->unique = null; 596 $info->not_null = ($rawcolumn->attnotnull === 't'); 597 $info->has_default = ($rawcolumn->atthasdef === 't'); 598 if ($info->has_default) { 599 // PG 9.5+ uses ::<TYPE> syntax for some defaults. 600 $parts = explode('::', $rawcolumn->adsrc); 601 if (count($parts) > 1) { 602 $info->default_value = reset($parts); 603 } else { 604 $info->default_value = $rawcolumn->adsrc; 605 } 606 $info->default_value = trim($info->default_value, "()'"); 607 } else { 608 $info->default_value = null; 609 } 610 // just guess expected number of deciaml places :-( 611 if ($matches[1] == 8) { 612 // total 15 digits 613 $info->max_length = 8; 614 $info->scale = 7; 615 } else { 616 // total 6 digits 617 $info->max_length = 4; 618 $info->scale = 2; 619 } 620 621 } else if ($rawcolumn->type === 'text') { 622 $info->type = $rawcolumn->type; 623 $info->meta_type = 'X'; 624 $info->max_length = -1; 625 $info->scale = null; 626 $info->not_null = ($rawcolumn->attnotnull === 't'); 627 $info->has_default = ($rawcolumn->atthasdef === 't'); 628 if ($info->has_default) { 629 $parts = explode('::', $rawcolumn->adsrc); 630 if (count($parts) > 1) { 631 $info->default_value = reset($parts); 632 $info->default_value = trim($info->default_value, "'"); 633 } else { 634 $info->default_value = $rawcolumn->adsrc; 635 } 636 } else { 637 $info->default_value = null; 638 } 639 $info->primary_key = false; 640 $info->binary = false; 641 $info->unsigned = null; 642 $info->auto_increment= false; 643 $info->unique = null; 644 645 } else if ($rawcolumn->type === 'bytea') { 646 $info->type = $rawcolumn->type; 647 $info->meta_type = 'B'; 648 $info->max_length = -1; 649 $info->scale = null; 650 $info->not_null = ($rawcolumn->attnotnull === 't'); 651 $info->has_default = false; 652 $info->default_value = null; 653 $info->primary_key = false; 654 $info->binary = true; 655 $info->unsigned = null; 656 $info->auto_increment= false; 657 $info->unique = null; 658 659 } 660 661 $structure[$info->name] = new database_column_info($info); 662 } 663 664 pg_free_result($result); 665 666 return $structure; 667 } 668 669 /** 670 * Normalise values based in RDBMS dependencies (booleans, LOBs...) 671 * 672 * @param database_column_info $column column metadata corresponding with the value we are going to normalise 673 * @param mixed $value value we are going to normalise 674 * @return mixed the normalised value 675 */ 676 protected function normalise_value($column, $value) { 677 $this->detect_objects($value); 678 679 if (is_bool($value)) { // Always, convert boolean to int 680 $value = (int)$value; 681 682 } else if ($column->meta_type === 'B') { 683 if (!is_null($value)) { 684 // standard_conforming_strings must be enabled, otherwise pg_escape_bytea() will double escape 685 // \ and produce data errors. This is set on the connection. 686 $value = pg_escape_bytea($this->pgsql, $value); 687 } 688 689 } else if ($value === '') { 690 if ($column->meta_type === 'I' or $column->meta_type === 'F' or $column->meta_type === 'N') { 691 $value = 0; // prevent '' problems in numeric fields 692 } 693 } 694 return $value; 695 } 696 697 /** 698 * Is db in unicode mode? 699 * @return bool 700 */ 701 public function setup_is_unicodedb() { 702 // Get PostgreSQL server_encoding value 703 $sql = "SHOW server_encoding"; 704 $this->query_start($sql, null, SQL_QUERY_AUX); 705 $result = pg_query($this->pgsql, $sql); 706 $this->query_end($result); 707 708 if (!$result) { 709 return false; 710 } 711 $rawcolumn = pg_fetch_object($result); 712 $encoding = $rawcolumn->server_encoding; 713 pg_free_result($result); 714 715 return (strtoupper($encoding) == 'UNICODE' || strtoupper($encoding) == 'UTF8'); 716 } 717 718 /** 719 * Do NOT use in code, to be used by database_manager only! 720 * @param string|array $sql query 721 * @param array|null $tablenames an array of xmldb table names affected by this request. 722 * @return bool true 723 * @throws ddl_change_structure_exception A DDL specific exception is thrown for any errors. 724 */ 725 public function change_database_structure($sql, $tablenames = null) { 726 $this->get_manager(); // Includes DDL exceptions classes ;-) 727 if (is_array($sql)) { 728 $sql = implode("\n;\n", $sql); 729 } 730 if (!$this->is_transaction_started()) { 731 // It is better to do all or nothing, this helps with recovery... 732 $sql = "BEGIN ISOLATION LEVEL SERIALIZABLE;\n$sql\n; COMMIT"; 733 } 734 735 try { 736 $this->query_start($sql, null, SQL_QUERY_STRUCTURE); 737 $result = pg_query($this->pgsql, $sql); 738 $this->query_end($result); 739 pg_free_result($result); 740 } catch (ddl_change_structure_exception $e) { 741 if (!$this->is_transaction_started()) { 742 $result = @pg_query($this->pgsql, "ROLLBACK"); 743 @pg_free_result($result); 744 } 745 $this->reset_caches($tablenames); 746 throw $e; 747 } 748 749 $this->reset_caches($tablenames); 750 return true; 751 } 752 753 /** 754 * Execute general sql query. Should be used only when no other method suitable. 755 * Do NOT use this to make changes in db structure, use database_manager methods instead! 756 * @param string $sql query 757 * @param array $params query parameters 758 * @return bool true 759 * @throws dml_exception A DML specific exception is thrown for any errors. 760 */ 761 public function execute($sql, array $params=null) { 762 list($sql, $params, $type) = $this->fix_sql_params($sql, $params); 763 764 if (strpos($sql, ';') !== false) { 765 throw new coding_exception('moodle_database::execute() Multiple sql statements found or bound parameters not used properly in query!'); 766 } 767 768 $this->query_start($sql, $params, SQL_QUERY_UPDATE); 769 $result = pg_query_params($this->pgsql, $sql, $params); 770 $this->query_end($result); 771 772 pg_free_result($result); 773 return true; 774 } 775 776 /** 777 * Get a number of records as a moodle_recordset using a SQL statement. 778 * 779 * Since this method is a little less readable, use of it should be restricted to 780 * code where it's possible there might be large datasets being returned. For known 781 * small datasets use get_records_sql - it leads to simpler code. 782 * 783 * The return type is like: 784 * @see function get_recordset. 785 * 786 * @param string $sql the SQL select query to execute. 787 * @param array $params array of sql parameters 788 * @param int $limitfrom return a subset of records, starting at this point (optional, required if $limitnum is set). 789 * @param int $limitnum return a subset comprising this many records (optional, required if $limitfrom is set). 790 * @return moodle_recordset instance 791 * @throws dml_exception A DML specific exception is thrown for any errors. 792 */ 793 public function get_recordset_sql($sql, array $params=null, $limitfrom=0, $limitnum=0) { 794 795 list($limitfrom, $limitnum) = $this->normalise_limit_from_num($limitfrom, $limitnum); 796 797 if ($limitnum) { 798 $sql .= " LIMIT $limitnum"; 799 } 800 if ($limitfrom) { 801 $sql .= " OFFSET $limitfrom"; 802 } 803 804 list($sql, $params, $type) = $this->fix_sql_params($sql, $params); 805 806 // For any query that doesn't explicitly specify a limit, we must use cursors to stop it 807 // loading the entire thing (unless the config setting is turned off). 808 $usecursors = !$limitnum && ($this->get_fetch_buffer_size() > 0); 809 if ($usecursors) { 810 // Work out the cursor unique identifer. This is based on a simple count used which 811 // should be OK because the identifiers only need to be unique within the current 812 // transaction. 813 $this->cursorcount++; 814 $cursorname = 'crs' . $this->cursorcount; 815 816 // Do the query to a cursor. 817 $sql = 'DECLARE ' . $cursorname . ' NO SCROLL CURSOR WITH HOLD FOR ' . $sql; 818 } else { 819 $cursorname = ''; 820 } 821 822 $this->query_start($sql, $params, SQL_QUERY_SELECT); 823 824 $result = pg_query_params($this->pgsql, $sql, $params); 825 826 $this->query_end($result); 827 if ($usecursors) { 828 pg_free_result($result); 829 $result = null; 830 } 831 832 return new pgsql_native_moodle_recordset($result, $this, $cursorname); 833 } 834 835 /** 836 * Gets size of fetch buffer used for recordset queries. 837 * 838 * If this returns 0 then cursors will not be used, meaning recordset queries will occupy enough 839 * memory as needed for the Postgres library to hold the entire query results in memory. 840 * 841 * @return int Fetch buffer size or 0 indicating not to use cursors 842 */ 843 protected function get_fetch_buffer_size() { 844 if (array_key_exists('fetchbuffersize', $this->dboptions)) { 845 return (int)$this->dboptions['fetchbuffersize']; 846 } else { 847 return self::DEFAULT_FETCH_BUFFER_SIZE; 848 } 849 } 850 851 /** 852 * Retrieves data from cursor. For use by recordset only; do not call directly. 853 * 854 * Return value contains the next batch of Postgres data, and a boolean indicating if this is 855 * definitely the last batch (if false, there may be more) 856 * 857 * @param string $cursorname Name of cursor to read from 858 * @return array Array with 2 elements (next data batch and boolean indicating last batch) 859 */ 860 public function fetch_from_cursor($cursorname) { 861 $count = $this->get_fetch_buffer_size(); 862 863 $sql = 'FETCH ' . $count . ' FROM ' . $cursorname; 864 865 $this->query_start($sql, [], SQL_QUERY_AUX); 866 $result = pg_query($this->pgsql, $sql); 867 $last = pg_num_rows($result) !== $count; 868 869 $this->query_end($result); 870 871 return [$result, $last]; 872 } 873 874 /** 875 * Closes a cursor. For use by recordset only; do not call directly. 876 * 877 * @param string $cursorname Name of cursor to close 878 * @return bool True if we actually closed one, false if the transaction was cancelled 879 */ 880 public function close_cursor($cursorname) { 881 // If the transaction got cancelled, then ignore this request. 882 $sql = 'CLOSE ' . $cursorname; 883 $this->query_start($sql, [], SQL_QUERY_AUX); 884 $result = pg_query($this->pgsql, $sql); 885 $this->query_end($result); 886 if ($result) { 887 pg_free_result($result); 888 } 889 return true; 890 } 891 892 /** 893 * Get a number of records as an array of objects using a SQL statement. 894 * 895 * Return value is like: 896 * @see function get_records. 897 * 898 * @param string $sql the SQL select query to execute. The first column of this SELECT statement 899 * must be a unique value (usually the 'id' field), as it will be used as the key of the 900 * returned array. 901 * @param array $params array of sql parameters 902 * @param int $limitfrom return a subset of records, starting at this point (optional, required if $limitnum is set). 903 * @param int $limitnum return a subset comprising this many records (optional, required if $limitfrom is set). 904 * @return array of objects, or empty array if no records were found 905 * @throws dml_exception A DML specific exception is thrown for any errors. 906 */ 907 public function get_records_sql($sql, array $params = null, $limitfrom = 0, $limitnum = 0) { 908 list($limitfrom, $limitnum) = $this->normalise_limit_from_num($limitfrom, $limitnum); 909 910 if ($limitnum) { 911 $sql .= " LIMIT $limitnum"; 912 } 913 if ($limitfrom) { 914 $sql .= " OFFSET $limitfrom"; 915 } 916 917 list($sql, $params, $type) = $this->fix_sql_params($sql, $params); 918 $this->query_start($sql, $params, SQL_QUERY_SELECT); 919 $result = pg_query_params($this->pgsql, $sql, $params); 920 $this->query_end($result); 921 922 // find out if there are any blobs 923 $numfields = pg_num_fields($result); 924 $blobs = array(); 925 for ($i = 0; $i < $numfields; $i++) { 926 $type = pg_field_type($result, $i); 927 if ($type == 'bytea') { 928 $blobs[] = pg_field_name($result, $i); 929 } 930 } 931 932 $return = []; 933 while ($row = pg_fetch_assoc($result)) { 934 $id = reset($row); 935 if ($blobs) { 936 foreach ($blobs as $blob) { 937 $row[$blob] = ($row[$blob] !== null ? pg_unescape_bytea($row[$blob]) : null); 938 } 939 } 940 if (isset($return[$id])) { 941 $colname = key($row); 942 debugging("Did you remember to make the first column something unique in your call to get_records? Duplicate value '$id' found in column '$colname'.", DEBUG_DEVELOPER); 943 } 944 $return[$id] = (object) $row; 945 } 946 947 return $return; 948 } 949 950 /** 951 * Selects records and return values (first field) as an array using a SQL statement. 952 * 953 * @param string $sql The SQL query 954 * @param array $params array of sql parameters 955 * @return array of values 956 * @throws dml_exception A DML specific exception is thrown for any errors. 957 */ 958 public function get_fieldset_sql($sql, array $params=null) { 959 list($sql, $params, $type) = $this->fix_sql_params($sql, $params); 960 961 $this->query_start($sql, $params, SQL_QUERY_SELECT); 962 $result = pg_query_params($this->pgsql, $sql, $params); 963 $this->query_end($result); 964 965 $return = pg_fetch_all_columns($result, 0); 966 967 if (pg_field_type($result, 0) == 'bytea') { 968 foreach ($return as $key => $value) { 969 $return[$key] = ($value === null ? $value : pg_unescape_bytea($value)); 970 } 971 } 972 973 pg_free_result($result); 974 975 return $return; 976 } 977 978 /** 979 * Insert new record into database, as fast as possible, no safety checks, lobs not supported. 980 * @param string $table name 981 * @param mixed $params data record as object or array 982 * @param bool $returnit return it of inserted record 983 * @param bool $bulk true means repeated inserts expected 984 * @param bool $customsequence true if 'id' included in $params, disables $returnid 985 * @return bool|int true or new id 986 * @throws dml_exception A DML specific exception is thrown for any errors. 987 */ 988 public function insert_record_raw($table, $params, $returnid=true, $bulk=false, $customsequence=false) { 989 if (!is_array($params)) { 990 $params = (array)$params; 991 } 992 993 $returning = ""; 994 995 if ($customsequence) { 996 if (!isset($params['id'])) { 997 throw new coding_exception('moodle_database::insert_record_raw() id field must be specified if custom sequences used.'); 998 } 999 $returnid = false; 1000 } else { 1001 if ($returnid) { 1002 $returning = "RETURNING id"; 1003 unset($params['id']); 1004 } else { 1005 unset($params['id']); 1006 } 1007 } 1008 1009 if (empty($params)) { 1010 throw new coding_exception('moodle_database::insert_record_raw() no fields found.'); 1011 } 1012 1013 $fields = implode(',', array_keys($params)); 1014 $values = array(); 1015 $i = 1; 1016 foreach ($params as $value) { 1017 $this->detect_objects($value); 1018 $values[] = "\$".$i++; 1019 } 1020 $values = implode(',', $values); 1021 1022 $sql = "INSERT INTO {$this->prefix}$table ($fields) VALUES($values) $returning"; 1023 $this->query_start($sql, $params, SQL_QUERY_INSERT); 1024 $result = pg_query_params($this->pgsql, $sql, $params); 1025 $this->query_end($result); 1026 1027 if ($returning !== "") { 1028 $row = pg_fetch_assoc($result); 1029 $params['id'] = reset($row); 1030 } 1031 pg_free_result($result); 1032 1033 if (!$returnid) { 1034 return true; 1035 } 1036 1037 return (int)$params['id']; 1038 } 1039 1040 /** 1041 * Insert a record into a table and return the "id" field if required. 1042 * 1043 * Some conversions and safety checks are carried out. Lobs are supported. 1044 * If the return ID isn't required, then this just reports success as true/false. 1045 * $data is an object containing needed data 1046 * @param string $table The database table to be inserted into 1047 * @param object|array $dataobject A data object with values for one or more fields in the record 1048 * @param bool $returnid Should the id of the newly created record entry be returned? If this option is not requested then true/false is returned. 1049 * @return bool|int true or new id 1050 * @throws dml_exception A DML specific exception is thrown for any errors. 1051 */ 1052 public function insert_record($table, $dataobject, $returnid=true, $bulk=false) { 1053 $dataobject = (array)$dataobject; 1054 1055 $columns = $this->get_columns($table); 1056 if (empty($columns)) { 1057 throw new dml_exception('ddltablenotexist', $table); 1058 } 1059 1060 $cleaned = array(); 1061 1062 foreach ($dataobject as $field=>$value) { 1063 if ($field === 'id') { 1064 continue; 1065 } 1066 if (!isset($columns[$field])) { 1067 continue; 1068 } 1069 $column = $columns[$field]; 1070 $cleaned[$field] = $this->normalise_value($column, $value); 1071 } 1072 1073 return $this->insert_record_raw($table, $cleaned, $returnid, $bulk); 1074 1075 } 1076 1077 /** 1078 * Insert multiple records into database as fast as possible. 1079 * 1080 * Order of inserts is maintained, but the operation is not atomic, 1081 * use transactions if necessary. 1082 * 1083 * This method is intended for inserting of large number of small objects, 1084 * do not use for huge objects with text or binary fields. 1085 * 1086 * @since Moodle 2.7 1087 * 1088 * @param string $table The database table to be inserted into 1089 * @param array|Traversable $dataobjects list of objects to be inserted, must be compatible with foreach 1090 * @return void does not return new record ids 1091 * 1092 * @throws coding_exception if data objects have different structure 1093 * @throws dml_exception A DML specific exception is thrown for any errors. 1094 */ 1095 public function insert_records($table, $dataobjects) { 1096 if (!is_array($dataobjects) and !($dataobjects instanceof Traversable)) { 1097 throw new coding_exception('insert_records() passed non-traversable object'); 1098 } 1099 1100 // PostgreSQL does not seem to have problems with huge queries. 1101 $chunksize = 500; 1102 if (!empty($this->dboptions['bulkinsertsize'])) { 1103 $chunksize = (int)$this->dboptions['bulkinsertsize']; 1104 } 1105 1106 $columns = $this->get_columns($table, true); 1107 1108 $fields = null; 1109 $count = 0; 1110 $chunk = array(); 1111 foreach ($dataobjects as $dataobject) { 1112 if (!is_array($dataobject) and !is_object($dataobject)) { 1113 throw new coding_exception('insert_records() passed invalid record object'); 1114 } 1115 $dataobject = (array)$dataobject; 1116 if ($fields === null) { 1117 $fields = array_keys($dataobject); 1118 $columns = array_intersect_key($columns, $dataobject); 1119 unset($columns['id']); 1120 } else if ($fields !== array_keys($dataobject)) { 1121 throw new coding_exception('All dataobjects in insert_records() must have the same structure!'); 1122 } 1123 1124 $count++; 1125 $chunk[] = $dataobject; 1126 1127 if ($count === $chunksize) { 1128 $this->insert_chunk($table, $chunk, $columns); 1129 $chunk = array(); 1130 $count = 0; 1131 } 1132 } 1133 1134 if ($count) { 1135 $this->insert_chunk($table, $chunk, $columns); 1136 } 1137 } 1138 1139 /** 1140 * Insert records in chunks, strict param types... 1141 * 1142 * Note: can be used only from insert_records(). 1143 * 1144 * @param string $table 1145 * @param array $chunk 1146 * @param database_column_info[] $columns 1147 */ 1148 protected function insert_chunk($table, array $chunk, array $columns) { 1149 $i = 1; 1150 $params = array(); 1151 $values = array(); 1152 foreach ($chunk as $dataobject) { 1153 $vals = array(); 1154 foreach ($columns as $field => $column) { 1155 $params[] = $this->normalise_value($column, $dataobject[$field]); 1156 $vals[] = "\$".$i++; 1157 } 1158 $values[] = '('.implode(',', $vals).')'; 1159 } 1160 1161 $fieldssql = '('.implode(',', array_keys($columns)).')'; 1162 $valuessql = implode(',', $values); 1163 1164 $sql = "INSERT INTO {$this->prefix}$table $fieldssql VALUES $valuessql"; 1165 $this->query_start($sql, $params, SQL_QUERY_INSERT); 1166 $result = pg_query_params($this->pgsql, $sql, $params); 1167 $this->query_end($result); 1168 pg_free_result($result); 1169 } 1170 1171 /** 1172 * Import a record into a table, id field is required. 1173 * Safety checks are NOT carried out. Lobs are supported. 1174 * 1175 * @param string $table name of database table to be inserted into 1176 * @param object $dataobject A data object with values for one or more fields in the record 1177 * @return bool true 1178 * @throws dml_exception A DML specific exception is thrown for any errors. 1179 */ 1180 public function import_record($table, $dataobject) { 1181 $dataobject = (array)$dataobject; 1182 1183 $columns = $this->get_columns($table); 1184 $cleaned = array(); 1185 1186 foreach ($dataobject as $field=>$value) { 1187 $this->detect_objects($value); 1188 if (!isset($columns[$field])) { 1189 continue; 1190 } 1191 $column = $columns[$field]; 1192 $cleaned[$field] = $this->normalise_value($column, $value); 1193 } 1194 1195 return $this->insert_record_raw($table, $cleaned, false, true, true); 1196 } 1197 1198 /** 1199 * Update record in database, as fast as possible, no safety checks, lobs not supported. 1200 * @param string $table name 1201 * @param mixed $params data record as object or array 1202 * @param bool true means repeated updates expected 1203 * @return bool true 1204 * @throws dml_exception A DML specific exception is thrown for any errors. 1205 */ 1206 public function update_record_raw($table, $params, $bulk=false) { 1207 $params = (array)$params; 1208 1209 if (!isset($params['id'])) { 1210 throw new coding_exception('moodle_database::update_record_raw() id field must be specified.'); 1211 } 1212 $id = $params['id']; 1213 unset($params['id']); 1214 1215 if (empty($params)) { 1216 throw new coding_exception('moodle_database::update_record_raw() no fields found.'); 1217 } 1218 1219 $i = 1; 1220 1221 $sets = array(); 1222 foreach ($params as $field=>$value) { 1223 $this->detect_objects($value); 1224 $sets[] = "$field = \$".$i++; 1225 } 1226 1227 $params[] = $id; // last ? in WHERE condition 1228 1229 $sets = implode(',', $sets); 1230 $sql = "UPDATE {$this->prefix}$table SET $sets WHERE id=\$".$i; 1231 1232 $this->query_start($sql, $params, SQL_QUERY_UPDATE); 1233 $result = pg_query_params($this->pgsql, $sql, $params); 1234 $this->query_end($result); 1235 1236 pg_free_result($result); 1237 return true; 1238 } 1239 1240 /** 1241 * Update a record in a table 1242 * 1243 * $dataobject is an object containing needed data 1244 * Relies on $dataobject having a variable "id" to 1245 * specify the record to update 1246 * 1247 * @param string $table The database table to be checked against. 1248 * @param object $dataobject An object with contents equal to fieldname=>fieldvalue. Must have an entry for 'id' to map to the table specified. 1249 * @param bool true means repeated updates expected 1250 * @return bool true 1251 * @throws dml_exception A DML specific exception is thrown for any errors. 1252 */ 1253 public function update_record($table, $dataobject, $bulk=false) { 1254 $dataobject = (array)$dataobject; 1255 1256 $columns = $this->get_columns($table); 1257 $cleaned = array(); 1258 1259 foreach ($dataobject as $field=>$value) { 1260 if (!isset($columns[$field])) { 1261 continue; 1262 } 1263 $column = $columns[$field]; 1264 $cleaned[$field] = $this->normalise_value($column, $value); 1265 } 1266 1267 $this->update_record_raw($table, $cleaned, $bulk); 1268 1269 return true; 1270 } 1271 1272 /** 1273 * Set a single field in every table record which match a particular WHERE clause. 1274 * 1275 * @param string $table The database table to be checked against. 1276 * @param string $newfield the field to set. 1277 * @param string $newvalue the value to set the field to. 1278 * @param string $select A fragment of SQL to be used in a where clause in the SQL call. 1279 * @param array $params array of sql parameters 1280 * @return bool true 1281 * @throws dml_exception A DML specific exception is thrown for any errors. 1282 */ 1283 public function set_field_select($table, $newfield, $newvalue, $select, array $params=null) { 1284 1285 if ($select) { 1286 $select = "WHERE $select"; 1287 } 1288 if (is_null($params)) { 1289 $params = array(); 1290 } 1291 list($select, $params, $type) = $this->fix_sql_params($select, $params); 1292 $i = count($params)+1; 1293 1294 // Get column metadata 1295 $columns = $this->get_columns($table); 1296 $column = $columns[$newfield]; 1297 1298 $normalisedvalue = $this->normalise_value($column, $newvalue); 1299 1300 $newfield = "$newfield = \$" . $i; 1301 $params[] = $normalisedvalue; 1302 $sql = "UPDATE {$this->prefix}$table SET $newfield $select"; 1303 1304 $this->query_start($sql, $params, SQL_QUERY_UPDATE); 1305 $result = pg_query_params($this->pgsql, $sql, $params); 1306 $this->query_end($result); 1307 1308 pg_free_result($result); 1309 1310 return true; 1311 } 1312 1313 /** 1314 * Delete one or more records from a table which match a particular WHERE clause, lobs not supported. 1315 * 1316 * @param string $table The database table to be checked against. 1317 * @param string $select A fragment of SQL to be used in a where clause in the SQL call (used to define the selection criteria). 1318 * @param array $params array of sql parameters 1319 * @return bool true 1320 * @throws dml_exception A DML specific exception is thrown for any errors. 1321 */ 1322 public function delete_records_select($table, $select, array $params=null) { 1323 if ($select) { 1324 $select = "WHERE $select"; 1325 } 1326 $sql = "DELETE FROM {$this->prefix}$table $select"; 1327 1328 list($sql, $params, $type) = $this->fix_sql_params($sql, $params); 1329 1330 $this->query_start($sql, $params, SQL_QUERY_UPDATE); 1331 $result = pg_query_params($this->pgsql, $sql, $params); 1332 $this->query_end($result); 1333 1334 pg_free_result($result); 1335 1336 return true; 1337 } 1338 1339 /** 1340 * Returns 'LIKE' part of a query. 1341 * 1342 * @param string $fieldname usually name of the table column 1343 * @param string $param usually bound query parameter (?, :named) 1344 * @param bool $casesensitive use case sensitive search 1345 * @param bool $accensensitive use accent sensitive search (not all databases support accent insensitive) 1346 * @param bool $notlike true means "NOT LIKE" 1347 * @param string $escapechar escape char for '%' and '_' 1348 * @return string SQL code fragment 1349 */ 1350 public function sql_like($fieldname, $param, $casesensitive = true, $accentsensitive = true, $notlike = false, $escapechar = '\\') { 1351 if (strpos($param, '%') !== false) { 1352 debugging('Potential SQL injection detected, sql_like() expects bound parameters (? or :named)'); 1353 } 1354 1355 // postgresql does not support accent insensitive text comparisons, sorry 1356 if ($casesensitive) { 1357 $LIKE = $notlike ? 'NOT LIKE' : 'LIKE'; 1358 } else { 1359 $LIKE = $notlike ? 'NOT ILIKE' : 'ILIKE'; 1360 } 1361 return "$fieldname $LIKE $param ESCAPE '$escapechar'"; 1362 } 1363 1364 public function sql_bitxor($int1, $int2) { 1365 return '((' . $int1 . ') # (' . $int2 . '))'; 1366 } 1367 1368 public function sql_cast_char2int($fieldname, $text=false) { 1369 return ' CAST(' . $fieldname . ' AS INT) '; 1370 } 1371 1372 public function sql_cast_char2real($fieldname, $text=false) { 1373 return " $fieldname::real "; 1374 } 1375 1376 public function sql_concat() { 1377 $arr = func_get_args(); 1378 $s = implode(' || ', $arr); 1379 if ($s === '') { 1380 return " '' "; 1381 } 1382 // Add always empty string element so integer-exclusive concats 1383 // will work without needing to cast each element explicitly 1384 return " '' || $s "; 1385 } 1386 1387 public function sql_concat_join($separator="' '", $elements=array()) { 1388 for ($n=count($elements)-1; $n > 0 ; $n--) { 1389 array_splice($elements, $n, 0, $separator); 1390 } 1391 $s = implode(' || ', $elements); 1392 if ($s === '') { 1393 return " '' "; 1394 } 1395 return " $s "; 1396 } 1397 1398 public function sql_regex_supported() { 1399 return true; 1400 } 1401 1402 public function sql_regex($positivematch = true, $casesensitive = false) { 1403 if ($casesensitive) { 1404 return $positivematch ? '~' : '!~'; 1405 } else { 1406 return $positivematch ? '~*' : '!~*'; 1407 } 1408 } 1409 1410 /** 1411 * Does this driver support tool_replace? 1412 * 1413 * @since Moodle 2.6.1 1414 * @return bool 1415 */ 1416 public function replace_all_text_supported() { 1417 return true; 1418 } 1419 1420 public function session_lock_supported() { 1421 return true; 1422 } 1423 1424 /** 1425 * Obtain session lock 1426 * @param int $rowid id of the row with session record 1427 * @param int $timeout max allowed time to wait for the lock in seconds 1428 * @return bool success 1429 */ 1430 public function get_session_lock($rowid, $timeout) { 1431 // NOTE: there is a potential locking problem for database running 1432 // multiple instances of moodle, we could try to use pg_advisory_lock(int, int), 1433 // luckily there is not a big chance that they would collide 1434 if (!$this->session_lock_supported()) { 1435 return; 1436 } 1437 1438 parent::get_session_lock($rowid, $timeout); 1439 1440 $timeoutmilli = $timeout * 1000; 1441 1442 $sql = "SET statement_timeout TO $timeoutmilli"; 1443 $this->query_start($sql, null, SQL_QUERY_AUX); 1444 $result = pg_query($this->pgsql, $sql); 1445 $this->query_end($result); 1446 1447 if ($result) { 1448 pg_free_result($result); 1449 } 1450 1451 $sql = "SELECT pg_advisory_lock($rowid)"; 1452 $this->query_start($sql, null, SQL_QUERY_AUX); 1453 $start = time(); 1454 $result = pg_query($this->pgsql, $sql); 1455 $end = time(); 1456 try { 1457 $this->query_end($result); 1458 } catch (dml_exception $ex) { 1459 if ($end - $start >= $timeout) { 1460 throw new dml_sessionwait_exception(); 1461 } else { 1462 throw $ex; 1463 } 1464 } 1465 1466 if ($result) { 1467 pg_free_result($result); 1468 } 1469 1470 $sql = "SET statement_timeout TO DEFAULT"; 1471 $this->query_start($sql, null, SQL_QUERY_AUX); 1472 $result = pg_query($this->pgsql, $sql); 1473 $this->query_end($result); 1474 1475 if ($result) { 1476 pg_free_result($result); 1477 } 1478 } 1479 1480 public function release_session_lock($rowid) { 1481 if (!$this->session_lock_supported()) { 1482 return; 1483 } 1484 if (!$this->used_for_db_sessions) { 1485 return; 1486 } 1487 1488 parent::release_session_lock($rowid); 1489 1490 $sql = "SELECT pg_advisory_unlock($rowid)"; 1491 $this->query_start($sql, null, SQL_QUERY_AUX); 1492 $result = pg_query($this->pgsql, $sql); 1493 $this->query_end($result); 1494 1495 if ($result) { 1496 pg_free_result($result); 1497 } 1498 } 1499 1500 /** 1501 * Driver specific start of real database transaction, 1502 * this can not be used directly in code. 1503 * @return void 1504 */ 1505 protected function begin_transaction() { 1506 $this->savepointpresent = true; 1507 $sql = "BEGIN ISOLATION LEVEL READ COMMITTED; SAVEPOINT moodle_pg_savepoint"; 1508 $this->query_start($sql, null, SQL_QUERY_AUX); 1509 $result = pg_query($this->pgsql, $sql); 1510 $this->query_end($result); 1511 1512 pg_free_result($result); 1513 } 1514 1515 /** 1516 * Driver specific commit of real database transaction, 1517 * this can not be used directly in code. 1518 * @return void 1519 */ 1520 protected function commit_transaction() { 1521 $this->savepointpresent = false; 1522 $sql = "RELEASE SAVEPOINT moodle_pg_savepoint; COMMIT"; 1523 $this->query_start($sql, null, SQL_QUERY_AUX); 1524 $result = pg_query($this->pgsql, $sql); 1525 $this->query_end($result); 1526 1527 pg_free_result($result); 1528 } 1529 1530 /** 1531 * Driver specific abort of real database transaction, 1532 * this can not be used directly in code. 1533 * @return void 1534 */ 1535 protected function rollback_transaction() { 1536 $this->savepointpresent = false; 1537 $sql = "RELEASE SAVEPOINT moodle_pg_savepoint; ROLLBACK"; 1538 $this->query_start($sql, null, SQL_QUERY_AUX); 1539 $result = pg_query($this->pgsql, $sql); 1540 $this->query_end($result); 1541 1542 pg_free_result($result); 1543 } 1544 1545 /** 1546 * Helper function trimming (whitespace + quotes) any string 1547 * needed because PG uses to enclose with double quotes some 1548 * fields in indexes definition and others 1549 * 1550 * @param string $str string to apply whitespace + quotes trim 1551 * @return string trimmed string 1552 */ 1553 private function trim_quotes($str) { 1554 return trim(trim($str), "'\""); 1555 } 1556 1557 /** 1558 * Postgresql supports full-text search indexes. 1559 * 1560 * @return bool 1561 */ 1562 public function is_fulltext_search_supported() { 1563 return true; 1564 } 1565 }
title
Description
Body
title
Description
Body
title
Description
Body
title
Body
