Search moodle.org's
Developer Documentation

See Release Notes
Long Term Support Release

  • Bug fixes for general core bugs in 3.9.x will end* 10 May 2021 (12 months).
  • Bug fixes for security issues in 3.9.x will end* 8 May 2023 (36 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.

Differences Between: [Versions 39 and 311] [Versions 39 and 400] [Versions 39 and 401] [Versions 39 and 402] [Versions 39 and 403]

   1  <?php
   2  /*
   3  
   4    @version   v5.20.16  12-Jan-2020
   5    @copyright (c) 2000-2013 John Lim. All rights reserved.
   6    @copyright (c) 2014      Damien Regad, Mark Newnham and the ADOdb community
   7  
   8    Released under both BSD license and Lesser GPL library license.
   9    Whenever there is any discrepancy between the two licenses,
  10    the BSD license will take precedence.
  11  
  12    Latest version is available at http://adodb.org/
  13  
  14    Code contributed by George Fourlanos <fou@infomap.gr>
  15  
  16    13 Nov 2000 jlim - removed all ora_* references.
  17  */
  18  
  19  // security - hide paths
  20  if (!defined('ADODB_DIR')) die();
  21  
  22  /*
  23  NLS_Date_Format
  24  Allows you to use a date format other than the Oracle Lite default. When a literal
  25  character string appears where a date value is expected, the Oracle Lite database
  26  tests the string to see if it matches the formats of Oracle, SQL-92, or the value
  27  specified for this parameter in the POLITE.INI file. Setting this parameter also
  28  defines the default format used in the TO_CHAR or TO_DATE functions when no
  29  other format string is supplied.
  30  
  31  For Oracle the default is dd-mon-yy or dd-mon-yyyy, and for SQL-92 the default is
  32  yy-mm-dd or yyyy-mm-dd.
  33  
  34  Using 'RR' in the format forces two-digit years less than or equal to 49 to be
  35  interpreted as years in the 21st century (2000-2049), and years over 50 as years in
  36  the 20th century (1950-1999). Setting the RR format as the default for all two-digit
  37  year entries allows you to become year-2000 compliant. For example:
  38  NLS_DATE_FORMAT='RR-MM-DD'
  39  
  40  You can also modify the date format using the ALTER SESSION command.
  41  */
  42  
  43  # define the LOB descriptor type for the given type
  44  # returns false if no LOB descriptor
  45  function oci_lob_desc($type) {
  46  	 switch ($type) {
  47  	 	 case OCI_B_BFILE:  return OCI_D_FILE;
  48  	 	 case OCI_B_CFILEE: return OCI_D_FILE;
  49  	 	 case OCI_B_CLOB:   return OCI_D_LOB;
  50  	 	 case OCI_B_BLOB:   return OCI_D_LOB;
  51  	 	 case OCI_B_ROWID:  return OCI_D_ROWID;
  52  	 }
  53  	 return false;
  54  }
  55  
  56  class ADODB_oci8 extends ADOConnection {
  57  	 var $databaseType = 'oci8';
  58  	 var $dataProvider = 'oci8';
  59  	 var $replaceQuote = "''"; // string to use to replace quotes
  60  	 var $concat_operator='||';
  61  	 var $sysDate = "TRUNC(SYSDATE)";
  62  	 var $sysTimeStamp = 'SYSDATE'; // requires oracle 9 or later, otherwise use SYSDATE
  63  	 var $metaDatabasesSQL = "SELECT USERNAME FROM ALL_USERS WHERE USERNAME NOT IN ('SYS','SYSTEM','DBSNMP','OUTLN') ORDER BY 1";
  64  	 var $_stmt;
  65  	 var $_commit = OCI_COMMIT_ON_SUCCESS;
  66  	 var $_initdate = true; // init date to YYYY-MM-DD
  67  	 var $metaTablesSQL = "select table_name,table_type from cat where table_type in ('TABLE','VIEW') and table_name not like 'BIN\$%'"; // bin$ tables are recycle bin tables
  68  	 var $metaColumnsSQL = "select cname,coltype,width, SCALE, PRECISION, NULLS, DEFAULTVAL from col where tname='%s' order by colno"; //changed by smondino@users.sourceforge. net
  69  	 var $metaColumnsSQL2 = "select column_name,data_type,data_length, data_scale, data_precision,
  70      case when nullable = 'Y' then 'NULL'
  71      else 'NOT NULL' end as nulls,
  72      data_default from all_tab_cols
  73    where owner='%s' and table_name='%s' order by column_id"; // when there is a schema
  74  	 var $_bindInputArray = true;
  75  	 var $hasGenID = true;
  76  	 var $_genIDSQL = "SELECT (%s.nextval) FROM DUAL";
  77  	 var $_genSeqSQL = "
  78  DECLARE
  79  	 PRAGMA AUTONOMOUS_TRANSACTION;
  80  BEGIN
  81  	 execute immediate 'CREATE SEQUENCE %s START WITH %s';
  82  END;
  83  ";
  84  
  85  	 var $_dropSeqSQL = "DROP SEQUENCE %s";
  86  	 var $hasAffectedRows = true;
  87  	 var $random = "abs(mod(DBMS_RANDOM.RANDOM,10000001)/10000000)";
  88  	 var $noNullStrings = false;
  89  	 var $connectSID = false;
  90  	 var $_bind = false;
  91  	 var $_nestedSQL = true;
  92  	 var $_hasOciFetchStatement = false;
  93  	 var $_getarray = false; // currently not working
  94  	 var $leftOuter = '';  // oracle wierdness, $col = $value (+) for LEFT OUTER, $col (+)= $value for RIGHT OUTER
  95  	 var $session_sharing_force_blob = false; // alter session on updateblob if set to true
  96  	 var $firstrows = true; // enable first rows optimization on SelectLimit()
  97  	 var $selectOffsetAlg1 = 1000; // when to use 1st algorithm of selectlimit.
  98  	 var $NLS_DATE_FORMAT = 'YYYY-MM-DD';  // To include time, use 'RRRR-MM-DD HH24:MI:SS'
  99  	 var $dateformat = 'YYYY-MM-DD'; // DBDate format
 100  	 var $useDBDateFormatForTextInput=false;
 101  	 var $datetime = false; // MetaType('DATE') returns 'D' (datetime==false) or 'T' (datetime == true)
 102  	 var $_refLOBs = array();
 103  
 104  	 // var $ansiOuter = true; // if oracle9
 105  
 106  	function __construct()
 107  	 {
 108  	 	 $this->_hasOciFetchStatement = ADODB_PHPVER >= 0x4200;
 109  	 	 if (defined('ADODB_EXTENSION')) {
 110  	 	 	 $this->rsPrefix .= 'ext_';
 111  	 	 }
 112  	 }
 113  
 114  	 /*  function MetaColumns($table, $normalize=true) added by smondino@users.sourceforge.net*/
 115  	function MetaColumns($table, $normalize=true)
 116  	 {
 117  	 global $ADODB_FETCH_MODE;
 118  
 119  	 	 $schema = '';
 120  	 	 $this->_findschema($table, $schema);
 121  
 122  	 	 $save = $ADODB_FETCH_MODE;
 123  	 	 $ADODB_FETCH_MODE = ADODB_FETCH_NUM;
 124  	 	 if ($this->fetchMode !== false) {
 125  	 	 	 $savem = $this->SetFetchMode(false);
 126  	 	 }
 127  
 128  	 	 if ($schema){
 129  	 	 	 $rs = $this->Execute(sprintf($this->metaColumnsSQL2, strtoupper($schema), strtoupper($table)));
 130  	 	 }
 131  	 	 else {
 132  	 	 	 $rs = $this->Execute(sprintf($this->metaColumnsSQL,strtoupper($table)));
 133  	 	 }
 134  
 135  	 	 if (isset($savem)) {
 136  	 	 	 $this->SetFetchMode($savem);
 137  	 	 }
 138  	 	 $ADODB_FETCH_MODE = $save;
 139  	 	 if (!$rs) {
 140  	 	 	 return false;
 141  	 	 }
 142  	 	 $retarr = array();
 143  	 	 while (!$rs->EOF) {
 144  	 	 	 $fld = new ADOFieldObject();
 145  	 	 	 $fld->name = $rs->fields[0];
 146  	 	 	 $fld->type = $rs->fields[1];
 147  	 	 	 $fld->max_length = $rs->fields[2];
 148  	 	 	 $fld->scale = $rs->fields[3];
 149  	 	 	 if ($rs->fields[1] == 'NUMBER') {
 150  	 	 	 	 if ($rs->fields[3] == 0) {
 151  	 	 	 	 	 $fld->type = 'INT';
 152  	 	 	 	 }
 153  	 	 	 	 $fld->max_length = $rs->fields[4];
 154  	 	 	 }
 155  	 	 	 $fld->not_null = (strncmp($rs->fields[5], 'NOT',3) === 0);
 156  	 	 	 $fld->binary = (strpos($fld->type,'BLOB') !== false);
 157  	 	 	 $fld->default_value = $rs->fields[6];
 158  
 159  	 	 	 if ($ADODB_FETCH_MODE == ADODB_FETCH_NUM) {
 160  	 	 	 	 $retarr[] = $fld;
 161  	 	 	 }
 162  	 	 	 else {
 163  	 	 	 	 $retarr[strtoupper($fld->name)] = $fld;
 164  	 	 	 }
 165  	 	 	 $rs->MoveNext();
 166  	 	 }
 167  	 	 $rs->Close();
 168  	 	 if (empty($retarr)) {
 169  	 	 	 return false;
 170  	 	 }
 171  	 	 return $retarr;
 172  	 }
 173  
 174  	function Time()
 175  	 {
 176  	 	 $rs = $this->Execute("select TO_CHAR($this->sysTimeStamp,'YYYY-MM-DD HH24:MI:SS') from dual");
 177  	 	 if ($rs && !$rs->EOF) {
 178  	 	 	 return $this->UnixTimeStamp(reset($rs->fields));
 179  	 	 }
 180  
 181  	 	 return false;
 182  	 }
 183  
 184  	 /**
 185  	  * Multiple modes of connection are supported:
 186  	  *
 187  	  * a. Local Database
 188  	  *    $conn->Connect(false,'scott','tiger');
 189  	  *
 190  	  * b. From tnsnames.ora
 191  	  *    $conn->Connect($tnsname,'scott','tiger');
 192  	  *    $conn->Connect(false,'scott','tiger',$tnsname);
 193  	  *
 194  	  * c. Server + service name
 195  	  *    $conn->Connect($serveraddress,'scott,'tiger',$service_name);
 196  	  *
 197  	  * d. Server + SID
 198  	  *    $conn->connectSID = true;
 199  	  *    $conn->Connect($serveraddress,'scott,'tiger',$SID);
 200  	  *
 201  	  * @param string|false $argHostname DB server hostname or TNS name
 202  	  * @param string $argUsername
 203  	  * @param string $argPassword
 204  	  * @param string $argDatabasename Service name, SID (defaults to null)
 205  	  * @param int $mode Connection mode, defaults to 0
 206  	  *                  (0 = non-persistent, 1 = persistent, 2 = force new connection)
 207  	  *
 208  	  * @return bool
 209  	  */
 210  	function _connect($argHostname, $argUsername, $argPassword, $argDatabasename=null, $mode=0)
 211  	 {
 212  	 	 if (!function_exists('oci_pconnect')) {
 213  	 	 	 return null;
 214  	 	 }
 215  	 	 #adodb_backtrace();
 216  
 217  	 	 $this->_errorMsg = false;
 218  	 	 $this->_errorCode = false;
 219  
 220  	 	 if($argHostname) { // added by Jorma Tuomainen <jorma.tuomainen@ppoy.fi>
 221  	 	 	 if (empty($argDatabasename)) {
 222  	 	 	 	 $argDatabasename = $argHostname;
 223  	 	 	 }
 224  	 	 	 else {
 225  	 	 	 	 if(strpos($argHostname,":")) {
 226  	 	 	 	 	 $argHostinfo=explode(":",$argHostname);
 227  	 	 	 	 	 $argHostname=$argHostinfo[0];
 228  	 	 	 	 	 $argHostport=$argHostinfo[1];
 229  	 	 	 	 } else {
 230  	 	 	 	 	 $argHostport = empty($this->port)?  "1521" : $this->port;
 231  	 	 	 	 }
 232  
 233  	 	 	 	 if (strncasecmp($argDatabasename,'SID=',4) == 0) {
 234  	 	 	 	 	 $argDatabasename = substr($argDatabasename,4);
 235  	 	 	 	 	 $this->connectSID = true;
 236  	 	 	 	 }
 237  
 238  	 	 	 	 if ($this->connectSID) {
 239  	 	 	 	 	 $argDatabasename="(DESCRIPTION=(ADDRESS=(PROTOCOL=TCP)(HOST=".$argHostname
 240  	 	 	 	 	 .")(PORT=$argHostport))(CONNECT_DATA=(SID=$argDatabasename)))";
 241  	 	 	 	 } else
 242  	 	 	 	 	 $argDatabasename="(DESCRIPTION=(ADDRESS=(PROTOCOL=TCP)(HOST=".$argHostname
 243  	 	 	 	 	 .")(PORT=$argHostport))(CONNECT_DATA=(SERVICE_NAME=$argDatabasename)))";
 244  	 	 	 }
 245  	 	 }
 246  
 247  	 	 //if ($argHostname) print "<p>Connect: 1st argument should be left blank for $this->databaseType</p>";
 248  	 	 if ($mode==1) {
 249  	 	 	 $this->_connectionID = ($this->charSet)
 250  	 	 	 	 ? oci_pconnect($argUsername,$argPassword, $argDatabasename,$this->charSet)
 251  	 	 	 	 : oci_pconnect($argUsername,$argPassword, $argDatabasename);
 252  	 	 	 if ($this->_connectionID && $this->autoRollback)  {
 253  	 	 	 	 oci_rollback($this->_connectionID);
 254  	 	 	 }
 255  	 	 } else if ($mode==2) {
 256  	 	 	 $this->_connectionID = ($this->charSet)
 257  	 	 	 	 ? oci_new_connect($argUsername,$argPassword, $argDatabasename,$this->charSet)
 258  	 	 	 	 : oci_new_connect($argUsername,$argPassword, $argDatabasename);
 259  	 	 } else {
 260  	 	 	 $this->_connectionID = ($this->charSet)
 261  	 	 	 	 ? oci_connect($argUsername,$argPassword, $argDatabasename,$this->charSet)
 262  	 	 	 	 : oci_connect($argUsername,$argPassword, $argDatabasename);
 263  	 	 }
 264  	 	 if (!$this->_connectionID) {
 265  	 	 	 return false;
 266  	 	 }
 267  
 268  	 	 if ($this->_initdate) {
 269  	 	 	 $this->Execute("ALTER SESSION SET NLS_DATE_FORMAT='".$this->NLS_DATE_FORMAT."'");
 270  	 	 }
 271  
 272  	 	 // looks like:
 273  	 	 // Oracle8i Enterprise Edition Release 8.1.7.0.0 - Production With the Partitioning option JServer Release 8.1.7.0.0 - Production
 274  	 	 // $vers = oci_server_version($this->_connectionID);
 275  	 	 // if (strpos($vers,'8i') !== false) $this->ansiOuter = true;
 276  	 	 return true;
 277  	 }
 278  
 279  	function ServerInfo()
 280  	 {
 281  	 	 $arr['compat'] = $this->GetOne('select value from sys.database_compatible_level');
 282  	 	 $arr['description'] = @oci_server_version($this->_connectionID);
 283  	 	 $arr['version'] = ADOConnection::_findvers($arr['description']);
 284  	 	 return $arr;
 285  	 }
 286  	 	 // returns true or false
 287  	function _pconnect($argHostname, $argUsername, $argPassword, $argDatabasename)
 288  	 {
 289  	 	 return $this->_connect($argHostname, $argUsername, $argPassword, $argDatabasename,1);
 290  	 }
 291  
 292  	 // returns true or false
 293  	function _nconnect($argHostname, $argUsername, $argPassword, $argDatabasename)
 294  	 {
 295  	 	 return $this->_connect($argHostname, $argUsername, $argPassword, $argDatabasename,2);
 296  	 }
 297  
 298  	function _affectedrows()
 299  	 {
 300  	 	 if (is_resource($this->_stmt)) {
 301  	 	 	 return @oci_num_rows($this->_stmt);
 302  	 	 }
 303  	 	 return 0;
 304  	 }
 305  
 306  	function IfNull( $field, $ifNull )
 307  	 {
 308  	 	 return " NVL($field, $ifNull) "; // if Oracle
 309  	 }
 310  
 311  	 // format and return date string in database date format
 312  	function DBDate($d,$isfld=false)
 313  	 {
 314  	 	 if (empty($d) && $d !== 0) {
 315  	 	 	 return 'null';
 316  	 	 }
 317  
 318  	 	 if ($isfld) {
 319  	 	 	 $d = _adodb_safedate($d);
 320  	 	 	 return 'TO_DATE('.$d.",'".$this->dateformat."')";
 321  	 	 }
 322  
 323  	 	 if (is_string($d)) {
 324  	 	 	 $d = ADORecordSet::UnixDate($d);
 325  	 	 }
 326  
 327  	 	 if (is_object($d)) {
 328  	 	 	 $ds = $d->format($this->fmtDate);
 329  	 	 }
 330  	 	 else {
 331  	 	 	 $ds = adodb_date($this->fmtDate,$d);
 332  	 	 }
 333  
 334  	 	 return "TO_DATE(".$ds.",'".$this->dateformat."')";
 335  	 }
 336  
 337  	function BindDate($d)
 338  	 {
 339  	 	 $d = ADOConnection::DBDate($d);
 340  	 	 if (strncmp($d, "'", 1)) {
 341  	 	 	 return $d;
 342  	 	 }
 343  
 344  	 	 return substr($d, 1, strlen($d)-2);
 345  	 }
 346  
 347  	function BindTimeStamp($ts)
 348  	 {
 349  	 	 if (empty($ts) && $ts !== 0) {
 350  	 	 	 return 'null';
 351  	 	 }
 352  	 	 if (is_string($ts)) {
 353  	 	 	 $ts = ADORecordSet::UnixTimeStamp($ts);
 354  	 	 }
 355  
 356  	 	 if (is_object($ts)) {
 357  	 	 	 $tss = $ts->format("'Y-m-d H:i:s'");
 358  	 	 }
 359  	 	 else {
 360  	 	 	 $tss = adodb_date("'Y-m-d H:i:s'",$ts);
 361  	 	 }
 362  
 363  	 	 return $tss;
 364  	 }
 365  
 366  	 // format and return date string in database timestamp format
 367  	function DBTimeStamp($ts,$isfld=false)
 368  	 {
 369  	 	 if (empty($ts) && $ts !== 0) {
 370  	 	 	 return 'null';
 371  	 	 }
 372  	 	 if ($isfld) {
 373  	 	 	 return 'TO_DATE(substr('.$ts.",1,19),'RRRR-MM-DD, HH24:MI:SS')";
 374  	 	 }
 375  	 	 if (is_string($ts)) {
 376  	 	 	 $ts = ADORecordSet::UnixTimeStamp($ts);
 377  	 	 }
 378  
 379  	 	 if (is_object($ts)) {
 380  	 	 	 $tss = $ts->format("'Y-m-d H:i:s'");
 381  	 	 }
 382  	 	 else {
 383  	 	 	 $tss = date("'Y-m-d H:i:s'",$ts);
 384  	 	 }
 385  
 386  	 	 return 'TO_DATE('.$tss.",'RRRR-MM-DD, HH24:MI:SS')";
 387  	 }
 388  
 389  	function RowLock($tables,$where,$col='1 as adodbignore')
 390  	 {
 391  	 	 if ($this->autoCommit) {
 392  	 	 	 $this->BeginTrans();
 393  	 	 }
 394  	 	 return $this->GetOne("select $col from $tables where $where for update");
 395  	 }
 396  
 397  	function MetaTables($ttype=false,$showSchema=false,$mask=false)
 398  	 {
 399  	 	 if ($mask) {
 400  	 	 	 $save = $this->metaTablesSQL;
 401  	 	 	 $mask = $this->qstr(strtoupper($mask));
 402  	 	 	 $this->metaTablesSQL .= " AND upper(table_name) like $mask";
 403  	 	 }
 404  	 	 $ret = ADOConnection::MetaTables($ttype,$showSchema);
 405  
 406  	 	 if ($mask) {
 407  	 	 	 $this->metaTablesSQL = $save;
 408  	 	 }
 409  	 	 return $ret;
 410  	 }
 411  
 412  	 // Mark Newnham
 413  	function MetaIndexes ($table, $primary = FALSE, $owner=false)
 414  	 {
 415  	 	 // save old fetch mode
 416  	 	 global $ADODB_FETCH_MODE;
 417  
 418  	 	 $save = $ADODB_FETCH_MODE;
 419  	 	 $ADODB_FETCH_MODE = ADODB_FETCH_NUM;
 420  
 421  	 	 if ($this->fetchMode !== FALSE) {
 422  	 	 	 $savem = $this->SetFetchMode(FALSE);
 423  	 	 }
 424  
 425  	 	 // get index details
 426  	 	 $table = strtoupper($table);
 427  
 428  	 	 // get Primary index
 429  	 	 $primary_key = '';
 430  
 431  	 	 $rs = $this->Execute(sprintf("SELECT * FROM ALL_CONSTRAINTS WHERE UPPER(TABLE_NAME)='%s' AND CONSTRAINT_TYPE='P'",$table));
 432  	 	 if (!is_object($rs)) {
 433  	 	 	 if (isset($savem)) {
 434  	 	 	 	 $this->SetFetchMode($savem);
 435  	 	 	 }
 436  	 	 	 $ADODB_FETCH_MODE = $save;
 437  	 	 	 return false;
 438  	 	 }
 439  
 440  	 	 if ($row = $rs->FetchRow()) {
 441  	 	 	 $primary_key = $row[1]; //constraint_name
 442  	 	 }
 443  
 444  	 	 if ($primary==TRUE && $primary_key=='') {
 445  	 	 	 if (isset($savem)) {
 446  	 	 	 	 $this->SetFetchMode($savem);
 447  	 	 	 }
 448  	 	 	 $ADODB_FETCH_MODE = $save;
 449  	 	 	 return false; //There is no primary key
 450  	 	 }
 451  
 452  	 	 $rs = $this->Execute(sprintf("SELECT ALL_INDEXES.INDEX_NAME, ALL_INDEXES.UNIQUENESS, ALL_IND_COLUMNS.COLUMN_POSITION, ALL_IND_COLUMNS.COLUMN_NAME FROM ALL_INDEXES,ALL_IND_COLUMNS WHERE UPPER(ALL_INDEXES.TABLE_NAME)='%s' AND ALL_IND_COLUMNS.INDEX_NAME=ALL_INDEXES.INDEX_NAME",$table));
 453  
 454  
 455  	 	 if (!is_object($rs)) {
 456  	 	 	 if (isset($savem)) {
 457  	 	 	 	 $this->SetFetchMode($savem);
 458  	 	 	 }
 459  	 	 	 $ADODB_FETCH_MODE = $save;
 460  	 	 	 return false;
 461  	 	 }
 462  
 463  	 	 $indexes = array ();
 464  	 	 // parse index data into array
 465  
 466  	 	 while ($row = $rs->FetchRow()) {
 467  	 	 	 if ($primary && $row[0] != $primary_key) {
 468  	 	 	 	 continue;
 469  	 	 	 }
 470  	 	 	 if (!isset($indexes[$row[0]])) {
 471  	 	 	 	 $indexes[$row[0]] = array(
 472  	 	 	 	 	 'unique' => ($row[1] == 'UNIQUE'),
 473  	 	 	 	 	 'columns' => array()
 474  	 	 	 	 );
 475  	 	 	 }
 476  	 	 	 $indexes[$row[0]]['columns'][$row[2] - 1] = $row[3];
 477  	 	 }
 478  
 479  	 	 // sort columns by order in the index
 480  	 	 foreach ( array_keys ($indexes) as $index ) {
 481  	 	 	 ksort ($indexes[$index]['columns']);
 482  	 	 }
 483  
 484  	 	 if (isset($savem)) {
 485  	 	 	 $this->SetFetchMode($savem);
 486  	 	 	 $ADODB_FETCH_MODE = $save;
 487  	 	 }
 488  	 	 return $indexes;
 489  	 }
 490  
 491  	function BeginTrans()
 492  	 {
 493  	 	 if ($this->transOff) {
 494  	 	 	 return true;
 495  	 	 }
 496  	 	 $this->transCnt += 1;
 497  	 	 $this->autoCommit = false;
 498  	 	 $this->_commit = OCI_DEFAULT;
 499  
 500  	 	 if ($this->_transmode) {
 501  	 	 	 $ok = $this->Execute("SET TRANSACTION ".$this->_transmode);
 502  	 	 }
 503  	 	 else {
 504  	 	 	 $ok = true;
 505  	 	 }
 506  
 507  	 	 return $ok ? true : false;
 508  	 }
 509  
 510  	function CommitTrans($ok=true)
 511  	 {
 512  	 	 if ($this->transOff) {
 513  	 	 	 return true;
 514  	 	 }
 515  	 	 if (!$ok) {
 516  	 	 	 return $this->RollbackTrans();
 517  	 	 }
 518  
 519  	 	 if ($this->transCnt) {
 520  	 	 	 $this->transCnt -= 1;
 521  	 	 }
 522  	 	 $ret = oci_commit($this->_connectionID);
 523  	 	 $this->_commit = OCI_COMMIT_ON_SUCCESS;
 524  	 	 $this->autoCommit = true;
 525  	 	 return $ret;
 526  	 }
 527  
 528  	function RollbackTrans()
 529  	 {
 530  	 	 if ($this->transOff) {
 531  	 	 	 return true;
 532  	 	 }
 533  	 	 if ($this->transCnt) {
 534  	 	 	 $this->transCnt -= 1;
 535  	 	 }
 536  	 	 $ret = oci_rollback($this->_connectionID);
 537  	 	 $this->_commit = OCI_COMMIT_ON_SUCCESS;
 538  	 	 $this->autoCommit = true;
 539  	 	 return $ret;
 540  	 }
 541  
 542  
 543  	function SelectDB($dbName)
 544  	 {
 545  	 	 return false;
 546  	 }
 547  
 548  	function ErrorMsg()
 549  	 {
 550  	 	 if ($this->_errorMsg !== false) {
 551  	 	 	 return $this->_errorMsg;
 552  	 	 }
 553  
 554  	 	 if (is_resource($this->_stmt)) {
 555  	 	 	 $arr = @oci_error($this->_stmt);
 556  	 	 }
 557  	 	 if (empty($arr)) {
 558  	 	 	 if (is_resource($this->_connectionID)) {
 559  	 	 	 	 $arr = @oci_error($this->_connectionID);
 560  	 	 	 }
 561  	 	 	 else {
 562  	 	 	 	 $arr = @oci_error();
 563  	 	 	 }
 564  	 	 	 if ($arr === false) {
 565  	 	 	 	 return '';
 566  	 	 	 }
 567  	 	 }
 568  	 	 $this->_errorMsg = $arr['message'];
 569  	 	 $this->_errorCode = $arr['code'];
 570  	 	 return $this->_errorMsg;
 571  	 }
 572  
 573  	function ErrorNo()
 574  	 {
 575  	 	 if ($this->_errorCode !== false) {
 576  	 	 	 return $this->_errorCode;
 577  	 	 }
 578  
 579  	 	 if (is_resource($this->_stmt)) {
 580  	 	 	 $arr = @oci_error($this->_stmt);
 581  	 	 }
 582  	 	 if (empty($arr)) {
 583  	 	 	 $arr = @oci_error($this->_connectionID);
 584  	 	 	 if ($arr == false) {
 585  	 	 	 	 $arr = @oci_error();
 586  	 	 	 }
 587  	 	 	 if ($arr == false) {
 588  	 	 	 	 return '';
 589  	 	 	 }
 590  	 	 }
 591  
 592  	 	 $this->_errorMsg = $arr['message'];
 593  	 	 $this->_errorCode = $arr['code'];
 594  
 595  	 	 return $arr['code'];
 596  	 }
 597  
 598  	 /**
 599  	  * Format date column in sql string given an input format that understands Y M D
 600  	  */
 601  	function SQLDate($fmt, $col=false)
 602  	 {
 603  	 	 if (!$col) {
 604  	 	 	 $col = $this->sysTimeStamp;
 605  	 	 }
 606  	 	 $s = 'TO_CHAR('.$col.",'";
 607  
 608  	 	 $len = strlen($fmt);
 609  	 	 for ($i=0; $i < $len; $i++) {
 610  	 	 	 $ch = $fmt[$i];
 611  	 	 	 switch($ch) {
 612  	 	 	 case 'Y':
 613  	 	 	 case 'y':
 614  	 	 	 	 $s .= 'YYYY';
 615  	 	 	 	 break;
 616  	 	 	 case 'Q':
 617  	 	 	 case 'q':
 618  	 	 	 	 $s .= 'Q';
 619  	 	 	 	 break;
 620  
 621  	 	 	 case 'M':
 622  	 	 	 	 $s .= 'Mon';
 623  	 	 	 	 break;
 624  
 625  	 	 	 case 'm':
 626  	 	 	 	 $s .= 'MM';
 627  	 	 	 	 break;
 628  	 	 	 case 'D':
 629  	 	 	 case 'd':
 630  	 	 	 	 $s .= 'DD';
 631  	 	 	 	 break;
 632  
 633  	 	 	 case 'H':
 634  	 	 	 	 $s.= 'HH24';
 635  	 	 	 	 break;
 636  
 637  	 	 	 case 'h':
 638  	 	 	 	 $s .= 'HH';
 639  	 	 	 	 break;
 640  
 641  	 	 	 case 'i':
 642  	 	 	 	 $s .= 'MI';
 643  	 	 	 	 break;
 644  
 645  	 	 	 case 's':
 646  	 	 	 	 $s .= 'SS';
 647  	 	 	 	 break;
 648  
 649  	 	 	 case 'a':
 650  	 	 	 case 'A':
 651  	 	 	 	 $s .= 'AM';
 652  	 	 	 	 break;
 653  
 654  	 	 	 case 'w':
 655  	 	 	 	 $s .= 'D';
 656  	 	 	 	 break;
 657  
 658  	 	 	 case 'l':
 659  	 	 	 	 $s .= 'DAY';
 660  	 	 	 	 break;
 661  
 662  	 	 	 case 'W':
 663  	 	 	 	 $s .= 'WW';
 664  	 	 	 	 break;
 665  
 666  	 	 	 default:
 667  	 	 	 	 // handle escape characters...
 668  	 	 	 	 if ($ch == '\\') {
 669  	 	 	 	 	 $i++;
 670  	 	 	 	 	 $ch = substr($fmt,$i,1);
 671  	 	 	 	 }
 672  	 	 	 	 if (strpos('-/.:;, ',$ch) !== false) {
 673  	 	 	 	 	 $s .= $ch;
 674  	 	 	 	 }
 675  	 	 	 	 else {
 676  	 	 	 	 	 $s .= '"'.$ch.'"';
 677  	 	 	 	 }
 678  
 679  	 	 	 }
 680  	 	 }
 681  	 	 return $s. "')";
 682  	 }
 683  
 684  	function GetRandRow($sql, $arr = false)
 685  	 {
 686  	 	 $sql = "SELECT * FROM ($sql ORDER BY dbms_random.value) WHERE rownum = 1";
 687  
 688  	 	 return $this->GetRow($sql,$arr);
 689  	 }
 690  
 691  	 /**
 692  	  * This algorithm makes use of
 693  	  *
 694  	  * a. FIRST_ROWS hint
 695  	  * The FIRST_ROWS hint explicitly chooses the approach to optimize response
 696  	  * time, that is, minimum resource usage to return the first row. Results
 697  	  * will be returned as soon as they are identified.
 698  	  *
 699  	  * b. Uses rownum tricks to obtain only the required rows from a given offset.
 700  	  * As this uses complicated sql statements, we only use this if $offset >= 100.
 701  	  * This idea by Tomas V V Cox.
 702  	  *
 703  	  * This implementation does not appear to work with oracle 8.0.5 or earlier.
 704  	  * Comment out this function then, and the slower SelectLimit() in the base
 705  	  * class will be used.
 706  	  *
 707  	  * Note: FIRST_ROWS hinting is only used if $sql is a string; when
 708  	  * processing a prepared statement's handle, no hinting is performed.
 709  	  */
 710  	function SelectLimit($sql,$nrows=-1,$offset=-1, $inputarr=false,$secs2cache=0)
 711  	 {
 712  	 	 $nrows = (int) $nrows;
 713  	 	 $offset = (int) $offset;
 714  	 	 // Since the methods used to limit the number of returned rows rely
 715  	 	 // on modifying the provided SQL query, we can't work with prepared
 716  	 	 // statements so we just extract the SQL string.
 717  	 	 if(is_array($sql)) {
 718  	 	 	 $sql = $sql[0];
 719  	 	 }
 720  
 721  	 	 // seems that oracle only supports 1 hint comment in 8i
 722  	 	 if ($this->firstrows) {
 723  	 	 	 if ($nrows > 500 && $nrows < 1000) {
 724  	 	 	 	 $hint = "FIRST_ROWS($nrows)";
 725  	 	 	 }
 726  	 	 	 else {
 727  	 	 	 	 $hint = 'FIRST_ROWS';
 728  	 	 	 }
 729  
 730  	 	 	 if (strpos($sql,'/*+') !== false) {
 731  	 	 	 	 $sql = str_replace('/*+ ',"/*+$hint ",$sql);
 732  	 	 	 }
 733  	 	 	 else {
 734  	 	 	 	 $sql = preg_replace('/^[ \t\n]*select/i',"SELECT /*+$hint*/",$sql);
 735  	 	 	 }
 736  	 	 	 $hint = "/*+ $hint */";
 737  	 	 } else {
 738  	 	 	 $hint = '';
 739  	 	 }
 740  
 741  	 	 if ($offset == -1 || ($offset < $this->selectOffsetAlg1 && 0 < $nrows && $nrows < 1000)) {
 742  	 	 	 if ($nrows > 0) {
 743  	 	 	 	 if ($offset > 0) {
 744  	 	 	 	 	 $nrows += $offset;
 745  	 	 	 	 }
 746  	 	 	 	 $sql = "select * from (".$sql.") where rownum <= :adodb_offset";
 747  	 	 	 	 $inputarr['adodb_offset'] = $nrows;
 748  	 	 	 	 $nrows = -1;
 749  	 	 	 }
 750  	 	 	 // note that $nrows = 0 still has to work ==> no rows returned
 751  
 752  	 	 	 return ADOConnection::SelectLimit($sql, $nrows, $offset, $inputarr, $secs2cache);
 753  	 	 } else {
 754  	 	 	 // Algorithm by Tomas V V Cox, from PEAR DB oci8.php
 755  
 756  	 	 	 // Let Oracle return the name of the columns
 757  	 	 	 $q_fields = "SELECT * FROM (".$sql.") WHERE NULL = NULL";
 758  
 759  	 	 	 if (! $stmt_arr = $this->Prepare($q_fields)) {
 760  	 	 	 	 return false;
 761  	 	 	 }
 762  	 	 	 $stmt = $stmt_arr[1];
 763  
 764  	 	 	 if (is_array($inputarr)) {
 765  	 	 	 	 foreach($inputarr as $k => $v) {
 766  	 	 	 	 	 $i=0;
 767  	 	 	 	 	 if ($this->databaseType == 'oci8po') {
 768  	 	 	 	 	 	 $bv_name = ":".$i++;
 769  	 	 	 	 	 } else {
 770  	 	 	 	 	 	 $bv_name = ":".$k;
 771  	 	 	 	 	 }
 772  	 	 	 	 	 if (is_array($v)) {
 773  	 	 	 	 	 	 // suggested by g.giunta@libero.
 774  	 	 	 	 	 	 if (sizeof($v) == 2) {
 775  	 	 	 	 	 	 	 oci_bind_by_name($stmt,$bv_name,$inputarr[$k][0],$v[1]);
 776  	 	 	 	 	 	 }
 777  	 	 	 	 	 	 else {
 778  	 	 	 	 	 	 	 oci_bind_by_name($stmt,$bv_name,$inputarr[$k][0],$v[1],$v[2]);
 779  	 	 	 	 	 	 }
 780  	 	 	 	 	 } else {
 781  	 	 	 	 	 	 $len = -1;
 782  	 	 	 	 	 	 if ($v === ' ') {
 783  	 	 	 	 	 	 	 $len = 1;
 784  	 	 	 	 	 	 }
 785  	 	 	 	 	 	 if (isset($bindarr)) {	 // is prepared sql, so no need to oci_bind_by_name again
 786  	 	 	 	 	 	 	 $bindarr[$k] = $v;
 787  	 	 	 	 	 	 } else { 	 	 	 	 // dynamic sql, so rebind every time
 788  	 	 	 	 	 	 	 oci_bind_by_name($stmt,$bv_name,$inputarr[$k],$len);
 789  	 	 	 	 	 	 }
 790  	 	 	 	 	 }
 791  	 	 	 	 }
 792  	 	 	 }
 793  
 794  	 	 	 if (!oci_execute($stmt, OCI_DEFAULT)) {
 795  	 	 	 	 oci_free_statement($stmt);
 796  	 	 	 	 return false;
 797  	 	 	 }
 798  
 799  	 	 	 $ncols = oci_num_fields($stmt);
 800  	 	 	 for ( $i = 1; $i <= $ncols; $i++ ) {
 801  	 	 	 	 $cols[] = '"'.oci_field_name($stmt, $i).'"';
 802  	 	 	 }
 803  	 	 	 $result = false;
 804  
 805  	 	 	 oci_free_statement($stmt);
 806  	 	 	 $fields = implode(',', $cols);
 807  	 	 	 if ($nrows <= 0) {
 808  	 	 	 	 $nrows = 999999999999;
 809  	 	 	 }
 810  	 	 	 else {
 811  	 	 	 	 $nrows += $offset;
 812  	 	 	 }
 813  	 	 	 $offset += 1; // in Oracle rownum starts at 1
 814  
 815  	 	 	 $sql = "SELECT $hint $fields FROM".
 816  	 	 	 	 "(SELECT rownum as adodb_rownum, $fields FROM".
 817  	 	 	 	 " ($sql) WHERE rownum <= :adodb_nrows".
 818  	 	 	 	 ") WHERE adodb_rownum >= :adodb_offset";
 819  	 	 	 $inputarr['adodb_nrows'] = $nrows;
 820  	 	 	 $inputarr['adodb_offset'] = $offset;
 821  
 822  	 	 	 if ($secs2cache > 0) {
 823  	 	 	 	 $rs = $this->CacheExecute($secs2cache, $sql,$inputarr);
 824  	 	 	 }
 825  	 	 	 else {
 826  	 	 	 	 $rs = $this->Execute($sql, $inputarr);
 827  	 	 	 }
 828  	 	 	 return $rs;
 829  	 	 }
 830  	 }
 831  
 832  	 /**
 833  	  * Usage:
 834  	  * Store BLOBs and CLOBs
 835  	  *
 836  	  * Example: to store $var in a blob
 837  	  *    $conn->Execute('insert into TABLE (id,ablob) values(12,empty_blob())');
 838  	  *    $conn->UpdateBlob('TABLE', 'ablob', $varHoldingBlob, 'ID=12', 'BLOB');
 839  	  *
 840  	  * $blobtype supports 'BLOB' and 'CLOB', but you need to change to 'empty_clob()'.
 841  	  *
 842  	  * to get length of LOB:
 843  	  *    select DBMS_LOB.GETLENGTH(ablob) from TABLE
 844  	  *
 845  	  * If you are using CURSOR_SHARING = force, it appears this will case a segfault
 846  	  * under oracle 8.1.7.0. Run:
 847  	  *    $db->Execute('ALTER SESSION SET CURSOR_SHARING=EXACT');
 848  	  * before UpdateBlob() then...
 849  	  */
 850  	function UpdateBlob($table,$column,$val,$where,$blobtype='BLOB')
 851  	 {
 852  
 853  	 	 //if (strlen($val) < 4000) return $this->Execute("UPDATE $table SET $column=:blob WHERE $where",array('blob'=>$val)) != false;
 854  
 855  	 	 switch(strtoupper($blobtype)) {
 856  	 	 default: ADOConnection::outp("<b>UpdateBlob</b>: Unknown blobtype=$blobtype"); return false;
 857  	 	 case 'BLOB': $type = OCI_B_BLOB; break;
 858  	 	 case 'CLOB': $type = OCI_B_CLOB; break;
 859  	 	 }
 860  
 861  	 	 if ($this->databaseType == 'oci8po')
 862  	 	 	 $sql = "UPDATE $table set $column=EMPTY_{$blobtype}() WHERE $where RETURNING $column INTO ?";
 863  	 	 else
 864  	 	 	 $sql = "UPDATE $table set $column=EMPTY_{$blobtype}() WHERE $where RETURNING $column INTO :blob";
 865  
 866  	 	 $desc = oci_new_descriptor($this->_connectionID, OCI_D_LOB);
 867  	 	 $arr['blob'] = array($desc,-1,$type);
 868  	 	 if ($this->session_sharing_force_blob) {
 869  	 	 	 $this->Execute('ALTER SESSION SET CURSOR_SHARING=EXACT');
 870  	 	 }
 871  	 	 $commit = $this->autoCommit;
 872  	 	 if ($commit) {
 873  	 	 	 $this->BeginTrans();
 874  	 	 }
 875  	 	 $rs = $this->_Execute($sql,$arr);
 876  	 	 if ($rez = !empty($rs)) {
 877  	 	 	 $desc->save($val);
 878  	 	 }
 879  	 	 $desc->free();
 880  	 	 if ($commit) {
 881  	 	 	 $this->CommitTrans();
 882  	 	 }
 883  	 	 if ($this->session_sharing_force_blob) {
 884  	 	 	 $this->Execute('ALTER SESSION SET CURSOR_SHARING=FORCE');
 885  	 	 }
 886  
 887  	 	 if ($rez) {
 888  	 	 	 $rs->Close();
 889  	 	 }
 890  	 	 return $rez;
 891  	 }
 892  
 893  	 /**
 894  	  * Usage:  store file pointed to by $val in a blob
 895  	  */
 896  	function UpdateBlobFile($table,$column,$val,$where,$blobtype='BLOB')
 897  	 {
 898  	 	 switch(strtoupper($blobtype)) {
 899  	 	 default: ADOConnection::outp( "<b>UpdateBlob</b>: Unknown blobtype=$blobtype"); return false;
 900  	 	 case 'BLOB': $type = OCI_B_BLOB; break;
 901  	 	 case 'CLOB': $type = OCI_B_CLOB; break;
 902  	 	 }
 903  
 904  	 	 if ($this->databaseType == 'oci8po')
 905  	 	 	 $sql = "UPDATE $table set $column=EMPTY_{$blobtype}() WHERE $where RETURNING $column INTO ?";
 906  	 	 else
 907  	 	 	 $sql = "UPDATE $table set $column=EMPTY_{$blobtype}() WHERE $where RETURNING $column INTO :blob";
 908  
 909  	 	 $desc = oci_new_descriptor($this->_connectionID, OCI_D_LOB);
 910  	 	 $arr['blob'] = array($desc,-1,$type);
 911  
 912  	 	 $this->BeginTrans();
 913  	 	 $rs = ADODB_oci8::Execute($sql,$arr);
 914  	 	 if ($rez = !empty($rs)) {
 915  	 	 	 $desc->savefile($val);
 916  	 	 }
 917  	 	 $desc->free();
 918  	 	 $this->CommitTrans();
 919  
 920  	 	 if ($rez) {
 921  	 	 	 $rs->Close();
 922  	 	 }
 923  	 	 return $rez;
 924  	 }
 925  
 926  	 /**
 927  	  * Execute SQL
 928  	  *
 929  	  * @param sql	 	 SQL statement to execute, or possibly an array holding prepared statement ($sql[0] will hold sql text)
 930  	  * @param [inputarr]	 holds the input data to bind to. Null elements will be set to null.
 931  	  * @return 	 	 RecordSet or false
 932  	  */
 933  	function Execute($sql,$inputarr=false)
 934  	 {
 935  	 	 if ($this->fnExecute) {
 936  	 	 	 $fn = $this->fnExecute;
 937  	 	 	 $ret = $fn($this,$sql,$inputarr);
 938  	 	 	 if (isset($ret)) {
 939  	 	 	 	 return $ret;
 940  	 	 	 }
 941  	 	 }
 942  	 	 if ($inputarr !== false) {
 943  	 	 	 if (!is_array($inputarr)) {
 944  	 	 	 	 $inputarr = array($inputarr);
 945  	 	 	 }
 946  
 947  	 	 	 $element0 = reset($inputarr);
 948  	 	 	 $array2d =  $this->bulkBind && is_array($element0) && !is_object(reset($element0));
 949  
 950  	 	 	 # see http://phplens.com/lens/lensforum/msgs.php?id=18786
 951  	 	 	 if ($array2d || !$this->_bindInputArray) {
 952  
 953  	 	 	 	 # is_object check because oci8 descriptors can be passed in
 954  	 	 	 	 if ($array2d && $this->_bindInputArray) {
 955  	 	 	 	 	 if (is_string($sql)) {
 956  	 	 	 	 	 	 $stmt = $this->Prepare($sql);
 957  	 	 	 	 	 } else {
 958  	 	 	 	 	 	 $stmt = $sql;
 959  	 	 	 	 	 }
 960  
 961  	 	 	 	 	 foreach($inputarr as $arr) {
 962  	 	 	 	 	 	 $ret = $this->_Execute($stmt,$arr);
 963  	 	 	 	 	 	 if (!$ret) {
 964  	 	 	 	 	 	 	 return $ret;
 965  	 	 	 	 	 	 }
 966  	 	 	 	 	 }
 967  	 	 	 	 	 return $ret;
 968  	 	 	 	 } else {
 969  	 	 	 	 	 $sqlarr = explode(':', $sql);
 970  	 	 	 	 	 $sql = '';
 971  	 	 	 	 	 $lastnomatch = -2;
 972  	 	 	 	 	 #var_dump($sqlarr);echo "<hr>";var_dump($inputarr);echo"<hr>";
 973  	 	 	 	 	 foreach($sqlarr as $k => $str) {
 974  	 	 	 	 	 	 if ($k == 0) {
 975  	 	 	 	 	 	 	 $sql = $str;
 976  	 	 	 	 	 	 	 continue;
 977  	 	 	 	 	 	 }
 978  	 	 	 	 	 	 // we need $lastnomatch because of the following datetime,
 979  	 	 	 	 	 	 // eg. '10:10:01', which causes code to think that there is bind param :10 and :1
 980  	 	 	 	 	 	 $ok = preg_match('/^([0-9]*)/', $str, $arr);
 981  
 982  	 	 	 	 	 	 if (!$ok) {
 983  	 	 	 	 	 	 	 $sql .= $str;
 984  	 	 	 	 	 	 } else {
 985  	 	 	 	 	 	 	 $at = $arr[1];
 986  	 	 	 	 	 	 	 if (isset($inputarr[$at]) || is_null($inputarr[$at])) {
 987  	 	 	 	 	 	 	 	 if ((strlen($at) == strlen($str) && $k < sizeof($arr)-1)) {
 988  	 	 	 	 	 	 	 	 	 $sql .= ':'.$str;
 989  	 	 	 	 	 	 	 	 	 $lastnomatch = $k;
 990  	 	 	 	 	 	 	 	 } else if ($lastnomatch == $k-1) {
 991  	 	 	 	 	 	 	 	 	 $sql .= ':'.$str;
 992  	 	 	 	 	 	 	 	 } else {
 993  	 	 	 	 	 	 	 	 	 if (is_null($inputarr[$at])) {
 994  	 	 	 	 	 	 	 	 	 	 $sql .= 'null';
 995  	 	 	 	 	 	 	 	 	 }
 996  	 	 	 	 	 	 	 	 	 else {
 997  	 	 	 	 	 	 	 	 	 	 $sql .= $this->qstr($inputarr[$at]);
 998  	 	 	 	 	 	 	 	 	 }
 999  	 	 	 	 	 	 	 	 	 $sql .= substr($str, strlen($at));
1000  	 	 	 	 	 	 	 	 }
1001  	 	 	 	 	 	 	 } else {
1002  	 	 	 	 	 	 	 	 $sql .= ':'.$str;
1003  	 	 	 	 	 	 	 }
1004  	 	 	 	 	 	 }
1005  	 	 	 	 	 }
1006  	 	 	 	 	 $inputarr = false;
1007  	 	 	 	 }
1008  	 	 	 }
1009  	 	 	 $ret = $this->_Execute($sql,$inputarr);
1010  
1011  	 	 } else {
1012  	 	 	 $ret = $this->_Execute($sql,false);
1013  	 	 }
1014  
1015  	 	 return $ret;
1016  	 }
1017  
1018  	 /*
1019  	  * Example of usage:
1020  	  *    $stmt = $this->Prepare('insert into emp (empno, ename) values (:empno, :ename)');
1021  	 */
1022  	function Prepare($sql,$cursor=false)
1023  	 {
1024  	 static $BINDNUM = 0;
1025  
1026  	 	 $stmt = oci_parse($this->_connectionID,$sql);
1027  
1028  	 	 if (!$stmt) {
1029  	 	 	 $this->_errorMsg = false;
1030  	 	 	 $this->_errorCode = false;
1031  	 	 	 $arr = @oci_error($this->_connectionID);
1032  	 	 	 if ($arr === false) {
1033  	 	 	 	 return false;
1034  	 	 	 }
1035  
1036  	 	 	 $this->_errorMsg = $arr['message'];
1037  	 	 	 $this->_errorCode = $arr['code'];
1038  	 	 	 return false;
1039  	 	 }
1040  
1041  	 	 $BINDNUM += 1;
1042  
1043  	 	 $sttype = @oci_statement_type($stmt);
1044  	 	 if ($sttype == 'BEGIN' || $sttype == 'DECLARE') {
1045  	 	 	 return array($sql,$stmt,0,$BINDNUM, ($cursor) ? oci_new_cursor($this->_connectionID) : false);
1046  	 	 }
1047  	 	 return array($sql,$stmt,0,$BINDNUM);
1048  	 }
1049  
1050  	 /*
1051  	 	 Call an oracle stored procedure and returns a cursor variable as a recordset.
1052  	 	 Concept by Robert Tuttle robert@ud.com
1053  
1054  	 	 Example:
1055  	 	 	 Note: we return a cursor variable in :RS2
1056  	 	 	 $rs = $db->ExecuteCursor("BEGIN adodb.open_tab(:RS2); END;",'RS2');
1057  
1058  	 	 	 $rs = $db->ExecuteCursor(
1059  	 	 	 	 "BEGIN :RS2 = adodb.getdata(:VAR1); END;",
1060  	 	 	 	 'RS2',
1061  	 	 	 	 array('VAR1' => 'Mr Bean'));
1062  
1063  	 */
1064  	function ExecuteCursor($sql,$cursorName='rs',$params=false)
1065  	 {
1066  	 	 if (is_array($sql)) {
1067  	 	 	 $stmt = $sql;
1068  	 	 }
1069  	 	 else $stmt = ADODB_oci8::Prepare($sql,true); # true to allocate oci_new_cursor
1070  
1071  	 	 if (is_array($stmt) && sizeof($stmt) >= 5) {
1072  	 	 	 $hasref = true;
1073  	 	 	 $ignoreCur = false;
1074  	 	 	 $this->Parameter($stmt, $ignoreCur, $cursorName, false, -1, OCI_B_CURSOR);
1075  	 	 	 if ($params) {
1076  	 	 	 	 foreach($params as $k => $v) {
1077  	 	 	 	 	 $this->Parameter($stmt,$params[$k], $k);
1078  	 	 	 	 }
1079  	 	 	 }
1080  	 	 } else
1081  	 	 	 $hasref = false;
1082  
1083  	 	 $rs = $this->Execute($stmt);
1084  	 	 if ($rs) {
1085  	 	 	 if ($rs->databaseType == 'array') {
1086  	 	 	 	 oci_free_cursor($stmt[4]);
1087  	 	 	 }
1088  	 	 	 elseif ($hasref) {
1089  	 	 	 	 $rs->_refcursor = $stmt[4];
1090  	 	 	 }
1091  	 	 }
1092  	 	 return $rs;
1093  	 }
1094  
1095  	 /**
1096  	  * Bind a variable -- very, very fast for executing repeated statements in oracle.
1097  	  *
1098  	  * Better than using
1099  	  *    for ($i = 0; $i < $max; $i++) {
1100  	  *        $p1 = ?; $p2 = ?; $p3 = ?;
1101  	  *        $this->Execute("insert into table (col0, col1, col2) values (:0, :1, :2)", array($p1,$p2,$p3));
1102  	  *    }
1103  	  *
1104  	  * Usage:
1105  	  *    $stmt = $DB->Prepare("insert into table (col0, col1, col2) values (:0, :1, :2)");
1106  	  *    $DB->Bind($stmt, $p1);
1107  	  *    $DB->Bind($stmt, $p2);
1108  	  *    $DB->Bind($stmt, $p3);
1109  	  *    for ($i = 0; $i < $max; $i++) {
1110  	  *        $p1 = ?; $p2 = ?; $p3 = ?;
1111  	  *        $DB->Execute($stmt);
1112  	  *    }
1113  	  *
1114  	  * Some timings to insert 1000 records, test table has 3 cols, and 1 index.
1115  	  * - Time 0.6081s (1644.60 inserts/sec) with direct oci_parse/oci_execute
1116  	  * - Time 0.6341s (1577.16 inserts/sec) with ADOdb Prepare/Bind/Execute
1117  	  * - Time 1.5533s ( 643.77 inserts/sec) with pure SQL using Execute
1118  	  *
1119  	  * Now if PHP only had batch/bulk updating like Java or PL/SQL...
1120  	  *
1121  	  * Note that the order of parameters differs from oci_bind_by_name,
1122  	  * because we default the names to :0, :1, :2
1123  	  */
1124  	function Bind(&$stmt,&$var,$size=4000,$type=false,$name=false,$isOutput=false)
1125  	 {
1126  
1127  	 	 if (!is_array($stmt)) {
1128  	 	 	 return false;
1129  	 	 }
1130  
1131  	 	 if (($type == OCI_B_CURSOR) && sizeof($stmt) >= 5) {
1132  	 	 	 return oci_bind_by_name($stmt[1],":".$name,$stmt[4],$size,$type);
1133  	 	 }
1134  
1135  	 	 if ($name == false) {
1136  	 	 	 if ($type !== false) {
1137  	 	 	 	 $rez = oci_bind_by_name($stmt[1],":".$stmt[2],$var,$size,$type);
1138  	 	 	 }
1139  	 	 	 else {
1140  	 	 	 	 $rez = oci_bind_by_name($stmt[1],":".$stmt[2],$var,$size); // +1 byte for null terminator
1141  	 	 	 }
1142  	 	 	 $stmt[2] += 1;
1143  	 	 } else if (oci_lob_desc($type)) {
1144  	 	 	 if ($this->debug) {
1145  	 	 	 	 ADOConnection::outp("<b>Bind</b>: name = $name");
1146  	 	 	 }
1147  	 	 	 //we have to create a new Descriptor here
1148  	 	 	 $numlob = count($this->_refLOBs);
1149  	 	 	 $this->_refLOBs[$numlob]['LOB'] = oci_new_descriptor($this->_connectionID, oci_lob_desc($type));
1150  	 	 	 $this->_refLOBs[$numlob]['TYPE'] = $isOutput;
1151  
1152  	 	 	 $tmp = $this->_refLOBs[$numlob]['LOB'];
1153  	 	 	 $rez = oci_bind_by_name($stmt[1], ":".$name, $tmp, -1, $type);
1154  	 	 	 if ($this->debug) {
1155  	 	 	 	 ADOConnection::outp("<b>Bind</b>: descriptor has been allocated, var (".$name.") binded");
1156  	 	 	 }
1157  
1158  	 	 	 // if type is input then write data to lob now
1159  	 	 	 if ($isOutput == false) {
1160  	 	 	 	 $var = $this->BlobEncode($var);
1161  	 	 	 	 $tmp->WriteTemporary($var);
1162  	 	 	 	 $this->_refLOBs[$numlob]['VAR'] = &$var;
1163  	 	 	 	 if ($this->debug) {
1164  	 	 	 	 	 ADOConnection::outp("<b>Bind</b>: LOB has been written to temp");
1165  	 	 	 	 }
1166  	 	 	 } else {
1167  	 	 	 	 $this->_refLOBs[$numlob]['VAR'] = &$var;
1168  	 	 	 }
1169  	 	 	 $rez = $tmp;
1170  	 	 } else {
1171  	 	 	 if ($this->debug)
1172  	 	 	 	 ADOConnection::outp("<b>Bind</b>: name = $name");
1173  
1174  	 	 	 if ($type !== false) {
1175  	 	 	 	 $rez = oci_bind_by_name($stmt[1],":".$name,$var,$size,$type);
1176  	 	 	 }
1177  	 	 	 else {
1178  	 	 	 	 $rez = oci_bind_by_name($stmt[1],":".$name,$var,$size); // +1 byte for null terminator
1179  	 	 	 }
1180  	 	 }
1181  
1182  	 	 return $rez;
1183  	 }
1184  
1185  	function Param($name,$type='C')
1186  	 {
1187  	 	 return ':'.$name;
1188  	 }
1189  
1190  	 /**
1191  	  * Usage:
1192  	  *    $stmt = $db->Prepare('select * from table where id =:myid and group=:group');
1193  	  *    $db->Parameter($stmt,$id,'myid');
1194  	  *    $db->Parameter($stmt,$group,'group');
1195  	  *    $db->Execute($stmt);
1196  	  *
1197  	  * @param $stmt Statement returned by Prepare() or PrepareSP().
1198  	  * @param $var PHP variable to bind to
1199  	  * @param $name Name of stored procedure variable name to bind to.
1200  	  * @param [$isOutput] Indicates direction of parameter 0/false=IN  1=OUT  2= IN/OUT. This is ignored in oci8.
1201  	  * @param [$maxLen] Holds an maximum length of the variable.
1202  	  * @param [$type] The data type of $var. Legal values depend on driver.
1203  	  *
1204  	  * @link http://php.net/oci_bind_by_name
1205  	 */
1206  	function Parameter(&$stmt,&$var,$name,$isOutput=false,$maxLen=4000,$type=false)
1207  	 {
1208  	 	 	 if  ($this->debug) {
1209  	 	 	 	 $prefix = ($isOutput) ? 'Out' : 'In';
1210  	 	 	 	 $ztype = (empty($type)) ? 'false' : $type;
1211  	 	 	 	 ADOConnection::outp( "{$prefix}Parameter(\$stmt, \$php_var='$var', \$name='$name', \$maxLen=$maxLen, \$type=$ztype);");
1212  	 	 	 }
1213  	 	 	 return $this->Bind($stmt,$var,$maxLen,$type,$name,$isOutput);
1214  	 }
1215  
1216  	 /**
1217  	  * returns query ID if successful, otherwise false
1218  	  * this version supports:
1219  	  *
1220  	  * 1. $db->execute('select * from table');
1221  	  *
1222  	  * 2. $db->prepare('insert into table (a,b,c) values (:0,:1,:2)');
1223  	  *    $db->execute($prepared_statement, array(1,2,3));
1224  	  *
1225  	  * 3. $db->execute('insert into table (a,b,c) values (:a,:b,:c)',array('a'=>1,'b'=>2,'c'=>3));
1226  	  *
1227  	  * 4. $db->prepare('insert into table (a,b,c) values (:0,:1,:2)');
1228  	  *    $db->bind($stmt,1); $db->bind($stmt,2); $db->bind($stmt,3);
1229  	  *    $db->execute($stmt);
1230  	  */
1231  	function _query($sql,$inputarr=false)
1232  	 {
1233  	 	 if (is_array($sql)) { // is prepared sql
1234  	 	 	 $stmt = $sql[1];
1235  
1236  	 	 	 // we try to bind to permanent array, so that oci_bind_by_name is persistent
1237  	 	 	 // and carried out once only - note that max array element size is 4000 chars
1238  	 	 	 if (is_array($inputarr)) {
1239  	 	 	 	 $bindpos = $sql[3];
1240  	 	 	 	 if (isset($this->_bind[$bindpos])) {
1241  	 	 	 	 // all tied up already
1242  	 	 	 	 	 $bindarr = $this->_bind[$bindpos];
1243  	 	 	 	 } else {
1244  	 	 	 	 // one statement to bind them all
1245  	 	 	 	 	 $bindarr = array();
1246  	 	 	 	 	 foreach($inputarr as $k => $v) {
1247  	 	 	 	 	 	 $bindarr[$k] = $v;
1248  	 	 	 	 	 	 oci_bind_by_name($stmt,":$k",$bindarr[$k],is_string($v) && strlen($v)>4000 ? -1 : 4000);
1249  	 	 	 	 	 }
1250  	 	 	 	 	 $this->_bind[$bindpos] = $bindarr;
1251  	 	 	 	 }
1252  	 	 	 }
1253  	 	 } else {
1254  	 	 	 $stmt=oci_parse($this->_connectionID,$sql);
1255  	 	 }
1256  
1257  	 	 $this->_stmt = $stmt;
1258  	 	 if (!$stmt) {
1259  	 	 	 return false;
1260  	 	 }
1261  
1262  	 	 if (defined('ADODB_PREFETCH_ROWS')) {
1263  	 	 	 @oci_set_prefetch($stmt,ADODB_PREFETCH_ROWS);
1264  	 	 }
1265  
1266  	 	 if (is_array($inputarr)) {
1267  	 	 	 foreach($inputarr as $k => $v) {
1268  	 	 	 	 if (is_array($v)) {
1269  	 	 	 	 	 // suggested by g.giunta@libero.
1270  	 	 	 	 	 if (sizeof($v) == 2) {
1271  	 	 	 	 	 	 oci_bind_by_name($stmt,":$k",$inputarr[$k][0],$v[1]);
1272  	 	 	 	 	 }
1273  	 	 	 	 	 else {
1274  	 	 	 	 	 	 oci_bind_by_name($stmt,":$k",$inputarr[$k][0],$v[1],$v[2]);
1275  	 	 	 	 	 }
1276  
1277  	 	 	 	 	 if ($this->debug==99) {
1278  	 	 	 	 	 	 if (is_object($v[0])) {
1279  	 	 	 	 	 	 	 echo "name=:$k",' len='.$v[1],' type='.$v[2],'<br>';
1280  	 	 	 	 	 	 }
1281  	 	 	 	 	 	 else {
1282  	 	 	 	 	 	 	 echo "name=:$k",' var='.$inputarr[$k][0],' len='.$v[1],' type='.$v[2],'<br>';
1283  	 	 	 	 	 	 }
1284  
1285  	 	 	 	 	 }
1286  	 	 	 	 } else {
1287  	 	 	 	 	 $len = -1;
1288  	 	 	 	 	 if ($v === ' ') {
1289  	 	 	 	 	 	 $len = 1;
1290  	 	 	 	 	 }
1291  	 	 	 	 	 if (isset($bindarr)) {	 // is prepared sql, so no need to oci_bind_by_name again
1292  	 	 	 	 	 	 $bindarr[$k] = $v;
1293  	 	 	 	 	 } else { 	 	 	 	 // dynamic sql, so rebind every time
1294  	 	 	 	 	 	 oci_bind_by_name($stmt,":$k",$inputarr[$k],$len);
1295  	 	 	 	 	 }
1296  	 	 	 	 }
1297  	 	 	 }
1298  	 	 }
1299  
1300  	 	 $this->_errorMsg = false;
1301  	 	 $this->_errorCode = false;
1302  	 	 if (oci_execute($stmt,$this->_commit)) {
1303  
1304  	 	 	 if (count($this -> _refLOBs) > 0) {
1305  
1306  	 	 	 	 foreach ($this -> _refLOBs as $key => $value) {
1307  	 	 	 	 	 if ($this -> _refLOBs[$key]['TYPE'] == true) {
1308  	 	 	 	 	 	 $tmp = $this -> _refLOBs[$key]['LOB'] -> load();
1309  	 	 	 	 	 	 if ($this -> debug) {
1310  	 	 	 	 	 	 	 ADOConnection::outp("<b>OUT LOB</b>: LOB has been loaded. <br>");
1311  	 	 	 	 	 	 }
1312  	 	 	 	 	 	 //$_GLOBALS[$this -> _refLOBs[$key]['VAR']] = $tmp;
1313  	 	 	 	 	 	 $this -> _refLOBs[$key]['VAR'] = $tmp;
1314  	 	 	 	 	 } else {
1315  	 	 	 	 	 	 $this->_refLOBs[$key]['LOB']->save($this->_refLOBs[$key]['VAR']);
1316  	 	 	 	 	 	 $this -> _refLOBs[$key]['LOB']->free();
1317  	 	 	 	 	 	 unset($this -> _refLOBs[$key]);
1318  	 	 	 	 	 	 if ($this->debug) {
1319  	 	 	 	 	 	 	 ADOConnection::outp("<b>IN LOB</b>: LOB has been saved. <br>");
1320  	 	 	 	 	 	 }
1321  	 	 	 	 	 }
1322  	 	 	 	 }
1323  	 	 	 }
1324  
1325  	 	 	 switch (@oci_statement_type($stmt)) {
1326  	 	 	 	 case "SELECT":
1327  	 	 	 	 	 return $stmt;
1328  
1329  	 	 	 	 case 'DECLARE':
1330  	 	 	 	 case "BEGIN":
1331  	 	 	 	 	 if (is_array($sql) && !empty($sql[4])) {
1332  	 	 	 	 	 	 $cursor = $sql[4];
1333  	 	 	 	 	 	 if (is_resource($cursor)) {
1334  	 	 	 	 	 	 	 $ok = oci_execute($cursor);
1335  	 	 	 	 	 	 	 return $cursor;
1336  	 	 	 	 	 	 }
1337  	 	 	 	 	 	 return $stmt;
1338  	 	 	 	 	 } else {
1339  	 	 	 	 	 	 if (is_resource($stmt)) {
1340  	 	 	 	 	 	 	 oci_free_statement($stmt);
1341  	 	 	 	 	 	 	 return true;
1342  	 	 	 	 	 	 }
1343  	 	 	 	 	 	 return $stmt;
1344  	 	 	 	 	 }
1345  	 	 	 	 	 break;
1346  	 	 	 	 default :
1347  
1348  	 	 	 	 	 return true;
1349  	 	 	 }
1350  	 	 }
1351  	 	 return false;
1352  	 }
1353  
1354  	 // From Oracle Whitepaper: PHP Scalability and High Availability
1355  	function IsConnectionError($err)
1356  	 {
1357  	 	 switch($err) {
1358  	 	 	 case 378: /* buffer pool param incorrect */
1359  	 	 	 case 602: /* core dump */
1360  	 	 	 case 603: /* fatal error */
1361  	 	 	 case 609: /* attach failed */
1362  	 	 	 case 1012: /* not logged in */
1363  	 	 	 case 1033: /* init or shutdown in progress */
1364  	 	 	 case 1043: /* Oracle not available */
1365  	 	 	 case 1089: /* immediate shutdown in progress */
1366  	 	 	 case 1090: /* shutdown in progress */
1367  	 	 	 case 1092: /* instance terminated */
1368  	 	 	 case 3113: /* disconnect */
1369  	 	 	 case 3114: /* not connected */
1370  	 	 	 case 3122: /* closing window */
1371  	 	 	 case 3135: /* lost contact */
1372  	 	 	 case 12153: /* TNS: not connected */
1373  	 	 	 case 27146: /* fatal or instance terminated */
1374  	 	 	 case 28511: /* Lost RPC */
1375  	 	 	 return true;
1376  	 	 }
1377  	 	 return false;
1378  	 }
1379  
1380  	 // returns true or false
1381  	function _close()
1382  	 {
1383  	 	 if (!$this->_connectionID) {
1384  	 	 	 return;
1385  	 	 }
1386  
1387  
1388  	 	 if (!$this->autoCommit) {
1389  	 	 	 oci_rollback($this->_connectionID);
1390  	 	 }
1391  	 	 if (count($this->_refLOBs) > 0) {
1392  	 	 	 foreach ($this ->_refLOBs as $key => $value) {
1393  	 	 	 	 $this->_refLOBs[$key]['LOB']->free();
1394  	 	 	 	 unset($this->_refLOBs[$key]);
1395  	 	 	 }
1396  	 	 }
1397  	 	 oci_close($this->_connectionID);
1398  
1399  	 	 $this->_stmt = false;
1400  	 	 $this->_connectionID = false;
1401  	 }
1402  
1403  	function MetaPrimaryKeys($table, $owner=false,$internalKey=false)
1404  	 {
1405  	 	 if ($internalKey) {
1406  	 	 	 return array('ROWID');
1407  	 	 }
1408  
1409  	 	 // tested with oracle 8.1.7
1410  	 	 $table = strtoupper($table);
1411  	 	 if ($owner) {
1412  	 	 	 $owner_clause = "AND ((a.OWNER = b.OWNER) AND (a.OWNER = UPPER('$owner')))";
1413  	 	 	 $ptab = 'ALL_';
1414  	 	 } else {
1415  	 	 	 $owner_clause = '';
1416  	 	 	 $ptab = 'USER_';
1417  	 	 }
1418  	 	 $sql = "
1419  SELECT /*+ RULE */ distinct b.column_name
1420     FROM {$ptab}CONSTRAINTS a
1421  	   , {$ptab}CONS_COLUMNS b
1422    WHERE ( UPPER(b.table_name) = ('$table'))
1423  	 AND (UPPER(a.table_name) = ('$table') and a.constraint_type = 'P')
1424  	 $owner_clause
1425  	 AND (a.constraint_name = b.constraint_name)";
1426  
1427  	 	 $rs = $this->Execute($sql);
1428  	 	 if ($rs && !$rs->EOF) {
1429  	 	 	 $arr = $rs->GetArray();
1430  	 	 	 $a = array();
1431  	 	 	 foreach($arr as $v) {
1432  	 	 	 	 $a[] = reset($v);
1433  	 	 	 }
1434  	 	 	 return $a;
1435  	 	 }
1436  	 	 else return false;
1437  	 }
1438  
1439  	 /**
1440  	  * returns assoc array where keys are tables, and values are foreign keys
1441  	  *
1442  	  * @param	 str	 	 $table
1443  	  * @param	 str	 	 $owner	 [optional][default=NULL]
1444  	  * @param	 bool	 $upper	 [optional][discarded]
1445  	  * @return	 mixed[]	 	 	 Array of foreign key information
1446  	  *
1447  	  * @link http://gis.mit.edu/classes/11.521/sqlnotes/referential_integrity.html
1448  	  */
1449  	function MetaForeignKeys($table, $owner=false, $upper=false)
1450  	 {
1451  	 	 global $ADODB_FETCH_MODE;
1452  
1453  	 	 $save = $ADODB_FETCH_MODE;
1454  	 	 $ADODB_FETCH_MODE = ADODB_FETCH_NUM;
1455  	 	 $table = $this->qstr(strtoupper($table));
1456  	 	 if (!$owner) {
1457  	 	 	 $owner = $this->user;
1458  	 	 	 $tabp = 'user_';
1459  	 	 } else
1460  	 	 	 $tabp = 'all_';
1461  
1462  	 	 $owner = ' and owner='.$this->qstr(strtoupper($owner));
1463  
1464  	 	 $sql =
1465  "select constraint_name,r_owner,r_constraint_name
1466  	 from {$tabp}constraints
1467  	 where constraint_type = 'R' and table_name = $table $owner";
1468  
1469  	 	 $constraints = $this->GetArray($sql);
1470  	 	 $arr = false;
1471  	 	 foreach($constraints as $constr) {
1472  	 	 	 $cons = $this->qstr($constr[0]);
1473  	 	 	 $rowner = $this->qstr($constr[1]);
1474  	 	 	 $rcons = $this->qstr($constr[2]);
1475  	 	 	 $cols = $this->GetArray("select column_name from {$tabp}cons_columns where constraint_name=$cons $owner order by position");
1476  	 	 	 $tabcol = $this->GetArray("select table_name,column_name from {$tabp}cons_columns where owner=$rowner and constraint_name=$rcons order by position");
1477  
1478  	 	 	 if ($cols && $tabcol)
1479  	 	 	 	 for ($i=0, $max=sizeof($cols); $i < $max; $i++) {
1480  	 	 	 	 	 $arr[$tabcol[$i][0]] = $cols[$i][0].'='.$tabcol[$i][1];
1481  	 	 	 	 }
1482  	 	 }
1483  	 	 $ADODB_FETCH_MODE = $save;
1484  
1485  	 	 return $arr;
1486  	 }
1487  
1488  
1489  	function CharMax()
1490  	 {
1491  	 	 return 4000;
1492  	 }
1493  
1494  	function TextMax()
1495  	 {
1496  	 	 return 4000;
1497  	 }
1498  
1499  	 /**
1500  	  * Quotes a string.
1501  	  * An example is  $db->qstr("Don't bother",magic_quotes_runtime());
1502  	  *
1503  	  * @param string $s the string to quote
1504  	  * @param bool $magic_quotes if $s is GET/POST var, set to get_magic_quotes_gpc().
1505  	  *             This undoes the stupidity of magic quotes for GPC.
1506  	  *
1507  	  * @return string quoted string to be sent back to database
1508  	  */
1509  	function qstr($s,$magic_quotes=false)
1510  	 {
1511  	 	 //$nofixquotes=false;
1512  
1513  	 	 if ($this->noNullStrings && strlen($s)==0) {
1514  	 	 	 $s = ' ';
1515  	 	 }
1516  	 	 if (!$magic_quotes) {
1517  	 	 	 if ($this->replaceQuote[0] == '\\'){
1518  	 	 	 	 $s = str_replace('\\','\\\\',$s);
1519  	 	 	 }
1520  	 	 	 return  "'".str_replace("'",$this->replaceQuote,$s)."'";
1521  	 	 }
1522  
1523  	 	 // undo magic quotes for " unless sybase is on
1524  	 	 if (!ini_get('magic_quotes_sybase')) {
1525  	 	 	 $s = str_replace('\\"','"',$s);
1526  	 	 	 $s = str_replace('\\\\','\\',$s);
1527  	 	 	 return "'".str_replace("\\'",$this->replaceQuote,$s)."'";
1528  	 	 } else {
1529  	 	 	 return "'".$s."'";
1530  	 	 }
1531  	 }
1532  
1533  }
1534  
1535  /*--------------------------------------------------------------------------------------
1536  	 Class Name: Recordset
1537  --------------------------------------------------------------------------------------*/
1538  
1539  class ADORecordset_oci8 extends ADORecordSet {
1540  
1541  	 var $databaseType = 'oci8';
1542  	 var $bind=false;
1543  	 var $_fieldobjs;
1544  
1545  	function __construct($queryID,$mode=false)
1546  	 {
1547  	 	 if ($mode === false) {
1548  	 	 	 global $ADODB_FETCH_MODE;
1549  	 	 	 $mode = $ADODB_FETCH_MODE;
1550  	 	 }
1551  	 	 switch ($mode) {
1552  	 	 	 case ADODB_FETCH_ASSOC:
1553  	 	 	 	 $this->fetchMode = OCI_ASSOC;
1554  	 	 	 	 break;
1555  	 	 	 case ADODB_FETCH_DEFAULT:
1556  	 	 	 case ADODB_FETCH_BOTH:
1557  	 	 	 	 $this->fetchMode = OCI_NUM + OCI_ASSOC;
1558  	 	 	 	 break;
1559  	 	 	 case ADODB_FETCH_NUM:
1560  	 	 	 default:
1561  	 	 	 	 $this->fetchMode = OCI_NUM;
1562  	 	 	 	 break;
1563  	 	 }
1564  	 	 $this->fetchMode += OCI_RETURN_NULLS + OCI_RETURN_LOBS;
1565  	 	 $this->adodbFetchMode = $mode;
1566  	 	 $this->_queryID = $queryID;
1567  	 }
1568  	 
1569  	 /**
1570  	 * Overrides the core destructor method as that causes problems here
1571  	 *
1572  	 * @return void
1573  	 */
1574  	function __destruct() {}
1575  
1576  	function Init()
1577  	 {
1578  	 	 if ($this->_inited) {
1579  	 	 	 return;
1580  	 	 }
1581  
1582  	 	 $this->_inited = true;
1583  	 	 if ($this->_queryID) {
1584  
1585  	 	 	 $this->_currentRow = 0;
1586  	 	 	 @$this->_initrs();
1587  	 	 	 if ($this->_numOfFields) {
1588  	 	 	 	 $this->EOF = !$this->_fetch();
1589  	 	 	 }
1590  	 	 	 else $this->EOF = true;
1591  
1592  	 	 	 /*
1593  	 	 	 // based on idea by Gaetano Giunta to detect unusual oracle errors
1594  	 	 	 // see http://phplens.com/lens/lensforum/msgs.php?id=6771
1595  	 	 	 $err = oci_error($this->_queryID);
1596  	 	 	 if ($err && $this->connection->debug) {
1597  	 	 	 	 ADOConnection::outp($err);
1598  	 	 	 }
1599  	 	 	 */
1600  
1601  	 	 	 if (!is_array($this->fields)) {
1602  	 	 	 	 $this->_numOfRows = 0;
1603  	 	 	 	 $this->fields = array();
1604  	 	 	 }
1605  	 	 } else {
1606  	 	 	 $this->fields = array();
1607  	 	 	 $this->_numOfRows = 0;
1608  	 	 	 $this->_numOfFields = 0;
1609  	 	 	 $this->EOF = true;
1610  	 	 }
1611  	 }
1612  
1613  	function _initrs()
1614  	 {
1615  	 	 $this->_numOfRows = -1;
1616  	 	 $this->_numOfFields = oci_num_fields($this->_queryID);
1617  	 	 if ($this->_numOfFields>0) {
1618  	 	 	 $this->_fieldobjs = array();
1619  	 	 	 $max = $this->_numOfFields;
1620  	 	 	 for ($i=0;$i<$max; $i++) $this->_fieldobjs[] = $this->_FetchField($i);
1621  	 	 }
1622  	 }
1623  
1624  	 /**
1625  	  * Get column information in the Recordset object.
1626  	  * fetchField() can be used in order to obtain information about fields
1627  	  * in a certain query result. If the field offset isn't specified, the next
1628  	  * field that wasn't yet retrieved by fetchField() is retrieved
1629  	  *
1630  	  * @return object containing field information
1631  	  */
1632  	function _FetchField($fieldOffset = -1)
1633  	 {
1634  	 	 $fld = new ADOFieldObject;
1635  	 	 $fieldOffset += 1;
1636  	 	 $fld->name =oci_field_name($this->_queryID, $fieldOffset);
1637  	 	 if (ADODB_ASSOC_CASE == ADODB_ASSOC_CASE_LOWER) {
1638  	 	 	 $fld->name = strtolower($fld->name);
1639  	 	 }
1640  	 	 $fld->type = oci_field_type($this->_queryID, $fieldOffset);
1641  	 	 $fld->max_length = oci_field_size($this->_queryID, $fieldOffset);
1642  
1643  	 	 switch($fld->type) {
1644  	 	 	 case 'NUMBER':
1645  	 	 	 	 $p = oci_field_precision($this->_queryID, $fieldOffset);
1646  	 	 	 	 $sc = oci_field_scale($this->_queryID, $fieldOffset);
1647  	 	 	 	 if ($p != 0 && $sc == 0) {
1648  	 	 	 	 	 $fld->type = 'INT';
1649  	 	 	 	 }
1650  	 	 	 	 $fld->scale = $p;
1651  	 	 	 	 break;
1652  
1653  	 	 	 case 'CLOB':
1654  	 	 	 case 'NCLOB':
1655  	 	 	 case 'BLOB':
1656  	 	 	 	 $fld->max_length = -1;
1657  	 	 	 	 break;
1658  	 	 }
1659  	 	 return $fld;
1660  	 }
1661  
1662  	 /* For some reason, oci_field_name fails when called after _initrs() so we cache it */
1663  	function FetchField($fieldOffset = -1)
1664  	 {
1665  	 	 return $this->_fieldobjs[$fieldOffset];
1666  	 }
1667  
1668  
1669  	function MoveNext()
1670  	 {
1671  	 	 if ($this->fields = @oci_fetch_array($this->_queryID,$this->fetchMode)) {
1672  	 	 	 $this->_currentRow += 1;
1673  	 	 	 $this->_updatefields();
1674  	 	 	 return true;
1675  	 	 }
1676  	 	 if (!$this->EOF) {
1677  	 	 	 $this->_currentRow += 1;
1678  	 	 	 $this->EOF = true;
1679  	 	 }
1680  	 	 return false;
1681  	 }
1682  
1683  	 // Optimize SelectLimit() by using oci_fetch()
1684  	function GetArrayLimit($nrows,$offset=-1)
1685  	 {
1686  	 	 if ($offset <= 0) {
1687  	 	 	 $arr = $this->GetArray($nrows);
1688  	 	 	 return $arr;
1689  	 	 }
1690  	 	 $arr = array();
1691  	 	 for ($i=1; $i < $offset; $i++) {
1692  	 	 	 if (!@oci_fetch($this->_queryID)) {
1693  	 	 	 	 return $arr;
1694  	 	 	 }
1695  	 	 }
1696  
1697  	 	 if (!$this->fields = @oci_fetch_array($this->_queryID,$this->fetchMode)) {
1698  	 	 	 return $arr;
1699  	 	 }
1700  	 	 $this->_updatefields();
1701  	 	 $results = array();
1702  	 	 $cnt = 0;
1703  	 	 while (!$this->EOF && $nrows != $cnt) {
1704  	 	 	 $results[$cnt++] = $this->fields;
1705  	 	 	 $this->MoveNext();
1706  	 	 }
1707  
1708  	 	 return $results;
1709  	 }
1710  
1711  
1712  	 // Use associative array to get fields array
1713  	function Fields($colname)
1714  	 {
1715  	 	 if (!$this->bind) {
1716  	 	 	 $this->bind = array();
1717  	 	 	 for ($i=0; $i < $this->_numOfFields; $i++) {
1718  	 	 	 	 $o = $this->FetchField($i);
1719  	 	 	 	 $this->bind[strtoupper($o->name)] = $i;
1720  	 	 	 }
1721  	 	 }
1722  
1723  	 	 return $this->fields[$this->bind[strtoupper($colname)]];
1724  	 }
1725  
1726  
1727  	function _seek($row)
1728  	 {
1729  	 	 return false;
1730  	 }
1731  
1732  	function _fetch()
1733  	 {
1734  	 	 $this->fields = @oci_fetch_array($this->_queryID,$this->fetchMode);
1735  	 	 $this->_updatefields();
1736  
1737  	 	 return $this->fields;
1738  	 }
1739  
1740  	 /**
1741  	  * close() only needs to be called if you are worried about using too much
1742  	  * memory while your script is running. All associated result memory for the
1743  	  * specified result identifier will automatically be freed.
1744  	  */
1745  	function _close()
1746  	 {
1747  	 	 if ($this->connection->_stmt === $this->_queryID) {
1748  	 	 	 $this->connection->_stmt = false;
1749  	 	 }
1750  	 	 if (!empty($this->_refcursor)) {
1751  	 	 	 oci_free_cursor($this->_refcursor);
1752  	 	 	 $this->_refcursor = false;
1753  	 	 }
1754  	 	 @oci_free_statement($this->_queryID);
1755  	 	 $this->_queryID = false;
1756  	 }
1757  
1758  	 /**
1759  	  * not the fastest implementation - quick and dirty - jlim
1760  	  * for best performance, use the actual $rs->MetaType().
1761  	  *
1762  	  * @param	 mixed	 $t
1763  	  * @param	 int	 	 $len	 	 [optional] Length of blobsize
1764  	  * @param	 bool	 $fieldobj	 [optional][discarded]
1765  	  * @return	 str	 	 	 	 	 The metatype of the field
1766  	  */
1767  	function MetaType($t, $len=-1, $fieldobj=false)
1768  	 {
1769  	 	 if (is_object($t)) {
1770  	 	 	 $fieldobj = $t;
1771  	 	 	 $t = $fieldobj->type;
1772  	 	 	 $len = $fieldobj->max_length;
1773  	 	 }
1774  
1775  	 	 switch (strtoupper($t)) {
1776  	 	 case 'VARCHAR':
1777  	 	 case 'VARCHAR2':
1778  	 	 case 'CHAR':
1779  	 	 case 'VARBINARY':
1780  	 	 case 'BINARY':
1781  	 	 case 'NCHAR':
1782  	 	 case 'NVARCHAR':
1783  	 	 case 'NVARCHAR2':
1784  	 	 	 if ($len <= $this->blobSize) {
1785  	 	 	 	 return 'C';
1786  	 	 	 }
1787  
1788  	 	 case 'NCLOB':
1789  	 	 case 'LONG':
1790  	 	 case 'LONG VARCHAR':
1791  	 	 case 'CLOB':
1792  	 	 return 'X';
1793  
1794  	 	 case 'LONG RAW':
1795  	 	 case 'LONG VARBINARY':
1796  	 	 case 'BLOB':
1797  	 	 	 return 'B';
1798  
1799  	 	 case 'DATE':
1800  	 	 	 return  ($this->connection->datetime) ? 'T' : 'D';
1801  
1802  
1803  	 	 case 'TIMESTAMP': return 'T';
1804  
1805  	 	 case 'INT':
1806  	 	 case 'SMALLINT':
1807  	 	 case 'INTEGER':
1808  	 	 	 return 'I';
1809  
1810  	 	 default:
1811  	 	 	 return 'N';
1812  	 	 }
1813  	 }
1814  }
1815  
1816  class ADORecordSet_ext_oci8 extends ADORecordSet_oci8 {
1817  	function __construct($queryID,$mode=false)
1818  	 {
1819  	 	 parent::__construct($queryID, $mode);
1820  	 }
1821  
1822  	function MoveNext()
1823  	 {
1824  	 	 return adodb_movenext($this);
1825  	 }
1826  }