home *** CD-ROM | disk | FTP | other *** search
/ Internet Magazine 2003 May / INTERNET103.ISO / pc / software / windows / building / php_nuke / html / includes / sql_layer.php < prev   
Encoding:
PHP Script  |  2002-09-16  |  12.0 KB  |  543 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. /* PostgreSQL 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",$PHP_SELF)) {
  18.     Header("Location: ../index.php");
  19.     die();
  20. }
  21.  
  22. /* $dbtype = "MySQL"; */
  23. /* $dbtype = "mSQL"; */
  24. /* $dbtype = "PostgreSQL"; */
  25. /* $dbtype = "PostgreSQL_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.         if (!mysql_select_db($db)) {
  81.         mysql_query("CREATE DATABASE $db");
  82.         mysql_select_db($db);
  83.         include("includes/install.php");
  84.         die();
  85.     }
  86.         return $dbi;
  87.     break;;
  88.  
  89.     case "mSQL":
  90.          $dbi=msql_connect($host);
  91.          if (!msql_select_db($db)) {
  92.         msql_query("CREATE DATABASE $db");
  93.         msql_select_db($db);
  94.         include("includes/install.php");
  95.         die();
  96.          }
  97.      return $dbi;
  98.     break;;
  99.  
  100.  
  101.     case "PostgreSQL":
  102.          $dbi=@pg_connect("host=$host user=$user password=$password port=5432 dbname=$db");
  103.          return $dbi;
  104.     break;;
  105.  
  106.     case "PostgreSQL_local":
  107.          $dbi=@pg_connect("user=$user password=$password dbname=$db");
  108.          return $dbi;
  109.     break;;
  110.  
  111.     case "ODBC":
  112.          $dbi=@odbc_connect($db,$user,$password);
  113.          return $dbi;
  114.     break;;
  115.  
  116.     case "ODBC_Adabas":
  117.          $dbi=@odbc_connect($host.":".$db,$user,$password);
  118.      return $dbi;
  119.     break;;
  120.  
  121.     case "Interbase":
  122.          $dbi=@ibase_connect($host.":".$db,$user,$password);
  123.          return $dbi;
  124.     break;;
  125.  
  126.     case "Sybase":
  127.         $dbi=@sybase_connect($host, $user, $password);
  128.     if (!sybase_select_db($db,$dbi)) {
  129.         sybase_query("CREATE DATABASE $db",$dbi);
  130.             sybase_select_db($db,$dbi);
  131.             include("includes/install.php");
  132.         die();
  133.     }
  134.     return $dbi;
  135.     break;;
  136.  
  137.     default:
  138.     break;;
  139.     }
  140.  
  141. }
  142.  
  143. function sql_logout($id)
  144. {
  145. global $dbtype;
  146. switch ($dbtype) {
  147.  
  148.     case "MySQL":
  149.         $dbi=@mysql_close($id);
  150.         return $dbi;
  151.     break;;
  152.  
  153.     case "mSQL":
  154.          $dbi=@msql_close($id);
  155.          return $dbi;
  156.     break;;
  157.  
  158.     case "PostgreSQL":
  159.     case "PostgreSQL_local":
  160.          $dbi=@pg_close($id);
  161.          return $dbi;
  162.     break;;
  163.   
  164.     case "ODBC":
  165.     case "ODBC_Adabas":
  166.          $dbi=@odbc_close($id);
  167.          return $dbi;  
  168.     break;;
  169.  
  170.     case "Interbase":
  171.          $dbi=@ibase_close($id);
  172.          return $dbi;
  173.     break;;
  174.  
  175.     case "Sybase":
  176.         $dbi=@sybase_close($id);
  177.         return $dbi;
  178.     break;;
  179.  
  180.     default:
  181.     break;;
  182.     }
  183. }
  184.  
  185.  
  186. /*
  187.  * sql_query($query, $id)
  188.  * executes an SQL statement, returns a result identifier
  189.  */
  190.  
  191. function sql_query($query, $id)
  192. {
  193.  
  194. global $dbtype;
  195. global $sql_debug;
  196. $sql_debug = 0;
  197. if($sql_debug) echo "SQL query: ".str_replace(",",", ",$query)."<BR>";
  198. switch ($dbtype) {
  199.  
  200.     case "MySQL":
  201.         $res=@mysql_query($query, $id);
  202.         return $res;
  203.     break;;
  204.  
  205.     case "mSQL":
  206.         $res=@msql_query($query, $id);
  207.         return $res;
  208.     break;;
  209.  
  210.     case "PostgreSQL":
  211.     case "PostgreSQL_local":
  212.     $res=pg_exec($id,$query);
  213.     $result_set = new ResultSet;
  214.     $result_set->set_result( $res );
  215.     $result_set->set_total_rows( sql_num_rows( $result_set ) );
  216.     $result_set->set_fetched_rows( 0 );
  217.         return $result_set;
  218.     break;;
  219.  
  220.     case "ODBC":
  221.     case "ODBC_Adabas":
  222.         $res=@odbc_exec($id,$query);
  223.         return $res;
  224.     break;;
  225.  
  226.     case "Interbase":
  227.         $res=@ibase_query($id,$query);
  228.         return $res;
  229.     break;;
  230.  
  231.     case "Sybase":
  232.         $res=@sybase_query($query, $id);
  233.         return $res;
  234.     break;;
  235.  
  236.     default:
  237.     break;;
  238.  
  239.     }
  240. }
  241.  
  242. /*
  243.  * sql_num_rows($res)
  244.  * given a result identifier, returns the number of affected rows
  245.  */
  246.  
  247. function sql_num_rows($res)
  248. {
  249. global $dbtype;
  250. switch ($dbtype) {
  251.  
  252.     case "MySQL":
  253.         $rows=mysql_num_rows($res);
  254.         return $rows;
  255.     break;;
  256.  
  257.     case "mSQL":  
  258.         $rows=msql_num_rows($res);
  259.         return $rows;
  260.     break;;
  261.  
  262.     case "PostgreSQL":
  263.     case "PostgreSQL_local":
  264.         $rows=pg_numrows( $res->get_result() );
  265.         return $rows;
  266.     break;;
  267.         
  268.     case "ODBC":
  269.     case "ODBC_Adabas":
  270.         $rows=odbc_num_rows($res);
  271.         return $rows; 
  272.     break;;
  273.         
  274.     case "Interbase":
  275.     echo "<BR>Error! PHP dosen't support ibase_numrows!<BR>";
  276.         return $rows; 
  277.     break;;
  278.  
  279.     case "Sybase":
  280.         $rows=sybase_num_rows($res);
  281.         return $rows; 
  282.     break;;
  283.  
  284.     default:
  285.     break;;
  286.     }
  287. }
  288.  
  289. /*
  290.  * sql_fetch_row(&$res,$row)
  291.  * given a result identifier, returns an array with the resulting row
  292.  * Needs also a row number for compatibility with PostgreSQL
  293.  */
  294.  
  295. function sql_fetch_row(&$res, $nr=0)
  296. {
  297. global $dbtype;
  298. switch ($dbtype) {
  299.  
  300.     case "MySQL":
  301.         $row = mysql_fetch_row($res);
  302.         return $row;
  303.     break;;
  304.  
  305.     case "mSQL":
  306.         $row = msql_fetch_row($res);
  307.         return $row;
  308.     break;;
  309.  
  310.     case "PostgreSQL":
  311.     case "PostgreSQL_local":
  312.     if ( $res->get_total_rows() > $res->get_fetched_rows() ) {
  313.         $row = pg_fetch_row($res->get_result(), $res->get_fetched_rows() );
  314.         $res->increment_fetched_rows();
  315.         return $row;
  316.     } else {
  317.         return false;
  318.     }
  319.     break;;
  320.  
  321.     case "ODBC":
  322.     case "ODBC_Adabas":
  323.         $row = array();
  324.         $cols = odbc_fetch_into($res, $nr, $row);
  325.         return $row;
  326.     break;;
  327.  
  328.     case "Interbase":
  329.         $row = ibase_fetch_row($res);
  330.         return $row;
  331.     break;;
  332.  
  333.     case "Sybase":
  334.         $row = sybase_fetch_row($res);
  335.         return $row;
  336.     break;;
  337.  
  338.     default:
  339.     break;;
  340.     }
  341. }
  342.  
  343. /*
  344.  * sql_fetch_array($res,$row)
  345.  * given a result identifier, returns an associative array
  346.  * with the resulting row using field names as keys.
  347.  * Needs also a row number for compatibility with PostgreSQL.
  348.  */
  349.  
  350. function sql_fetch_array(&$res, $nr=0)
  351. {
  352. global $dbtype;
  353. switch ($dbtype)
  354.     {
  355.     case "MySQL":
  356.         $row = array();
  357.         $row = mysql_fetch_array($res);
  358.         return $row;
  359.     break;;
  360.  
  361.     case "mSQL":
  362.         $row = array();
  363.         $row = msql_fetch_array($res);
  364.         return $row;
  365.     break;;
  366.  
  367.     case "PostgreSQL":
  368.     case "PostgreSQL_local":
  369.     if( $res->get_total_rows() > $res->get_fetched_rows() ) {
  370.         $row = array();
  371.         $row = pg_fetch_array($res->get_result(), $res->get_fetched_rows() );
  372.         $res->increment_fetched_rows();
  373.         return $row;
  374.     } else {
  375.         return false;
  376.     }
  377.     break;;
  378.  
  379. /*
  380.  * ODBC doesn't have a native _fetch_array(), so we have to
  381.  * use a trick. Beware: this might cause HUGE loads!
  382.  */
  383.  
  384.     case "ODBC":
  385.         $row = array();
  386.         $result = array();
  387.         $result = odbc_fetch_row($res, $nr);
  388.     $nf = odbc_num_fields($res); /* Field numbering starts at 1 */
  389.         for($count=1; $count < $nf+1; $count++)
  390.     {
  391.             $field_name = odbc_field_name($res, $count);
  392.             $field_value = odbc_result($res, $field_name);
  393.             $row[$field_name] = $field_value;
  394.         }
  395.         return $row;
  396.     break;;
  397.  
  398.     case "ODBC_Adabas":
  399.         $row = array();
  400.         $result = array();
  401.         $result = odbc_fetch_row($res, $nr);
  402.  
  403.         $nf = count($result)+2; /* Field numbering starts at 1 */
  404.     for($count=1; $count < $nf; $count++) {
  405.         $field_name = odbc_field_name($res, $count);
  406.         $field_value = odbc_result($res, $field_name);
  407.         $row[$field_name] = $field_value;
  408.     }
  409.         return $row;
  410.     break;;
  411.  
  412.     case "Interbase":
  413.     $orow=ibase_fetch_object($res);
  414.     $row=get_object_vars($orow);
  415.         return $row;
  416.     break;;
  417.  
  418.     case "Sybase":
  419.         $row = sybase_fetch_array($res);
  420.         return $row;
  421.     break;;
  422.  
  423.     }
  424. }
  425.  
  426. function sql_fetch_object(&$res, $nr=0)
  427. {
  428. global $dbtype;
  429. switch ($dbtype)
  430.     {
  431.     case "MySQL":
  432.         $row = mysql_fetch_object($res);
  433.     if($row) return $row;
  434.     else return false;
  435.     break;;
  436.  
  437.     case "mSQL":
  438.         $row = msql_fetch_object($res);
  439.     if($row) return $row;
  440.     else return false;
  441.     break;;
  442.  
  443.     case "PostgreSQL":
  444.     case "PostgreSQL_local":
  445.     if( $res->get_total_rows() > $res->get_fetched_rows() ) {
  446.         $row = pg_fetch_object( $res->get_result(), $res->get_fetched_rows() );
  447.         $res->increment_fetched_rows();
  448.         if($row) return $row;
  449.         else return false;
  450.     } else {
  451.         return false;
  452.     }
  453.     break;;
  454.  
  455.     case "ODBC":
  456.         $result = odbc_fetch_row($res, $nr);
  457.     if(!$result) return false;
  458.     $nf = odbc_num_fields($res); /* Field numbering starts at 1 */
  459.         for($count=1; $count < $nf+1; $count++)
  460.     {
  461.             $field_name = odbc_field_name($res, $count);
  462.             $field_value = odbc_result($res, $field_name);
  463.             $row->$field_name = $field_value;
  464.         }
  465.         return $row;
  466.     break;;
  467.  
  468.     case "ODBC_Adabas":
  469.         $result = odbc_fetch_row($res, $nr);
  470.     if(!$result) return false;
  471.  
  472.         $nf = count($result)+2; /* Field numbering starts at 1 */
  473.     for($count=1; $count < $nf; $count++) {
  474.         $field_name = odbc_field_name($res, $count);
  475.         $field_value = odbc_result($res, $field_name);
  476.         $row->$field_name = $field_value;
  477.     }
  478.         return $row;
  479.     break;;
  480.  
  481.     case "Interbase":
  482.         $orow = ibase_fetch_object($res);
  483.     if($orow)
  484.     {
  485.         $arow=get_object_vars($orow);
  486.         while(list($name,$key)=each($arow))
  487.         {
  488.         $name=strtolower($name);
  489.         $row->$name=$key;
  490.         }
  491.             return $row;
  492.     }else return false;
  493.     break;;
  494.  
  495.     case "Sybase":
  496.         $row = sybase_fetch_object($res);
  497.         return $row;
  498.     break;;
  499.  
  500.     }
  501. }
  502.  
  503. /*** Function Free Result for function free the memory ***/
  504. function sql_free_result($res) {
  505. global $dbtype;
  506. switch ($dbtype) {
  507.  
  508.     case "MySQL":
  509.         $row = mysql_free_result($res);
  510.         return $row;
  511.     break;;
  512.  
  513.        case "mSQL":
  514.         $row = msql_free_result($res);
  515.         return $row;
  516.     break;;
  517.  
  518.  
  519.         case "PostgreSQL":
  520.     case "PostgreSQL_local":
  521.         $rows=pg_FreeResult( $res->get_result() );
  522.         return $rows;
  523.     break;;
  524.  
  525.     case "ODBC":
  526.     case "ODBC_Adabas":
  527.         $rows=odbc_free_result($res);
  528.         return $rows;
  529.     break;;
  530.  
  531.     case "Interbase":
  532.     echo "<BR>Error! PHP dosen't support ibase_numrows!<BR>";
  533.         return $rows;
  534.     break;;
  535.  
  536.     case "Sybase":
  537.         $rows=sybase_free_result($res);
  538.         return $rows;
  539.     break;;
  540.     }
  541. }
  542.  
  543. ?>