home *** CD-ROM | disk | FTP | other *** search
/ H4CK3R 4 / hacker04 / 04_HACK04.ISO / src / PHP / sqlhelp.php3.txt < prev    next >
Encoding:
Text File  |  2002-05-06  |  7.8 KB  |  289 lines
  1. SQL helper functions 
  2.  
  3. A set of functions sitting on top of the abstraction layer that makes it a little easier to do SQL stuff. Documentation is within. 
  4.  
  5.  
  6. <?php  /* -*- C++ -*- */ 
  7. /* 
  8.  * $Id: sql.phl,v 1.5 1998/07/02 09:52:13 ssb Exp $ 
  9.  */ 
  10.  
  11. /* 
  12.  * ABOUT: 
  13.  * 
  14.  * Lazy PHP programmer series: SQL helper functions. 
  15.  * Written by Stig Bakken <ssb@guardian.no> 
  16.  * 
  17.  * CONFIGURATION: 
  18.  * 
  19.  * You must set some global variables prior to including this library: 
  20.  * $db_type          which database abstraction layer to use. 
  21.  *                   If your layer is defined in "db-odbc.phl", 
  22.  *                   set this variable to "odbc". 
  23.  * $db_dsn           Which database to connect to (dsn=data source name) 
  24.  * $db_user          Which user to connect as 
  25.  * $db_pass          Password used when connecting 
  26.  * 
  27.  * Some optional global variables can be set: 
  28.  * $sql_debug        true/false, toggles debug information 
  29.  * $sql_log_facility how to log debug information 
  30.  * $sql_log_dest     debug information destination 
  31.  * 
  32.  * $sql_log_facility and $sql_log_dest are passed as the second 
  33.  * and third args to PHP's error_log() function, respectively. 
  34.  * The default is debugging through the PHP TCP debugger to 
  35.  * port 1400 on localhost.  Debug information is also disabled 
  36.  * by default. 
  37.  * 
  38.  * The following global variables will be defined: 
  39.  * $db_connection  The opened connection. 
  40.  * 
  41.  * 
  42.  * USAGE: 
  43.  * 
  44.  * All you have to do is require("sql.phl"), either explicitly in the 
  45.  * pages where you want to use it, or through auto_prepend_file somehow. 
  46.  * Being a lazy programmer, I always include everything I need with 
  47.  * auto-prepend from a file I call "config.phl" looking something like 
  48.  * this: 
  49.  * 
  50.  * <?php 
  51.  * $db_type = "odbc"; 
  52.  * $db_user = "myuser"; 
  53.  * $db_pass = "mypassword"; 
  54.  * $db_dsn = "SVT=Solid; DSN=MyDB" 
  55.  * require("sql.phl"); 
  56.  * ?> 
  57.  * 
  58.  * Once you have included this file, a database connection will 
  59.  * be opened for you once it is needed, and this connection will 
  60.  * be used for all queries.  Memory is freed automatically for 
  61.  * all functions except sql(). 
  62.  * 
  63.  * Example use of all functions:  
  64.  * 
  65.  * // returns a result identifier 
  66.  * $res = sql("SELECT * FROM table"); 
  67.  * 
  68.  * // returns one column: 
  69.  * $name = sql_one("SELECT name FROM table WHERE id = $id"); 
  70.  * 
  71.  * // returns one row in an array 
  72.  * $row = sql_onerow("SELECT * FROM table WHERE id = $id"); 
  73.  * 
  74.  * // returns an array of arrays with all the result data 
  75.  * $data = sql_all("SELECT * FROM table"); 
  76.  * 
  77.  * // returns an array with data from column 0 only: 
  78.  * $names = sql_col("SELECT name FROM table", 0); 
  79.  * 
  80.  * // returns an associative array with the first column as the 
  81.  * // key and the second column as the value: 
  82.  * $name_by_id = sql_assoc("SELECT id, name FROM table"); 
  83.  * 
  84.  * // enable auto-commit 
  85.  * sql_autocommit(true); 
  86.  * 
  87.  * // disable auto-commit 
  88.  * sql_autocommit(false); 
  89.  * 
  90.  * // commit transaction 
  91.  * sql_commit(); 
  92.  * 
  93.  * // roll back transaction 
  94.  * sql_rollback(); 
  95.  * 
  96.  */ 
  97.  
  98. require( "db-$db_type.phl"); 
  99.  
  100. $db_connection = 0; 
  101.  
  102. /* debugging defaults */ 
  103. if (empty($sql_debug)) { 
  104.     $sql_debug = false; 
  105. } 
  106. if (empty($sql_log_facility)) { 
  107.     $sql_log_facility = 2;  /* debug through TCP */ 
  108. } 
  109. if (empty($sql_log_dest)) { 
  110.     $sql_log_dest =  "127.0.0.1:1400";  /* destination */ 
  111. } 
  112.  
  113. /* 
  114.  * Function: sql_debug 
  115.  * Description: sends debug information somewhere if 
  116.  * the global variable $sql_debug is true. 
  117.  */ 
  118. function sql_debug($message) { 
  119.     global $sql_debug, $sql_log_facility, $sql_log_dest; 
  120.     if ($sql_debug) { 
  121.     error_log( "[SQL] $message", $sql_log_facility, $sql_log_dest); 
  122.     } 
  123. } 
  124.  
  125. /* 
  126.  * Function: assert_db_connection 
  127.  * Description: makes sure we have a database connection 
  128.  */ 
  129. function assert_db_connection() 
  130. { 
  131.     global $db_connection; 
  132.     if ($db_connection) { 
  133.     return; 
  134.     } 
  135.     global $db_dsn, $db_user, $db_pass; 
  136.     $db_connection = db_connect($db_dsn, $db_user, $db_pass); 
  137.     if (!$db_connection) { 
  138.     die( "Failed to connect to database."); 
  139.     } 
  140. } 
  141.  
  142. /* 
  143.  * Function: sql 
  144.  * Arguments: $query (string)   - SQL statement 
  145.  * Description: executes an SQL statement 
  146.  * Returns: (int) result identifier 
  147.  *          returns 0 upon error 
  148.  */ 
  149. function sql($query) { 
  150.     global $db_connection, $PHP_SELF; 
  151.     assert_db_connection(); 
  152.     sql_debug($query); 
  153.     return db_query($db_connection, $query); 
  154. } 
  155.  
  156. /* 
  157.  * Function: sql_onerow 
  158.  * Arguments: $query (string)   - SQL statement 
  159.  * Description: executes an SQL statement and returns the first 
  160.  *              row of the result 
  161.  * Returns: (array) the first row 
  162.  *          returns 0 upon error 
  163.  */ 
  164. function sql_onerow($query) { 
  165.     $res = sql($query); 
  166.     $row = db_fetch_row($res); 
  167.     db_free_result($res); 
  168.     return $row; 
  169. } 
  170.  
  171. /* 
  172.  * Function: sql_one 
  173.  * Arguments: $query (string)   - SQL statement 
  174.  * Description: executes an SQL statement and returns the first 
  175.  *              column of the first row of the result 
  176.  * Returns: (mixed) the first column of the first row 
  177.  *          returns false upon error 
  178.  */ 
  179. function sql_one($query) { 
  180.     $row = sql_onerow($query); 
  181.     if (gettype($row) ==  "array") { 
  182.     return $row[0]; 
  183.     } else { 
  184.     return false; 
  185.     } 
  186. } 
  187.  
  188. /* 
  189.  * Function: sql_all 
  190.  * Arguments: $query (string)   - SQL statement 
  191.  * Description: executes an SQL statement and returns an array 
  192.  *              of arrays with the rows and columns of all the 
  193.  *              result data from the query. 
  194.  * Returns: array of arrays or false on error 
  195.  */ 
  196. function sql_all($query) { 
  197.     $res = sql($query); 
  198.     if ($res) { 
  199.     $all = array(); 
  200.     while ($row = db_fetch_row($res)) { 
  201.         $all[] = $row; 
  202.     } 
  203.     db_free_result($res); 
  204.     return $all; 
  205.     } 
  206.     return false; 
  207. } 
  208.  
  209.  
  210. /* 
  211.  * Function: sql_col 
  212.  * Arguments: $query (string)   - SQL statement 
  213.  *            $column (int)     - returned result column number 
  214.  * Description: executes an SQL statement and returns an array 
  215.  *              with the results from a specific column in the result. 
  216.  * Returns: array or false on error 
  217.  */ 
  218. function sql_col($query, $column) { 
  219.     $res = sql($query); 
  220.     if ($res) { 
  221.     $all = array(); 
  222.     while ($row = db_fetch_row($res)) { 
  223.         $all[] = $row[$column]; 
  224.     } 
  225.     db_free_result($res); 
  226.     return $all; 
  227.     } 
  228.     return false; 
  229. } 
  230.  
  231.  
  232. /* 
  233.  * Function: sql_assoc 
  234.  * Arguments: $query (string)   - SQL statement 
  235.  * Description: executes an SQL statement and returns an associative 
  236.  *              array.  The indices of this array are taken from the 
  237.  *              first column of the result, while the values are taken 
  238.  *              from the second column.  If there are more than two 
  239.  *              columns the remaining ones are ignored. 
  240.  * Returns: associative array or false on error 
  241.  */ 
  242. function sql_assoc($query) { 
  243.     $res = sql($query); 
  244.     if ($res) { 
  245.     $row = db_fetch_row($res); 
  246.     if (!is_array($row) || count($row) < 2) { 
  247.         db_free_result($res); 
  248.         return false; 
  249.     } 
  250.     while ($row) { 
  251.         $assoc[$row[0]] = $row[1]; 
  252.         $row = db_fetch_row($res); 
  253.     } 
  254.     db_free_result($res); 
  255.     return $assoc; 
  256.     } 
  257.     return false; 
  258. } 
  259.  
  260.  
  261. function sql_autocommit($enabled) 
  262. { 
  263.     global $db_connection; 
  264.     if (!$enabled) { 
  265.     sql_debug( "transaction starting"); 
  266.     } 
  267.     return db_autocommit($db_connection, $enabled); 
  268. } 
  269.  
  270.  
  271. function sql_commit() 
  272. { 
  273.     global $db_connection; 
  274.     sql_debug( "transaction complete"); 
  275.     return db_commit($db_connection); 
  276. } 
  277.  
  278.  
  279. function sql_rollback() 
  280. { 
  281.     global $db_connection; 
  282.     sql_debug( "transaction aborted"); 
  283.     return db_rollback($db_connection); 
  284. } 
  285.  
  286.  
  287. ?> 
  288.  
  289.