home *** CD-ROM | disk | FTP | other *** search
/ PC World 2005 April / PCWorld_2005-04_cd.bin / akce / web / phpnuke / PHP-Nuke-7.5.exe / html / includes / sql_layer.php < prev    next >
PHP Script  |  2004-01-29  |  11KB  |  528 lines
  1. <?php
  2.  
  3. /************************************************************************/
  4. /* PHP-NUKE: Web Portal System                                          */
  5. /* ===========================                                          */
  6. /*                                                                      */
  7. /* Copyright (c) 2002 by Francisco Burzi                                */
  8. /* http://phpnuke.org                                                   */
  9. /*                                                                      */
  10. /* postgres fix by RubΘn Campos - Oscar Silla                         */
  11. /*                                                                      */
  12. /* This program is free software. You can redistribute it and/or modify */
  13. /* it under the terms of the GNU General Public License as published by */
  14. /* the Free Software Foundation; either version 2 of the License.       */
  15. /************************************************************************/
  16.  
  17. if (eregi("sql_layer.php",$_SERVER['PHP_SELF'])) {
  18.     Header("Location: ../index.php");
  19.     die();
  20. }
  21.  
  22. /* $dbtype = "MySQL"; */
  23. /* $dbtype = "mSQL"; */
  24. /* $dbtype = "postgres"; */
  25. /* $dbtype = "postgres_local";// When postmaster start without "-i" option. */
  26. /* $dbtype = "ODBC"; */
  27. /* $dbtype = "ODBC_Adabas"; */
  28. /* $dbtype = "Interbase"; */
  29. /* $dbtype = "Sybase"; */
  30.  
  31. /*
  32.  * sql_connect($host, $user, $password, $db)
  33.  * returns the connection ID
  34.  */
  35.  
  36.  
  37. class ResultSet {
  38.     var $result;
  39.     var $total_rows;
  40.     var $fetched_rows;
  41.  
  42.     function set_result( $res ) {
  43.         $this->result = $res;
  44.     }
  45.  
  46.     function get_result() {
  47.         return $this->result;
  48.     }
  49.  
  50.     function set_total_rows( $rows ) {
  51.         $this->total_rows = $rows;
  52.     }
  53.  
  54.     function get_total_rows() {
  55.         return $this->total_rows;
  56.     }
  57.  
  58.     function set_fetched_rows( $rows ) {
  59.         $this->fetched_rows = $rows;
  60.     }
  61.  
  62.     function get_fetched_rows() {
  63.         return $this->fetched_rows;
  64.     }
  65.  
  66.     function increment_fetched_rows() {
  67.         $this->fetched_rows = $this->fetched_rows + 1;
  68.     }
  69. }
  70.  
  71.  
  72.  
  73. function sql_connect($host, $user, $password, $db)
  74. {
  75. global $dbtype;
  76. switch ($dbtype) {
  77.  
  78.     case "MySQL":
  79.         $dbi=@mysql_connect($host, $user, $password);
  80.     mysql_select_db($db);
  81.         return $dbi;
  82.     break;;
  83.  
  84.     case "mSQL":
  85.          $dbi=msql_connect($host);
  86.      msql_select_db($db);
  87.      return $dbi;
  88.     break;;
  89.  
  90.  
  91.     case "postgres":
  92.          $dbi=@pg_connect("host=$host user=$user password=$password port=5432 dbname=$db");
  93.          return $dbi;
  94.     break;;
  95.  
  96.     case "postgres_local":
  97.          $dbi=@pg_connect("user=$user password=$password dbname=$db");
  98.          return $dbi;
  99.     break;;
  100.  
  101.     case "ODBC":
  102.          $dbi=@odbc_connect($db,$user,$password);
  103.          return $dbi;
  104.     break;;
  105.  
  106.     case "ODBC_Adabas":
  107.          $dbi=@odbc_connect($host.":".$db,$user,$password);
  108.      return $dbi;
  109.     break;;
  110.  
  111.     case "Interbase":
  112.          $dbi=@ibase_connect($host.":".$db,$user,$password);
  113.          return $dbi;
  114.     break;;
  115.  
  116.     case "Sybase":
  117.         $dbi=@sybase_connect($host, $user, $password);
  118.         sybase_select_db($db,$dbi);
  119.     return $dbi;
  120.     break;;
  121.  
  122.     default:
  123.     break;;
  124.     }
  125.  
  126. }
  127.  
  128. function sql_logout($id)
  129. {
  130. global $dbtype;
  131. switch ($dbtype) {
  132.  
  133.     case "MySQL":
  134.         $dbi=@mysql_close($id);
  135.         return $dbi;
  136.     break;;
  137.  
  138.     case "mSQL":
  139.          $dbi=@msql_close($id);
  140.          return $dbi;
  141.     break;;
  142.  
  143.     case "postgres":
  144.     case "postgres_local":
  145.          $dbi=@pg_close($id);
  146.          return $dbi;
  147.     break;;
  148.   
  149.     case "ODBC":
  150.     case "ODBC_Adabas":
  151.          $dbi=@odbc_close($id);
  152.          return $dbi;  
  153.     break;;
  154.  
  155.     case "Interbase":
  156.          $dbi=@ibase_close($id);
  157.          return $dbi;
  158.     break;;
  159.  
  160.     case "Sybase":
  161.         $dbi=@sybase_close($id);
  162.         return $dbi;
  163.     break;;
  164.  
  165.     default:
  166.     break;;
  167.     }
  168. }
  169.  
  170.  
  171. /*
  172.  * sql_query($query, $id)
  173.  * executes an SQL statement, returns a result identifier
  174.  */
  175.  
  176. function sql_query($query, $id)
  177. {
  178.  
  179. global $dbtype;
  180. global $sql_debug;
  181. $sql_debug = 0;
  182. if($sql_debug) echo "SQL query: ".str_replace(",",", ",$query)."<BR>";
  183. switch ($dbtype) {
  184.  
  185.     case "MySQL":
  186.         $res=@mysql_query($query, $id);
  187.         return $res;
  188.     break;;
  189.  
  190.     case "mSQL":
  191.         $res=@msql_query($query, $id);
  192.         return $res;
  193.     break;;
  194.  
  195.     case "postgres":
  196.     case "postgres_local":
  197.     $res=pg_exec($id,$query);
  198.     $result_set = new ResultSet;
  199.     $result_set->set_result( $res );
  200.     $result_set->set_total_rows( sql_num_rows( $result_set ) );
  201.     $result_set->set_fetched_rows( 0 );
  202.         return $result_set;
  203.     break;;
  204.  
  205.     case "ODBC":
  206.     case "ODBC_Adabas":
  207.         $res=@odbc_exec($id,$query);
  208.         return $res;
  209.     break;;
  210.  
  211.     case "Interbase":
  212.         $res=@ibase_query($id,$query);
  213.         return $res;
  214.     break;;
  215.  
  216.     case "Sybase":
  217.         $res=@sybase_query($query, $id);
  218.         return $res;
  219.     break;;
  220.  
  221.     default:
  222.     break;;
  223.  
  224.     }
  225. }
  226.  
  227. /*
  228.  * sql_num_rows($res)
  229.  * given a result identifier, returns the number of affected rows
  230.  */
  231.  
  232. function sql_num_rows($res)
  233. {
  234. global $dbtype;
  235. switch ($dbtype) {
  236.  
  237.     case "MySQL":
  238.         $rows=mysql_num_rows($res);
  239.         return $rows;
  240.     break;;
  241.  
  242.     case "mSQL":  
  243.         $rows=msql_num_rows($res);
  244.         return $rows;
  245.     break;;
  246.  
  247.     case "postgres":
  248.     case "postgres_local":
  249.         $rows=pg_numrows( $res->get_result() );
  250.         return $rows;
  251.     break;;
  252.         
  253.     case "ODBC":
  254.     case "ODBC_Adabas":
  255.         $rows=odbc_num_rows($res);
  256.         return $rows; 
  257.     break;;
  258.         
  259.     case "Interbase":
  260.     echo "<BR>Error! PHP dosen't support ibase_numrows!<BR>";
  261.         return $rows; 
  262.     break;;
  263.  
  264.     case "Sybase":
  265.         $rows=sybase_num_rows($res);
  266.         return $rows; 
  267.     break;;
  268.  
  269.     default:
  270.     break;;
  271.     }
  272. }
  273.  
  274. /*
  275.  * sql_fetch_row(&$res,$row)
  276.  * given a result identifier, returns an array with the resulting row
  277.  * Needs also a row number for compatibility with postgres
  278.  */
  279.  
  280. function sql_fetch_row(&$res, $nr=0)
  281. {
  282. global $dbtype;
  283. switch ($dbtype) {
  284.  
  285.     case "MySQL":
  286.         $row = mysql_fetch_row($res);
  287.         return $row;
  288.     break;;
  289.  
  290.     case "mSQL":
  291.         $row = msql_fetch_row($res);
  292.         return $row;
  293.     break;;
  294.  
  295.     case "postgres":
  296.     case "postgres_local":
  297.     if ( $res->get_total_rows() > $res->get_fetched_rows() ) {
  298.         $row = pg_fetch_row($res->get_result(), $res->get_fetched_rows() );
  299.         $res->increment_fetched_rows();
  300.         return $row;
  301.     } else {
  302.         return false;
  303.     }
  304.     break;;
  305.  
  306.     case "ODBC":
  307.     case "ODBC_Adabas":
  308.         $row = array();
  309.         $cols = odbc_fetch_into($res, $nr, $row);
  310.         return $row;
  311.     break;;
  312.  
  313.     case "Interbase":
  314.         $row = ibase_fetch_row($res);
  315.         return $row;
  316.     break;;
  317.  
  318.     case "Sybase":
  319.         $row = sybase_fetch_row($res);
  320.         return $row;
  321.     break;;
  322.  
  323.     default:
  324.     break;;
  325.     }
  326. }
  327.  
  328. /*
  329.  * sql_fetch_array($res,$row)
  330.  * given a result identifier, returns an associative array
  331.  * with the resulting row using field names as keys.
  332.  * Needs also a row number for compatibility with postgres.
  333.  */
  334.  
  335. function sql_fetch_array(&$res, $nr=0)
  336. {
  337. global $dbtype;
  338. switch ($dbtype)
  339.     {
  340.     case "MySQL":
  341.         $row = array();
  342.         $row = mysql_fetch_array($res);
  343.         return $row;
  344.     break;;
  345.  
  346.     case "mSQL":
  347.         $row = array();
  348.         $row = msql_fetch_array($res);
  349.         return $row;
  350.     break;;
  351.  
  352.     case "postgres":
  353.     case "postgres_local":
  354.     if( $res->get_total_rows() > $res->get_fetched_rows() ) {
  355.         $row = array();
  356.         $row = pg_fetch_array($res->get_result(), $res->get_fetched_rows() );
  357.         $res->increment_fetched_rows();
  358.         return $row;
  359.     } else {
  360.         return false;
  361.     }
  362.     break;;
  363.  
  364. /*
  365.  * ODBC doesn't have a native _fetch_array(), so we have to
  366.  * use a trick. Beware: this might cause HUGE loads!
  367.  */
  368.  
  369.     case "ODBC":
  370.         $row = array();
  371.         $result = array();
  372.         $result = odbc_fetch_row($res, $nr);
  373.     $nf = odbc_num_fields($res); /* Field numbering starts at 1 */
  374.         for($count=1; $count < $nf+1; $count++)
  375.     {
  376.             $field_name = odbc_field_name($res, $count);
  377.             $field_value = odbc_result($res, $field_name);
  378.             $row[$field_name] = $field_value;
  379.         }
  380.         return $row;
  381.     break;;
  382.  
  383.     case "ODBC_Adabas":
  384.         $row = array();
  385.         $result = array();
  386.         $result = odbc_fetch_row($res, $nr);
  387.  
  388.         $nf = count($result)+2; /* Field numbering starts at 1 */
  389.     for($count=1; $count < $nf; $count++) {
  390.         $field_name = odbc_field_name($res, $count);
  391.         $field_value = odbc_result($res, $field_name);
  392.         $row[$field_name] = $field_value;
  393.     }
  394.         return $row;
  395.     break;;
  396.  
  397.     case "Interbase":
  398.     $orow=ibase_fetch_object($res);
  399.     $row=get_object_vars($orow);
  400.         return $row;
  401.     break;;
  402.  
  403.     case "Sybase":
  404.         $row = sybase_fetch_array($res);
  405.         return $row;
  406.     break;;
  407.  
  408.     }
  409. }
  410.  
  411. function sql_fetch_object(&$res, $nr=0)
  412. {
  413. global $dbtype;
  414. switch ($dbtype)
  415.     {
  416.     case "MySQL":
  417.         $row = mysql_fetch_object($res);
  418.     if($row) return $row;
  419.     else return false;
  420.     break;;
  421.  
  422.     case "mSQL":
  423.         $row = msql_fetch_object($res);
  424.     if($row) return $row;
  425.     else return false;
  426.     break;;
  427.  
  428.     case "postgres":
  429.     case "postgres_local":
  430.     if( $res->get_total_rows() > $res->get_fetched_rows() ) {
  431.         $row = pg_fetch_object( $res->get_result(), $res->get_fetched_rows() );
  432.         $res->increment_fetched_rows();
  433.         if($row) return $row;
  434.         else return false;
  435.     } else {
  436.         return false;
  437.     }
  438.     break;;
  439.  
  440.     case "ODBC":
  441.         $result = odbc_fetch_row($res, $nr);
  442.     if(!$result) return false;
  443.     $nf = odbc_num_fields($res); /* Field numbering starts at 1 */
  444.         for($count=1; $count < $nf+1; $count++)
  445.     {
  446.             $field_name = odbc_field_name($res, $count);
  447.             $field_value = odbc_result($res, $field_name);
  448.             $row->$field_name = $field_value;
  449.         }
  450.         return $row;
  451.     break;;
  452.  
  453.     case "ODBC_Adabas":
  454.         $result = odbc_fetch_row($res, $nr);
  455.     if(!$result) return false;
  456.  
  457.         $nf = count($result)+2; /* Field numbering starts at 1 */
  458.     for($count=1; $count < $nf; $count++) {
  459.         $field_name = odbc_field_name($res, $count);
  460.         $field_value = odbc_result($res, $field_name);
  461.         $row->$field_name = $field_value;
  462.     }
  463.         return $row;
  464.     break;;
  465.  
  466.     case "Interbase":
  467.         $orow = ibase_fetch_object($res);
  468.     if($orow)
  469.     {
  470.         $arow=get_object_vars($orow);
  471.         while(list($name,$key)=each($arow))
  472.         {
  473.         $name=strtolower($name);
  474.         $row->$name=$key;
  475.         }
  476.             return $row;
  477.     }else return false;
  478.     break;;
  479.  
  480.     case "Sybase":
  481.         $row = sybase_fetch_object($res);
  482.         return $row;
  483.     break;;
  484.  
  485.     }
  486. }
  487.  
  488. /*** Function Free Result for function free the memory ***/
  489. function sql_free_result($res) {
  490. global $dbtype;
  491. switch ($dbtype) {
  492.  
  493.     case "MySQL":
  494.         $row = mysql_free_result($res);
  495.         return $row;
  496.     break;;
  497.  
  498.        case "mSQL":
  499.         $row = msql_free_result($res);
  500.         return $row;
  501.     break;;
  502.  
  503.  
  504.         case "postgres":
  505.     case "postgres_local":
  506.         $rows=pg_FreeResult( $res->get_result() );
  507.         return $rows;
  508.     break;;
  509.  
  510.     case "ODBC":
  511.     case "ODBC_Adabas":
  512.         $rows=odbc_free_result($res);
  513.         return $rows;
  514.     break;;
  515.  
  516.     case "Interbase":
  517.     echo "<BR>Error! PHP dosen't support ibase_numrows!<BR>";
  518.         return $rows;
  519.     break;;
  520.  
  521.     case "Sybase":
  522.         $rows=sybase_free_result($res);
  523.         return $rows;
  524.     break;;
  525.     }
  526. }
  527.  
  528. ?>