home *** CD-ROM | disk | FTP | other *** search
/ PC World 2003 March / PCWorld_2003-03_cd.bin / Software / Vyzkuste / phptriad / phptriad2-2-1.exe / php / pear / DB / oci8.php < prev    next >
Encoding:
PHP Script  |  2001-11-13  |  20.1 KB  |  675 lines
  1. <?php
  2. //
  3. // +----------------------------------------------------------------------+
  4. // | PHP version 4.0                                                      |
  5. // +----------------------------------------------------------------------+
  6. // | Copyright (c) 1997-2001 The PHP Group                                |
  7. // +----------------------------------------------------------------------+
  8. // | This source file is subject to version 2.02 of the PHP license,      |
  9. // | that is bundled with this package in the file LICENSE, and is        |
  10. // | available at through the world-wide-web at                           |
  11. // | http://www.php.net/license/2_02.txt.                                 |
  12. // | If you did not receive a copy of the PHP license and are unable to   |
  13. // | obtain it through the world-wide-web, please send a note to          |
  14. // | license@php.net so we can mail you a copy immediately.               |
  15. // +----------------------------------------------------------------------+
  16. // | Authors: James L. Pine <jlp@valinux.com>                             |
  17. // |                                                                      |
  18. // +----------------------------------------------------------------------+
  19. //
  20. // $Id: oci8.php,v 1.26.2.2 2001/11/13 01:26:42 ssb Exp $
  21. //
  22. // Database independent query interface definition for PHP's Oracle 8
  23. // call-interface extension.
  24. //
  25.  
  26. //
  27. // be aware...  OCIError() only appears to return anything when given a
  28. // statement, so functions return the generic DB_ERROR instead of more
  29. // useful errors that have to do with feedback from the database.
  30. //
  31.  
  32.  
  33. require_once 'DB/common.php';
  34.  
  35. class DB_oci8 extends DB_common
  36. {
  37.     // {{{ properties
  38.  
  39.     var $connection;
  40.     var $phptype, $dbsyntax;
  41.     var $manip_query = array();
  42.     var $prepare_types = array();
  43.     var $autoCommit = 1;
  44.     var $last_stmt = false;
  45.  
  46.     // }}}
  47.     // {{{ constructor
  48.  
  49.     function DB_oci8()
  50.     {
  51.         $this->DB_common();
  52.         $this->phptype = 'oci8';
  53.         $this->dbsyntax = 'oci8';
  54.         $this->features = array(
  55.             'prepare' => false,
  56.             'pconnect' => true,
  57.             'transactions' => true,
  58.             'limit' => 'alter'
  59.         );
  60.         $this->errorcode_map = array(
  61.             900 => DB_ERROR_SYNTAX,
  62.             904 => DB_ERROR_NOSUCHFIELD,
  63.             923 => DB_ERROR_SYNTAX,
  64.             942 => DB_ERROR_NOSUCHTABLE,
  65.             955 => DB_ERROR_ALREADY_EXISTS,
  66.             1476 => DB_ERROR_DIVZERO,
  67.             1722 => DB_ERROR_INVALID_NUMBER,
  68.             2289 => DB_ERROR_NOSUCHTABLE,
  69.             2291 => DB_ERROR_CONSTRAINT,
  70.             2449 => DB_ERROR_CONSTRAINT,
  71.         );
  72.     }
  73.  
  74.     // }}}
  75.     // {{{ connect()
  76.  
  77.     /**
  78.      * Connect to a database and log in as the specified user.
  79.      *
  80.      * @param $dsn the data source name (see DB::parseDSN for syntax)
  81.      * @param $persistent (optional) whether the connection should
  82.      *        be persistent
  83.      *
  84.      * @return int DB_OK on success, a DB error code on failure
  85.      */
  86.     function connect($dsninfo, $persistent = false)
  87.     {
  88.         if (!DB::assertExtension("oci8"))
  89.             return $this->raiseError(DB_ERROR_EXTENSION_NOT_FOUND);
  90.  
  91.         $this->dsn = $dsninfo;
  92.         $user = $dsninfo['username'];
  93.         $pw = $dsninfo['password'];
  94.         $hostspec = $dsninfo['hostspec'];
  95.  
  96.         $connect_function = $persistent ? 'OCIPLogon' : 'OCILogon';
  97.  
  98.         if ($hostspec) {
  99.             $conn = @$connect_function($user,$pw,$hostspec);
  100.         } elseif ($user || $pw) {
  101.             $conn = @$connect_function($user,$pw);
  102.         } else {
  103.             $conn = false;
  104.         }
  105.         if ($conn == false) {
  106.             return $this->raiseError(DB_ERROR_CONNECT_FAILED);
  107.         }
  108.         $this->connection = $conn;
  109.         return DB_OK;
  110.     }
  111.  
  112.     // }}}
  113.     // {{{ disconnect()
  114.  
  115.     /**
  116.      * Log out and disconnect from the database.
  117.      *
  118.      * @return bool TRUE on success, FALSE if not connected.
  119.      */
  120.     function disconnect()
  121.     {
  122.         $ret = @OCILogOff($this->connection);
  123.         $this->connection = null;
  124.         return $ret;
  125.     }
  126.  
  127.     // }}}
  128.     // {{{ simpleQuery()
  129.  
  130.     /**
  131.      * Send a query to oracle and return the results as an oci8 resource
  132.      * identifier.
  133.      *
  134.      * @param $query the SQL query
  135.      *
  136.      * @return int returns a valid oci8 result for successful SELECT
  137.      * queries, DB_OK for other successful queries.  A DB error code
  138.      * is returned on failure.
  139.      */
  140.     function simpleQuery($query)
  141.     {
  142.         $this->last_query = $query;
  143.         $query = $this->modifyQuery($query);
  144.         $result = @OCIParse($this->connection, $query);
  145.         if (!$result) {
  146.             return $this->oci8RaiseError();
  147.         }
  148.         if ($this->autoCommit) {
  149.             $success = @OCIExecute($result,OCI_COMMIT_ON_SUCCESS);
  150.         } else {
  151.             $success = @OCIExecute($result,OCI_DEFAULT);
  152.         }
  153.         if (!$success) {
  154.             return $this->oci8RaiseError($result);
  155.         }
  156.         $this->last_stmt=$result;
  157.         // Determine which queries that should return data, and which
  158.         // should return an error code only.
  159.         return DB::isManip($query) ? DB_OK : $result;
  160.     }
  161.  
  162.     // }}}
  163.     // {{{ nextResult()
  164.  
  165.     /**
  166.      * Move the internal oracle result pointer to the next available result
  167.      *
  168.      * @param a valid fbsql result resource
  169.      *
  170.      * @access public
  171.      *
  172.      * @return true if a result is available otherwise return false
  173.      */
  174.     function nextResult($result)
  175.     {
  176.         return false;
  177.     }
  178.  
  179.     // }}}
  180.     // {{{ fetchRow()
  181.  
  182.     /**
  183.      * Fetch a row and return as array.
  184.      *
  185.      * @param $result oci8 result identifier
  186.      * @param $fetchmode how the resulting array should be indexed
  187.      *
  188.      * @return int an array on success, a DB error code on failure, NULL
  189.      *             if there is no more data
  190.      */
  191.     function &fetchRow($result, $fetchmode = DB_FETCHMODE_DEFAULT)
  192.     {
  193.         if ($fetchmode == DB_FETCHMODE_DEFAULT) {
  194.             $fetchmode = $this->fetchmode;
  195.         }
  196.         if ($fetchmode & DB_FETCHMODE_ASSOC) {
  197.             $moredata = @OCIFetchInto($result, $row, OCI_ASSOC + OCI_RETURN_NULLS + OCI_RETURN_LOBS);
  198.         } else {
  199.             $moredata = @OCIFetchInto($result, $row, OCI_RETURN_NULLS + OCI_RETURN_LOBS);
  200.         }
  201.         if (!$moredata) {
  202.             return NULL;
  203.         }
  204.         return $row;
  205.     }
  206.  
  207.     // }}}
  208.     // {{{ fetchInto()
  209.  
  210.     /**
  211.      * Fetch a row and insert the data into an existing array.
  212.      *
  213.      * @param $result oci8 result identifier
  214.      * @param $arr (reference) array where data from the row is stored
  215.      * @param $fetchmode how the array data should be indexed
  216.      * @param $rownum the row number to fetch (not yet supported)
  217.      *
  218.      * @return int DB_OK on success, a DB error code on failure
  219.      */
  220.     function fetchInto($result, &$arr, $fetchmode = DB_FETCHMODE_DEFAULT, $rownum=NULL)
  221.     {
  222.         if ($rownum !== NULL) {
  223.             return $this->raiseError(DB_ERROR_NOT_CAPABLE);
  224.         }
  225.         if ($fetchmode == DB_FETCHMODE_DEFAULT) {
  226.             $fetchmode = $this->fetchmode;
  227.         }
  228.         if ($fetchmode & DB_FETCHMODE_ASSOC) {
  229.             $moredata = @OCIFetchInto($result,$arr,OCI_ASSOC+OCI_RETURN_NULLS+OCI_RETURN_LOBS);
  230.         } else {
  231.             $moredata = @OCIFetchInto($result,$arr,OCI_RETURN_NULLS+OCI_RETURN_LOBS);
  232.         }
  233.         if (!$moredata) {
  234.             return NULL;
  235.         }
  236.         return DB_OK;
  237.     }
  238.  
  239.     // }}}
  240.     // {{{ freeResult()
  241.  
  242.     /**
  243.      * Free the internal resources associated with $result.
  244.      *
  245.      * @param $result oci8 result identifier or DB statement identifier
  246.      *
  247.      * @return bool TRUE on success, FALSE if $result is invalid
  248.      */
  249.     function freeResult($result)
  250.     {
  251.         if (is_resource($result)) {
  252.             return @OCIFreeStatement($result);
  253.         }
  254.         if (!isset($this->prepare_tokens[(int)$result])) {
  255.             return false;
  256.         }
  257.         unset($this->prepare_tokens[(int)$result]);
  258.         unset($this->prepare_types[(int)$result]);
  259.         unset($this->manip_query[(int)$result]);
  260.         return true;
  261.     }
  262.  
  263.     // }}}
  264.     // {{{ numRows()
  265.  
  266.     function numRows($result)
  267.     {
  268.         // emulate numRows for Oracle.  yuck.
  269.         if ($this->options['optimize'] == 'portability' &&
  270.             $result === $this->last_stmt) {
  271.             $countquery = preg_replace('/^\s*SELECT\s+(.*?)[,\s].*\s+FROM\s+/is',
  272.                                        'SELECT COUNT(\1) FROM ',
  273.                                        $this->last_query);
  274.             $save_query = $this->last_query;
  275.             $save_stmt = $this->last_stmt;
  276.             $count = $this->query($countquery);
  277.             if (DB::isError($count) ||
  278.                 DB::isError($row = $count->fetchRow(DB_FETCHMODE_ORDERED)))
  279.             {
  280.                 $this->last_query = $save_query;
  281.                 $this->last_stmt = $save_stmt;
  282.                 return $this->raiseError(DB_ERROR_NOT_CAPABLE);
  283.             }
  284.             return $row[0];
  285.         }
  286.         return $this->raiseError(DB_ERROR_NOT_CAPABLE);
  287.     }
  288.  
  289.     // }}}
  290.     // {{{ numCols()
  291.  
  292.     /**
  293.      * Get the number of columns in a result set.
  294.      *
  295.      * @param $result oci8 result identifier
  296.      *
  297.      * @return int the number of columns per row in $result
  298.      */
  299.     function numCols($result)
  300.     {
  301.         $cols = @OCINumCols($result);
  302.         if (!$cols) {
  303.             return $this->oci8RaiseError($result);
  304.         }
  305.         return $cols;
  306.     }
  307.  
  308.     // }}}
  309.     // {{{ errorNative()
  310.  
  311.     /**
  312.      * Get the native error code of the last error (if any) that occured
  313.      * on the current connection.  This does not work, as OCIError does
  314.      * not work unless given a statement.  If OCIError does return
  315.      * something, so will this.
  316.      *
  317.      * @return int native oci8 error code
  318.      */
  319.     function errorNative()
  320.     {
  321.         if (is_resource($this->last_stmt)) {
  322.             $error = @OCIError($this->last_stmt);
  323.         } else {
  324.             $error = @OCIError($this->connection);
  325.         }
  326.         if (is_array($error)) {
  327.             return $error['code'];
  328.         }
  329.         return false;
  330.     }
  331.  
  332.     // }}}
  333.     // {{{ prepare()
  334.  
  335.     /**
  336.      * Prepares a query for multiple execution with execute().  With
  337.      * oci8, this is emulated.
  338.      * @param $query query to be prepared
  339.      *
  340.      * @return DB statement resource
  341.      */
  342.     function prepare($query)
  343.     {
  344.         $tokens = split('[\&\?]', $query);
  345.         $token = 0;
  346.         $types = array();
  347.         for ($i = 0; $i < strlen($query); $i++) {
  348.             switch ($query[$i]) {
  349.                 case '?':
  350.                     $types[$token++] = DB_PARAM_SCALAR;
  351.                     break;
  352.                 case '&':
  353.                     $types[$token++] = DB_PARAM_OPAQUE;
  354.                     break;
  355.             }
  356.         }
  357.         $binds = sizeof($tokens) - 1;
  358.         for ($i = 0; $i < $binds; $i++) {
  359.             $newquery .= $tokens[$i] . ":bind" . $i;
  360.         }
  361.         $newquery .= $tokens[$i];
  362.         $this->last_query = $query;
  363.         $newquery = $this->modifyQuery($newquery);
  364.         $stmt = @OCIParse($this->connection, $newquery);
  365.         $this->prepare_types[$stmt] = $types;
  366.         $this->manip_query[(int)$stmt] = DB::isManip($query);
  367.         return $stmt;
  368.     }
  369.  
  370.     // }}}
  371.     // {{{ execute()
  372.  
  373.     /**
  374.      * Executes a DB statement prepared with prepare().
  375.      *
  376.      * @param $stmt a DB statement resource (returned from prepare())
  377.      * @param $data data to be used in execution of the statement
  378.      *
  379.      * @return int returns an oci8 result resource for successful
  380.      * SELECT queries, DB_OK for other successful queries.  A DB error
  381.      * code is returned on failure.
  382.      */
  383.     function execute($stmt, $data = false)
  384.     {
  385.         $types=&$this->prepare_types[$stmt];
  386.         if (($size = sizeof($types)) != sizeof($data)) {
  387.             return $this->raiseError(DB_ERROR_MISMATCH);
  388.         }
  389.         for ($i = 0; $i < $size; $i++) {
  390.             if (is_array($data)) {
  391.                 $pdata[$i] = &$data[$i];
  392.             }
  393.             else {
  394.                 $pdata[$i] = &$data;
  395.             }
  396.             if ($types[$i] == DB_PARAM_OPAQUE) {
  397.                 $fp = fopen($pdata[$i], "r");
  398.                 $pdata = '';
  399.                 if ($fp) {
  400.                     while (($buf = fread($fp, 4096)) != false) {
  401.                         $pdata[$i] .= $buf;
  402.                     }
  403.                 }
  404.             }
  405.             if (!@OCIBindByName($stmt, ":bind" . $i, $pdata[$i], -1)) {
  406.                 return $this->oci8RaiseError($stmt);
  407.             }
  408.         }
  409.         if ($this->autoCommit) {
  410.             $success = @OCIExecute($stmt, OCI_COMMIT_ON_SUCCESS);
  411.         }
  412.         else {
  413.             $success = @OCIExecute($stmt, OCI_DEFAULT);
  414.         }
  415.         if (!$success) {
  416.             return $this->oci8RaiseError($stmt);
  417.         }
  418.         $this->last_stmt = $stmt;
  419.         if ($this->manip_query[(int)$stmt]) {
  420.             return DB_OK;
  421.         } else {
  422.             return new DB_result($this, $stmt);
  423.         }
  424.     }
  425.  
  426.     // }}}
  427.     // {{{ autoCommit()
  428.  
  429.     /**
  430.      * Enable/disable automatic commits
  431.      *
  432.      * @param $onoff true/false whether to autocommit
  433.      */
  434.     function autoCommit($onoff = false)
  435.     {
  436.         $this->autoCommit = (bool)$onoff;;
  437.         return DB_OK;
  438.     }
  439.  
  440.     // }}}
  441.     // {{{ commit()
  442.  
  443.     /**
  444.      * Commit transactions on the current connection
  445.      *
  446.      * @return DB_ERROR or DB_OK
  447.      */
  448.     function commit()
  449.     {
  450.         $result = @OCICommit($this->connection);
  451.         if (!$result) {
  452.             return $this->oci8RaiseError();
  453.         }
  454.         return DB_OK;
  455.     }
  456.  
  457.     // }}}
  458.     // {{{ rollback()
  459.  
  460.     /**
  461.      * Roll back all uncommitted transactions on the current connection.
  462.      *
  463.      * @return DB_ERROR or DB_OK
  464.      */
  465.     function rollback()
  466.     {
  467.         $result = @OCIRollback($this->connection);
  468.         if (!$result) {
  469.             return $this->oci8RaiseError();
  470.         }
  471.         return DB_OK;
  472.     }
  473.  
  474.     // }}}
  475.     // {{{ affectedRows()
  476.  
  477.     /**
  478.      * Gets the number of rows affected by the last query.
  479.      * if the last query was a select, returns 0.
  480.      *
  481.      * @return number of rows affected by the last query or DB_ERROR
  482.      */
  483.     function affectedRows()
  484.     {
  485.         if ($this->last_stmt === false) {
  486.             return $this->oci8RaiseError();
  487.         }
  488.         $result = @OCIRowCount($this->last_stmt);
  489.         if ($result === false) {
  490.             return $this->oci8RaiseError($this->last_stmt);
  491.         }
  492.         return $result;
  493.     }
  494.  
  495.     // }}}
  496.     // {{{ modifyQuery()
  497.  
  498.     function modifyQuery($query)
  499.     {
  500.         // "SELECT 2+2" must be "SELECT 2+2 FROM dual" in Oracle
  501.         if (preg_match('/^\s*SELECT/i', $query) &&
  502.             !preg_match('/\sFROM\s/i', $query)) {
  503.             $query .= " FROM dual";
  504.         }
  505.         return $query;
  506.     }
  507.  
  508.     // }}}
  509.     // {{{ modifyLimitQuery()
  510.  
  511.     /**
  512.     * Emulate the row limit support altering the query
  513.     *
  514.     * @param string $query The query to treat
  515.     * @param int    $from  The row to start to fetch from
  516.     * @param int    $count The offset
  517.     * @return string The modified query
  518.     *
  519.     * @author Tomas V.V.Cox <cox@idecnet.com>
  520.     */
  521.     function modifyLimitQuery($query, $from, $count)
  522.     {
  523.         // Find fields (supports UNIONs also)
  524.         $t = preg_split('/\s+FROM\s+/is', $query);
  525.         $f = preg_replace('/^\s*SELECT\s+/is', '', $t[0]);
  526.  
  527.         // Put the "Order by" statement at the end of the final query
  528.         if (preg_match('/\s+ORDER\s+BY\s+.*/is', $query, $match)) {
  529.             $orderby = $match[0];
  530.             $query = substr($query, 0, -1 * strlen($orderby));
  531.         } else {
  532.             $orderby = '';
  533.         }
  534.  
  535.         // Field parsing: Try to find final column names
  536.         $fa = array();
  537.         $grab = true;
  538.         $tmpbuff = '';
  539.         for ($i = 0; $i < strlen($f); $i++) {
  540.             // Probably doesn't work if the query contains a funcion without
  541.             // alias ("AS"), for ex: to_char(...) as date
  542.             if ($f{$i} == '(') { //don't parse commas acting as func params
  543.                 $grab = false;
  544.             } elseif ($f{$i} == ')') {
  545.                 $grab = true;
  546.             }
  547.             if (preg_match('/\sAS\s/i', substr($tmpbuff, -4))) {
  548.                 $tmpbuff = '';
  549.             }
  550.             if ($f{$i} == ',' && $grab) {
  551.                 $fa[] = $tmpbuff;
  552.                 $tmpbuff = '';
  553.                 continue;
  554.             }
  555.             $tmpbuff .= $f{$i};
  556.         }
  557.         $fa[] = $tmpbuff;
  558.         $fields = implode(', ', $fa);
  559.  
  560.         // Construct the query
  561.         // more at: http://marc.theaimsgroup.com/?l=php-db&m=99831958101212&w=2
  562.         $query = "SELECT $fields FROM".
  563.                  "  (SELECT rownum as linenum, $fields FROM".
  564.                  "      ($query)".
  565.                  "  ) ".
  566.                  "WHERE linenum BETWEEN $from AND ". ($from + $count) .
  567.                  "$orderby";
  568.  
  569.         return $query;
  570.     }
  571.  
  572.     // }}}
  573.     // {{{ nextId()
  574.  
  575.     /**
  576.      * Get the next value in a sequence.  We emulate sequences
  577.      * for MySQL.  Will create the sequence if it does not exist.
  578.      *
  579.      * @access public
  580.      *
  581.      * @param $seq_name the name of the sequence
  582.      *
  583.      * @param $ondemand whether to create the sequence table on demand
  584.      * (default is true)
  585.      *
  586.      * @return a sequence integer, or a DB error
  587.      */
  588.     function nextId($seq_name, $ondemand = true)
  589.     {
  590.         $sqn = preg_replace('/[^a-z0-9_]/i', '_', $seq_name);
  591.         $repeat = 0;
  592.         do {
  593.             $result = $this->query("SELECT ${sqn}_seq.nextval FROM dual");
  594.             if ($ondemand && DB::isError($result) &&
  595.                 $result->getCode() == DB_ERROR_NOSUCHTABLE) {
  596.                 $repeat = 1;
  597.                 $result = $this->createSequence($seq_name);
  598.                 if (DB::isError($result)) {
  599.                     return $result;
  600.                 }
  601.             } else {
  602.                 $repeat = 0;
  603.             }
  604.         } while ($repeat);
  605.         if (DB::isError($result)) {
  606.             return $result;
  607.         }
  608.         $arr = $result->fetchRow(DB_FETCHMODE_ORDERED);
  609.         return $arr[0];
  610.     }
  611.  
  612.     // }}}
  613.     // {{{ createSequence()
  614.  
  615.     function createSequence($seq_name)
  616.     {
  617.         $sqn = preg_replace('/[^a-z0-9_]/i', '_', $seq_name);
  618.         return $this->query("CREATE SEQUENCE ${sqn}_seq");
  619.     }
  620.  
  621.     // }}}
  622.     // {{{ dropSequence()
  623.  
  624.     function dropSequence($seq_name)
  625.     {
  626.         $sqn = preg_replace('/[^a-z0-9_]/i', '_', $seq_name);
  627.         return $this->query("DROP SEQUENCE ${sqn}_seq");
  628.     }
  629.  
  630.     // }}}
  631.     // {{{ oci8RaiseError()
  632.  
  633.     function oci8RaiseError($errno = null)
  634.     {
  635.         if ($errno === null) {
  636.             $error = @OCIError($this->connection);
  637.             return $this->raiseError($this->errorCode($error['code']),
  638.                                      null, null, null, $error['message']);
  639.         } elseif (is_resource($errno)) {
  640.             $error = @OCIError($errno);
  641.             return $this->raiseError($this->errorCode($error['code']),
  642.                                      null, null, null, $error['message']);
  643.         }
  644.         return $this->raiseError($this->errorCode($errno));
  645.     }
  646.  
  647.     // }}}
  648.     // {{{ getSpecialQuery()
  649.  
  650.     /**
  651.     * Returns the query needed to get some backend info
  652.     * @param string $type What kind of info you want to retrieve
  653.     * @return string The SQL query string
  654.     */
  655.     function getSpecialQuery($type)
  656.     {
  657.         switch ($type) {
  658.             case 'tables':
  659.                 $sql = "SELECT table_name FROM user_tables";
  660.                 break;
  661.             default:
  662.                 return null;
  663.         }
  664.         return $sql;
  665.     }
  666.  
  667.     // }}}
  668.  
  669. }
  670.  
  671. // Local variables:
  672. // tab-width: 4
  673. // c-basic-offset: 4
  674. // End:
  675. ?>