home *** CD-ROM | disk | FTP | other *** search
/ Enter 2004 June / ENTER.ISO / files / xampp-win32-1.4.5-installer.exe / xampp / adodb-odbc.inc.php < prev    next >
Encoding:
PHP Script  |  2004-03-20  |  18.8 KB  |  711 lines
  1. <?php
  2. /* 
  3. V4.21 20 Mar 2004  (c) 2000-2004 John Lim (jlim#natsoft.com.my). All rights reserved.
  4.   Released under both BSD license and Lesser GPL library license. 
  5.   Whenever there is any discrepancy between the two licenses, 
  6.   the BSD license will take precedence. 
  7. Set tabs to 4 for best viewing.
  8.   
  9.   Latest version is available at http://php.weblogs.com/
  10.   
  11.   Requires ODBC. Works on Windows and Unix.
  12. */
  13.   define("_ADODB_ODBC_LAYER", 2 );
  14.      
  15. /*--------------------------------------------------------------------------------------
  16. --------------------------------------------------------------------------------------*/
  17.  
  18.  
  19. class ADODB_odbc extends ADOConnection {
  20.     var $databaseType = "odbc";    
  21.     var $fmtDate = "'Y-m-d'";
  22.     var $fmtTimeStamp = "'Y-m-d, h:i:sA'";
  23.     var $replaceQuote = "''"; // string to use to replace quotes
  24.     var $dataProvider = "odbc";
  25.     var $hasAffectedRows = true;
  26.     var $binmode = ODBC_BINMODE_RETURN;
  27.     var $useFetchArray = false; // setting this to true will make array elements in FETCH_ASSOC mode case-sensitive
  28.                                 // breaking backward-compat
  29.     //var $longreadlen = 8000; // default number of chars to return for a Blob/Long field
  30.     var $_bindInputArray = false;    
  31.     var $curmode = SQL_CUR_USE_DRIVER; // See sqlext.h, SQL_CUR_DEFAULT == SQL_CUR_USE_DRIVER == 2L
  32.     var $_genSeqSQL = "create table %s (id integer)";
  33.     var $_autocommit = true;
  34.     var $_haserrorfunctions = true;
  35.     var $_has_stupid_odbc_fetch_api_change = true;
  36.     var $_lastAffectedRows = 0;
  37.     
  38.     function ADODB_odbc() 
  39.     {     
  40.         $this->_haserrorfunctions = ADODB_PHPVER >= 0x4050;
  41.         $this->_has_stupid_odbc_fetch_api_change = ADODB_PHPVER >= 0x4200;
  42.     }
  43.     
  44.     function ServerInfo()
  45.     {
  46.     
  47.         if (!empty($this->host) && ADODB_PHPVER >= 0x4300) {
  48.             $dsn = strtoupper($this->host);
  49.             $first = true;
  50.             $found = false;
  51.             
  52.             if (!function_exists('odbc_data_source')) return false;
  53.             
  54.             while(true) {
  55.                 
  56.                 $rez = odbc_data_source($this->_connectionID,
  57.                     $first ? SQL_FETCH_FIRST : SQL_FETCH_NEXT);
  58.                 $first = false;
  59.                 if (!is_array($rez)) break;
  60.                 if (strtoupper($rez['server']) == $dsn) {
  61.                     $found = true;
  62.                     break;
  63.                 }
  64.             } 
  65.             if (!$found) return ADOConnection::ServerInfo();
  66.             if (!isset($rez['version'])) $rez['version'] = '';
  67.             return $rez;
  68.         } else {
  69.             return ADOConnection::ServerInfo();
  70.         }
  71.     }
  72.  
  73.     
  74.     function CreateSequence($seqname='adodbseq',$start=1)
  75.     {
  76.         if (empty($this->_genSeqSQL)) return false;
  77.         $ok = $this->Execute(sprintf($this->_genSeqSQL,$seqname));
  78.         if (!$ok) return false;
  79.         $start -= 1;
  80.         return $this->Execute("insert into $seqname values($start)");
  81.     }
  82.     
  83.     var $_dropSeqSQL = 'drop table %s';
  84.     function DropSequence($seqname)
  85.     {
  86.         if (empty($this->_dropSeqSQL)) return false;
  87.         return $this->Execute(sprintf($this->_dropSeqSQL,$seqname));
  88.     }
  89.     
  90.     /*
  91.         This algorithm is not very efficient, but works even if table locking
  92.         is not available.
  93.         
  94.         Will return false if unable to generate an ID after $MAXLOOPS attempts.
  95.     */
  96.     function GenID($seq='adodbseq',$start=1)
  97.     {    
  98.         // if you have to modify the parameter below, your database is overloaded,
  99.         // or you need to implement generation of id's yourself!
  100.         $MAXLOOPS = 100;
  101.         //$this->debug=1;
  102.         while (--$MAXLOOPS>=0) {
  103.             $num = $this->GetOne("select id from $seq");
  104.             if ($num === false) {
  105.                 $this->Execute(sprintf($this->_genSeqSQL ,$seq));    
  106.                 $start -= 1;
  107.                 $num = '0';
  108.                 $ok = $this->Execute("insert into $seq values($start)");
  109.                 if (!$ok) return false;
  110.             } 
  111.             $this->Execute("update $seq set id=id+1 where id=$num");
  112.             
  113.             if ($this->affected_rows() > 0) {
  114.                 $num += 1;
  115.                 $this->genID = $num;
  116.                 return $num;
  117.             }
  118.         }
  119.         if ($fn = $this->raiseErrorFn) {
  120.             $fn($this->databaseType,'GENID',-32000,"Unable to generate unique id after $MAXLOOPS attempts",$seq,$num);
  121.         }
  122.         return false;
  123.     }
  124.  
  125.  
  126.     function ErrorMsg()
  127.     {
  128.         if ($this->_haserrorfunctions) {
  129.             if ($this->_errorMsg !== false) return $this->_errorMsg;
  130.             if (empty($this->_connectionID)) return @odbc_errormsg();
  131.             return @odbc_errormsg($this->_connectionID);
  132.         } else return ADOConnection::ErrorMsg();
  133.     }
  134.     
  135.     function ErrorNo()
  136.     {
  137.         
  138.         if ($this->_haserrorfunctions) {
  139.             if ($this->_errorCode !== false) {
  140.                 // bug in 4.0.6, error number can be corrupted string (should be 6 digits)
  141.                 return (strlen($this->_errorCode)<=2) ? 0 : $this->_errorCode;
  142.             }
  143.  
  144.             if (empty($this->_connectionID)) $e = @odbc_error(); 
  145.             else $e = @odbc_error($this->_connectionID);
  146.             
  147.              // bug in 4.0.6, error number can be corrupted string (should be 6 digits)
  148.              // so we check and patch
  149.             if (strlen($e)<=2) return 0;
  150.             return $e;
  151.         } else return ADOConnection::ErrorNo();
  152.     }
  153.     
  154.     
  155.     // returns true or false
  156.     function _connect($argDSN, $argUsername, $argPassword, $argDatabasename)
  157.     {
  158.     global $php_errormsg;
  159.         
  160.         if (!function_exists('odbc_connect')) return false;
  161.         
  162.         if ($this->debug && $argDatabasename) {
  163.             ADOConnection::outp("For odbc Connect(), $argDatabasename is not used. Place dsn in 1st parameter.");
  164.         }
  165.         $php_errormsg = '';
  166.         if ($this->curmode === false) $this->_connectionID = odbc_connect($argDSN,$argUsername,$argPassword);
  167.         else $this->_connectionID = odbc_connect($argDSN,$argUsername,$argPassword,$this->curmode);
  168.         $this->_errorMsg = $php_errormsg;
  169.         if (isset($this->connectStmt)) $this->Execute($this->connectStmt);
  170.         
  171.         //if ($this->_connectionID) odbc_autocommit($this->_connectionID,true);
  172.         return $this->_connectionID != false;
  173.     }
  174.     
  175.     // returns true or false
  176.     function _pconnect($argDSN, $argUsername, $argPassword, $argDatabasename)
  177.     {
  178.     global $php_errormsg;
  179.     
  180.         if (!function_exists('odbc_connect')) return false;
  181.         
  182.         $php_errormsg = '';
  183.         if ($this->debug && $argDatabasename) {
  184.             ADOConnection::outp("For odbc PConnect(), $argDatabasename is not used. Place dsn in 1st parameter.");
  185.         }
  186.     //    print "dsn=$argDSN u=$argUsername p=$argPassword<br>"; flush();
  187.         if ($this->curmode === false) $this->_connectionID = odbc_connect($argDSN,$argUsername,$argPassword);
  188.         else $this->_connectionID = odbc_pconnect($argDSN,$argUsername,$argPassword,$this->curmode);
  189.         
  190.         $this->_errorMsg = $php_errormsg;
  191.         if ($this->_connectionID && $this->autoRollback) @odbc_rollback($this->_connectionID);
  192.         if (isset($this->connectStmt)) $this->Execute($this->connectStmt);
  193.         
  194.         return $this->_connectionID != false;
  195.     }
  196.  
  197.     function BeginTrans()
  198.     {    
  199.         if (!$this->hasTransactions) return false;
  200.         if ($this->transOff) return true; 
  201.         $this->transCnt += 1;
  202.         $this->_autocommit = false;
  203.         return odbc_autocommit($this->_connectionID,false);
  204.     }
  205.     
  206.     function CommitTrans($ok=true) 
  207.     { 
  208.         if ($this->transOff) return true; 
  209.         if (!$ok) return $this->RollbackTrans();
  210.         if ($this->transCnt) $this->transCnt -= 1;
  211.         $this->_autocommit = true;
  212.         $ret = odbc_commit($this->_connectionID);
  213.         odbc_autocommit($this->_connectionID,true);
  214.         return $ret;
  215.     }
  216.     
  217.     function RollbackTrans()
  218.     {
  219.         if ($this->transOff) return true; 
  220.         if ($this->transCnt) $this->transCnt -= 1;
  221.         $this->_autocommit = true;
  222.         $ret = odbc_rollback($this->_connectionID);
  223.         odbc_autocommit($this->_connectionID,true);
  224.         return $ret;
  225.     }
  226.     
  227.     function MetaPrimaryKeys($table)
  228.     {
  229.     global $ADODB_FETCH_MODE;
  230.     
  231.         $savem = $ADODB_FETCH_MODE;
  232.         $ADODB_FETCH_MODE = ADODB_FETCH_NUM;
  233.         $qid = @odbc_primarykeys($this->_connectionID,'','',$table);
  234.         
  235.         if (!$qid) {
  236.             $ADODB_FETCH_MODE = $savem;
  237.             return false;
  238.         }
  239.         $rs = new ADORecordSet_odbc($qid);
  240.         $ADODB_FETCH_MODE = $savem;
  241.         
  242.         if (!$rs) return false;
  243.         $rs->_has_stupid_odbc_fetch_api_change = $this->_has_stupid_odbc_fetch_api_change;
  244.         
  245.         $arr =& $rs->GetArray();
  246.         $rs->Close();
  247.         //print_r($arr);
  248.         $arr2 = array();
  249.         for ($i=0; $i < sizeof($arr); $i++) {
  250.             if ($arr[$i][3]) $arr2[] = $arr[$i][3];
  251.         }
  252.         return $arr2;
  253.     }
  254.     
  255.     
  256.     
  257.     function &MetaTables($ttype=false)
  258.     {
  259.     global $ADODB_FETCH_MODE;
  260.     
  261.         $savem = $ADODB_FETCH_MODE;
  262.         $ADODB_FETCH_MODE = ADODB_FETCH_NUM;
  263.         $qid = odbc_tables($this->_connectionID);
  264.         
  265.         $rs = new ADORecordSet_odbc($qid);
  266.         
  267.         $ADODB_FETCH_MODE = $savem;
  268.         if (!$rs) return false;
  269.         
  270.         $rs->_has_stupid_odbc_fetch_api_change = $this->_has_stupid_odbc_fetch_api_change;
  271.         
  272.         $arr =& $rs->GetArray();
  273.         //print_r($arr);
  274.         
  275.         $rs->Close();
  276.         $arr2 = array();
  277.         
  278.         if ($ttype) {
  279.             $isview = strncmp($ttype,'V',1) === 0;
  280.         }
  281.         for ($i=0; $i < sizeof($arr); $i++) {
  282.             if (!$arr[$i][2]) continue;
  283.             $type = $arr[$i][3];
  284.             if ($ttype) { 
  285.                 if ($isview) {
  286.                     if (strncmp($type,'V',1) === 0) $arr2[] = $arr[$i][2];
  287.                 } else if (strncmp($type,'SYS',3) !== 0) $arr2[] = $arr[$i][2];
  288.             } else if (strncmp($type,'SYS',3) !== 0) $arr2[] = $arr[$i][2];
  289.         }
  290.         return $arr2;
  291.     }
  292.     
  293. /*
  294. / SQL data type codes /
  295. #define    SQL_UNKNOWN_TYPE    0
  296. #define SQL_CHAR            1
  297. #define SQL_NUMERIC         2
  298. #define SQL_DECIMAL         3
  299. #define SQL_INTEGER         4
  300. #define SQL_SMALLINT        5
  301. #define SQL_FLOAT           6
  302. #define SQL_REAL            7
  303. #define SQL_DOUBLE          8
  304. #if (ODBCVER >= 0x0300)
  305. #define SQL_DATETIME        9
  306. #endif
  307. #define SQL_VARCHAR        12
  308.  
  309. / One-parameter shortcuts for date/time data types /
  310. #if (ODBCVER >= 0x0300)
  311. #define SQL_TYPE_DATE      91
  312. #define SQL_TYPE_TIME      92
  313. #define SQL_TYPE_TIMESTAMP 93
  314.  
  315. #define SQL_UNICODE                             (-95)
  316. #define SQL_UNICODE_VARCHAR                     (-96)
  317. #define SQL_UNICODE_LONGVARCHAR                 (-97)
  318. */
  319.     function ODBCTypes($t)
  320.     {
  321.         switch ((integer)$t) {
  322.         case 1:    
  323.         case 12:
  324.         case 0:
  325.         case -95:
  326.         case -96:
  327.             return 'C';
  328.         case -97:
  329.         case -1: //text
  330.             return 'X';
  331.         case -4: //image
  332.             return 'B';
  333.                 
  334.         case 91:
  335.         case 11:
  336.             return 'D';
  337.             
  338.         case 92:
  339.         case 93:
  340.         case 9:    return 'T';
  341.         case 4:
  342.         case 5:
  343.         case -6:
  344.             return 'I';
  345.             
  346.         case -11: // uniqidentifier
  347.             return 'R';
  348.         case -7: //bit
  349.             return 'L';
  350.         
  351.         default:
  352.             return 'N';
  353.         }
  354.     }
  355.     
  356.     function &MetaColumns($table)
  357.     {
  358.     global $ADODB_FETCH_MODE;
  359.     
  360.         $table = strtoupper($table);
  361.         $schema = false;
  362.         $this->_findschema($table,$schema);
  363.         
  364.         $savem = $ADODB_FETCH_MODE;
  365.         $ADODB_FETCH_MODE = ADODB_FETCH_NUM;
  366.     
  367.         if (false) { // after testing, confirmed that the following does not work becoz of a bug
  368.             $qid2 = odbc_tables($this->_connectionID);
  369.             $rs = new ADORecordSet_odbc($qid2);        
  370.             $ADODB_FETCH_MODE = $savem;
  371.             if (!$rs) return false;
  372.             $rs->_has_stupid_odbc_fetch_api_change = $this->_has_stupid_odbc_fetch_api_change;
  373.             $rs->_fetch();
  374.             
  375.             while (!$rs->EOF) {
  376.                 if ($table == strtoupper($rs->fields[2])) {
  377.                     $q = $rs->fields[0];
  378.                     $o = $rs->fields[1];
  379.                     break;
  380.                 }
  381.                 $rs->MoveNext();
  382.             }
  383.             $rs->Close();
  384.             
  385.             $qid = odbc_columns($this->_connectionID,$q,$o,strtoupper($table),'%');
  386.         } else switch ($this->databaseType) {
  387.         case 'access':
  388.         case 'vfp':
  389.         case 'db2':
  390.             $qid = odbc_columns($this->_connectionID);
  391.             break;
  392.             
  393.         default:
  394.             $qid = @odbc_columns($this->_connectionID,'%','%',strtoupper($table),'%');
  395.             if (empty($qid)) $qid = odbc_columns($this->_connectionID);
  396.             break;
  397.         }
  398.         if (empty($qid)) return false;
  399.         
  400.         $rs = new ADORecordSet_odbc($qid);
  401.         $ADODB_FETCH_MODE = $savem;
  402.         
  403.         if (!$rs) return false;
  404.         
  405.         $rs->_has_stupid_odbc_fetch_api_change = $this->_has_stupid_odbc_fetch_api_change;
  406.         $rs->_fetch();
  407.         $retarr = array();
  408.         
  409.         /*
  410.         $rs->fields indices
  411.         0 TABLE_QUALIFIER
  412.         1 TABLE_SCHEM
  413.         2 TABLE_NAME
  414.         3 COLUMN_NAME
  415.         4 DATA_TYPE
  416.         5 TYPE_NAME
  417.         6 PRECISION
  418.         7 LENGTH
  419.         8 SCALE
  420.         9 RADIX
  421.         10 NULLABLE
  422.         11 REMARKS
  423.         */
  424.         while (!$rs->EOF) {
  425.             //adodb_pr($rs->fields);
  426.             if (strtoupper($rs->fields[2]) == $table && (!$schema || strtoupper($rs->fields[1]) == $schema)) {
  427.                 $fld = new ADOFieldObject();
  428.                 $fld->name = $rs->fields[3];
  429.                 $fld->type = $this->ODBCTypes($rs->fields[4]);
  430.                 
  431.                 // ref: http://msdn.microsoft.com/library/default.asp?url=/archive/en-us/dnaraccgen/html/msdn_odk.asp
  432.                 // access uses precision to store length for char/varchar
  433.                 if ($fld->type == 'C' or $fld->type == 'X') {
  434.                     if ($this->databaseType == 'access') 
  435.                         $fld->max_length = $rs->fields[6];
  436.                     else if ($rs->fields[4] <= -95) // UNICODE
  437.                         $fld->max_length = $rs->fields[7]/2;
  438.                     else
  439.                         $fld->max_length = $rs->fields[7];
  440.                 } else 
  441.                     $fld->max_length = $rs->fields[7];
  442.                 $fld->not_null = !empty($rs->fields[10]);
  443.                 $fld->scale = $rs->fields[8];
  444.                 $retarr[strtoupper($fld->name)] = $fld;    
  445.             } else if (sizeof($retarr)>0)
  446.                 break;
  447.             $rs->MoveNext();
  448.         }
  449.         $rs->Close(); //-- crashes 4.03pl1 -- why?
  450.         
  451.         return $retarr;
  452.     }
  453.     
  454.     function Prepare($sql)
  455.     {
  456.         if (! $this->_bindInputArray) return $sql; // no binding
  457.         $stmt = odbc_prepare($this->_connectionID,$sql);
  458.         if (!$stmt) {
  459.             // we don't know whether odbc driver is parsing prepared stmts, so just return sql
  460.             return $sql;
  461.         }
  462.         return array($sql,$stmt,false);
  463.     }
  464.  
  465.     /* returns queryID or false */
  466.     function _query($sql,$inputarr=false) 
  467.     {
  468.     GLOBAL $php_errormsg;
  469.         $php_errormsg = '';
  470.         $this->_error = '';
  471.         
  472.         if ($inputarr) {
  473.             if (is_array($sql)) {
  474.                 $stmtid = $sql[1];
  475.             } else {
  476.                 $stmtid = odbc_prepare($this->_connectionID,$sql);
  477.     
  478.                 if ($stmtid == false) {
  479.                     $this->_errorMsg = $php_errormsg;
  480.                     return false;
  481.                 }
  482.             }
  483.             
  484.             if (! odbc_execute($stmtid,$inputarr)) {
  485.                 //@odbc_free_result($stmtid);
  486.                 if ($this->_haserrorfunctions) {
  487.                     $this->_errorMsg = odbc_errormsg();
  488.                     $this->_errorCode = odbc_error();
  489.                 }
  490.                 return false;
  491.             }
  492.         
  493.         } else if (is_array($sql)) {
  494.             $stmtid = $sql[1];
  495.             if (!odbc_execute($stmtid)) {
  496.                 //@odbc_free_result($stmtid);
  497.                 if ($this->_haserrorfunctions) {
  498.                     $this->_errorMsg = odbc_errormsg();
  499.                     $this->_errorCode = odbc_error();
  500.                 }
  501.                 return false;
  502.             }
  503.         } else
  504.             $stmtid = odbc_exec($this->_connectionID,$sql);
  505.         
  506.         $this->_lastAffectedRows = 0;
  507.         if ($stmtid) {
  508.             if (@odbc_num_fields($stmtid) == 0) {
  509.                 $this->_lastAffectedRows = odbc_num_rows($stmtid);
  510.                 $stmtid = true;
  511.             } else {
  512.                 $this->_lastAffectedRows = 0;
  513.                 odbc_binmode($stmtid,$this->binmode);
  514.                 odbc_longreadlen($stmtid,$this->maxblobsize);
  515.             }
  516.             
  517.             if ($this->_haserrorfunctions) {
  518.                 $this->_errorMsg = '';
  519.                 $this->_errorCode = 0;
  520.             } else
  521.                 $this->_errorMsg = $php_errormsg;
  522.         } else {
  523.             if ($this->_haserrorfunctions) {
  524.                 $this->_errorMsg = odbc_errormsg();
  525.                 $this->_errorCode = odbc_error();
  526.             } else
  527.                 $this->_errorMsg = $php_errormsg;
  528.         }
  529.         return $stmtid;
  530.     }
  531.  
  532.     /*
  533.         Insert a null into the blob field of the table first.
  534.         Then use UpdateBlob to store the blob.
  535.         
  536.         Usage:
  537.          
  538.         $conn->Execute('INSERT INTO blobtable (id, blobcol) VALUES (1, null)');
  539.         $conn->UpdateBlob('blobtable','blobcol',$blob,'id=1');
  540.     */
  541.     function UpdateBlob($table,$column,$val,$where,$blobtype='BLOB')
  542.     {
  543.         return $this->Execute("UPDATE $table SET $column=? WHERE $where",array($val)) != false;
  544.     }
  545.     
  546.     // returns true or false
  547.     function _close()
  548.     {
  549.         $ret = @odbc_close($this->_connectionID);
  550.         $this->_connectionID = false;
  551.         return $ret;
  552.     }
  553.  
  554.     function _affectedrows()
  555.     {
  556.         return $this->_lastAffectedRows;
  557.     }
  558.     
  559. }
  560.     
  561. /*--------------------------------------------------------------------------------------
  562.      Class Name: Recordset
  563. --------------------------------------------------------------------------------------*/
  564.  
  565. class ADORecordSet_odbc extends ADORecordSet {    
  566.     
  567.     var $bind = false;
  568.     var $databaseType = "odbc";        
  569.     var $dataProvider = "odbc";
  570.     var $useFetchArray;
  571.     var $_has_stupid_odbc_fetch_api_change;
  572.     
  573.     function ADORecordSet_odbc($id,$mode=false)
  574.     {
  575.         if ($mode === false) {  
  576.             global $ADODB_FETCH_MODE;
  577.             $mode = $ADODB_FETCH_MODE;
  578.         }
  579.         $this->fetchMode = $mode;
  580.         
  581.         $this->_queryID = $id;
  582.         
  583.         // the following is required for mysql odbc driver in 4.3.1 -- why?
  584.         $this->EOF = false;
  585.         $this->_currentRow = -1;
  586.         //$this->ADORecordSet($id);
  587.     }
  588.  
  589.  
  590.     // returns the field object
  591.     function &FetchField($fieldOffset = -1) 
  592.     {
  593.         
  594.         $off=$fieldOffset+1; // offsets begin at 1
  595.         
  596.         $o= new ADOFieldObject();
  597.         $o->name = @odbc_field_name($this->_queryID,$off);
  598.         $o->type = @odbc_field_type($this->_queryID,$off);
  599.         $o->max_length = @odbc_field_len($this->_queryID,$off);
  600.         if (ADODB_ASSOC_CASE == 0) $o->name = strtolower($o->name);
  601.         else if (ADODB_ASSOC_CASE == 1) $o->name = strtoupper($o->name);
  602.         return $o;
  603.     }
  604.     
  605.     /* Use associative array to get fields array */
  606.     function Fields($colname)
  607.     {
  608.         if ($this->fetchMode & ADODB_FETCH_ASSOC) return $this->fields[$colname];
  609.         if (!$this->bind) {
  610.             $this->bind = array();
  611.             for ($i=0; $i < $this->_numOfFields; $i++) {
  612.                 $o = $this->FetchField($i);
  613.                 $this->bind[strtoupper($o->name)] = $i;
  614.             }
  615.         }
  616.  
  617.          return $this->fields[$this->bind[strtoupper($colname)]];
  618.     }
  619.     
  620.         
  621.     function _initrs()
  622.     {
  623.     global $ADODB_COUNTRECS;
  624.         $this->_numOfRows = ($ADODB_COUNTRECS) ? @odbc_num_rows($this->_queryID) : -1;
  625.         $this->_numOfFields = @odbc_num_fields($this->_queryID);
  626.         // some silly drivers such as db2 as/400 and intersystems cache return _numOfRows = 0
  627.         if ($this->_numOfRows == 0) $this->_numOfRows = -1;
  628.         //$this->useFetchArray = $this->connection->useFetchArray;
  629.         $this->_has_stupid_odbc_fetch_api_change = ADODB_PHPVER >= 0x4200;
  630.     }    
  631.     
  632.     function _seek($row)
  633.     {
  634.         return false;
  635.     }
  636.     
  637.     // speed up SelectLimit() by switching to ADODB_FETCH_NUM as ADODB_FETCH_ASSOC is emulated
  638.     function &GetArrayLimit($nrows,$offset=-1) 
  639.     {
  640.         if ($offset <= 0) {
  641.             $rs =& $this->GetArray($nrows);
  642.             return $rs;
  643.         }
  644.         $savem = $this->fetchMode;
  645.         $this->fetchMode = ADODB_FETCH_NUM;
  646.         $this->Move($offset);
  647.         $this->fetchMode = $savem;
  648.         
  649.         if ($this->fetchMode & ADODB_FETCH_ASSOC) {
  650.             $this->fields =& $this->GetRowAssoc(ADODB_ASSOC_CASE);
  651.         }
  652.         
  653.         $results = array();
  654.         $cnt = 0;
  655.         while (!$this->EOF && $nrows != $cnt) {
  656.             $results[$cnt++] = $this->fields;
  657.             $this->MoveNext();
  658.         }
  659.         
  660.         return $results;
  661.     }
  662.     
  663.     
  664.     function MoveNext() 
  665.     {
  666.         if ($this->_numOfRows != 0 && !$this->EOF) {        
  667.             $this->_currentRow++;
  668.             $row = 0;
  669.             if ($this->_has_stupid_odbc_fetch_api_change)
  670.                 $rez = @odbc_fetch_into($this->_queryID,$this->fields);
  671.             else 
  672.                 $rez = @odbc_fetch_into($this->_queryID,$row,$this->fields);
  673.             if ($rez) {
  674.                 if ($this->fetchMode & ADODB_FETCH_ASSOC) {
  675.                     $this->fields =& $this->GetRowAssoc(ADODB_ASSOC_CASE);
  676.                 }
  677.                 return true;
  678.             }
  679.         }
  680.         $this->fields = false;
  681.         $this->EOF = true;
  682.         return false;
  683.     }    
  684.     
  685.     function _fetch()
  686.     {
  687.         $row = 0;
  688.         if ($this->_has_stupid_odbc_fetch_api_change)
  689.             $rez = @odbc_fetch_into($this->_queryID,$this->fields,$row);
  690.         else 
  691.             $rez = @odbc_fetch_into($this->_queryID,$row,$this->fields);
  692.         
  693.         if ($rez) {
  694.             if ($this->fetchMode & ADODB_FETCH_ASSOC) {
  695.                 $this->fields =& $this->GetRowAssoc(ADODB_ASSOC_CASE);
  696.             }
  697.             return true;
  698.         }
  699.         $this->fields = false;
  700.         return false;
  701.     }
  702.     
  703.     function _close() 
  704.     {
  705.         return @odbc_free_result($this->_queryID);        
  706.     }
  707.  
  708. }
  709.  
  710. ?>
  711.