home *** CD-ROM | disk | FTP | other *** search
/ Chip 2004 April / CMCD0404.ISO / Software / Freeware / Programare / dotproject / includes / db_connect.php < prev    next >
PHP Script  |  2004-01-28  |  9KB  |  383 lines
  1. <?php /* INCLUDES $Id: db_connect.php,v 1.26 2004/01/28 06:27:16 ajdonnison Exp $ */
  2. /**
  3. * Generic functions based on library function (that is, non-db specific)
  4. *
  5. * @todo Encapsulate into a database object
  6. */
  7.  
  8. // load the db specific handlers
  9. require_once( "{$AppUI->cfg['root_dir']}/includes/db_{$AppUI->cfg['dbtype']}.php" );
  10.  
  11. // make the connection to the db
  12. db_connect( $AppUI->cfg['dbhost'], $AppUI->cfg['dbname'],
  13.     $AppUI->cfg['dbuser'], $AppUI->cfg['dbpass'], $AppUI->cfg['dbport'], $AppUI->cfg['dbpersist'] );
  14.  
  15. /**
  16. * This global function loads the first field of the first row returned by the query.
  17. *
  18. * @param string The SQL query
  19. * @return The value returned in the query or null if the query failed.
  20. */
  21. function db_loadResult( $sql ) {
  22.     $cur = db_exec( $sql );
  23.     $cur or exit( db_error() );
  24.     $ret = null;
  25.     if ($row = db_fetch_row( $cur )) {
  26.         $ret = $row[0];
  27.     }
  28.     db_free_result( $cur );
  29.     return $ret;
  30. }
  31.  
  32. /**
  33. * This global function loads the first row of a query into an object
  34. *
  35. * If an object is passed to this function, the returned row is bound to the existing elements of <var>object</var>.
  36. * If <var>object</var> has a value of null, then all of the returned query fields returned in the object. 
  37. * @param string The SQL query
  38. * @param object The address of variable
  39. */
  40. function db_loadObject( $sql, &$object, $bindAll=false , $strip = true) {
  41.     if ($object != null) {
  42.         $hash = array();
  43.         if( !db_loadHash( $sql, $hash ) ) {
  44.             return false;
  45.         }
  46.         bindHashToObject( $hash, $object, null, $strip, $bindAll );
  47.         return true;
  48.     } else {
  49.         $cur = db_exec( $sql );
  50.         $cur or exit( db_error() );
  51.         if ($object = db_fetch_object( $cur )) {
  52.             db_free_result( $cur );
  53.             return true;
  54.         } else {
  55.             $object = null;
  56.             return false;
  57.         }
  58.     }
  59. }
  60.  
  61. /**
  62. * This global function return a result row as an associative array 
  63. *
  64. * @param string The SQL query
  65. * @param array An array for the result to be return in
  66. * @return <b>True</b> is the query was successful, <b>False</b> otherwise
  67. */
  68. function db_loadHash( $sql, &$hash ) {
  69.     $cur = db_exec( $sql );
  70.     $cur or exit( db_error() );
  71.     $hash = db_fetch_assoc( $cur );
  72.     db_free_result( $cur );
  73.     if ($hash == false) {
  74.         return false;
  75.     } else {
  76.         return true;
  77.     }
  78. }
  79.  
  80. /**
  81. * Document::db_loadHashList()
  82. *
  83. * { Description }
  84. *
  85. * @param string $index
  86. */
  87. function db_loadHashList( $sql, $index='' ) {
  88.     $cur = db_exec( $sql );
  89.     $cur or exit( db_error() );
  90.     $hashlist = array();
  91.     while ($hash = db_fetch_array( $cur )) {
  92.         $hashlist[$hash[$index ? $index : 0]] = $index ? $hash : $hash[1];
  93.     }
  94.     db_free_result( $cur );
  95.     return $hashlist;
  96. }
  97.  
  98. /**
  99. * Document::db_loadList()
  100. *
  101. * { Description }
  102. *
  103. * @param [type] $maxrows
  104. */
  105. function db_loadList( $sql, $maxrows=NULL ) {
  106.     GLOBAL $AppUI;
  107.     if (!($cur = db_exec( $sql ))) {;
  108.         $AppUI->setMsg( db_error(), UI_MSG_ERROR );
  109.         return false;
  110.     }
  111.     $list = array();
  112.     $cnt = 0;
  113.     while ($hash = db_fetch_assoc( $cur )) {
  114.         $list[] = $hash;
  115.         if( $maxrows && $maxrows == $cnt++ ) {
  116.             break;
  117.         }
  118.     }
  119.     db_free_result( $cur );
  120.     return $list;
  121. }
  122.  
  123. /**
  124. * Document::db_loadColumn()
  125. *
  126. * { Description }
  127. *
  128. * @param [type] $maxrows
  129. */
  130. function db_loadColumn( $sql, $maxrows=NULL ) {
  131.     GLOBAL $AppUI;
  132.     if (!($cur = db_exec( $sql ))) {;
  133.         $AppUI->setMsg( db_error(), UI_MSG_ERROR );
  134.         return false;
  135.     }
  136.     $list = array();
  137.     $cnt = 0;
  138.     while ($row = db_fetch_row( $cur )) {
  139.         $list[] = $row[0];
  140.         if( $maxrows && $maxrows == $cnt++ ) {
  141.             break;
  142.         }
  143.     }
  144.     db_free_result( $cur );
  145.     return $list;
  146. }
  147.  
  148. /* return an array of objects from a SQL SELECT query
  149.  * class must implement the Load() factory, see examples in Webo classes
  150.  * @note to optimize request, only select object oids in $sql
  151.  */
  152. function db_loadObjectList( $sql, $object, $maxrows = NULL ) {
  153.     $cur = db_exec( $sql );
  154.     if (!$cur) {
  155.         die( "db_loadObjectList : " . db_error() );
  156.     }
  157.     $list = array();
  158.     $cnt = 0;
  159.     while ($row = db_fetch_array( $cur )) {
  160.         $object->load( $row[0] );
  161.         $list[] = $object;
  162.         if( $maxrows && $maxrows == $cnt++ ) {
  163.             break;
  164.         }
  165.     }
  166.     db_free_result( $cur );
  167.     return $list;
  168. }
  169.  
  170.  
  171. /**
  172. * Document::db_insertArray()
  173. *
  174. * { Description }
  175. *
  176. * @param [type] $verbose
  177. */
  178. function db_insertArray( $table, &$hash, $verbose=false ) {
  179.     $fmtsql = "insert into $table ( %s ) values( %s ) ";
  180.     foreach ($hash as $k => $v) {
  181.         if (is_array($v) or is_object($v) or $v == NULL) {
  182.             continue;
  183.         }
  184.         $fields[] = $k;
  185.         $values[] = "'" . db_escape( $v ) . "'";
  186.     }
  187.     $sql = sprintf( $fmtsql, implode( ",", $fields ) ,  implode( ",", $values ) );
  188.  
  189.     ($verbose) && print "$sql<br />\n";
  190.  
  191.     if (!db_exec( $sql )) {
  192.         return false;
  193.     }
  194.     $id = db_insert_id();
  195.     return true;
  196. }
  197.  
  198. /**
  199. * Document::db_updateArray()
  200. *
  201. * { Description }
  202. *
  203. * @param [type] $verbose
  204. */
  205. function db_updateArray( $table, &$hash, $keyName, $verbose=false ) {
  206.     $fmtsql = "UPDATE $table SET %s WHERE %s";
  207.     foreach ($hash as $k => $v) {
  208.         if( is_array($v) or is_object($v) or $k[0] == '_' ) // internal or NA field
  209.             continue;
  210.  
  211.         if( $k == $keyName ) { // PK not to be updated
  212.             $where = "$keyName='" . db_escape( $v ) . "'";
  213.             continue;
  214.         }
  215.         if ($v == '') {
  216.             $val = 'NULL';
  217.         } else {
  218.             $val = "'" . db_escape( $v ) . "'";
  219.         }
  220.         $tmp[] = "$k=$val";
  221.     }
  222.     $sql = sprintf( $fmtsql, implode( ",", $tmp ) , $where );
  223.     ($verbose) && print "$sql<br />\n";
  224.     $ret = db_exec( $sql );
  225.     return $ret;
  226. }
  227.  
  228. /**
  229. * Document::db_delete()
  230. *
  231. * { Description }
  232. *
  233. */
  234. function db_delete( $table, $keyName, $keyValue ) {
  235.     $keyName = db_escape( $keyName );
  236.     $keyValue = db_escape( $keyValue );
  237.     $ret = db_exec( "DELETE FROM $table WHERE $keyName='$keyValue'" );
  238.     return $ret;
  239. }
  240.  
  241.  
  242. /**
  243. * Document::db_insertObject()
  244. *
  245. * { Description }
  246. *
  247. * @param [type] $keyName
  248. * @param [type] $verbose
  249. */
  250. function db_insertObject( $table, &$object, $keyName = NULL, $verbose=false ) {
  251.     $fmtsql = "INSERT INTO $table ( %s ) VALUES ( %s ) ";
  252.     foreach (get_object_vars( $object ) as $k => $v) {
  253.         if (is_array($v) or is_object($v) or $v == NULL) {
  254.             continue;
  255.         }
  256.         if ($k[0] == '_') { // internal field
  257.             continue;
  258.         }
  259.         $fields[] = $k;
  260.         $values[] = "'" . db_escape( $v ) . "'";
  261.     }
  262.     $sql = sprintf( $fmtsql, implode( ",", $fields ) ,  implode( ",", $values ) );
  263.     ($verbose) && print "$sql<br />\n";
  264.     if (!db_exec( $sql )) {
  265.         return false;
  266.     }
  267.     $id = db_insert_id();
  268.     ($verbose) && print "id=[$id]<br />\n";
  269.     if ($keyName && $id)
  270.         $object->$keyName = $id;
  271.     return true;
  272. }
  273.  
  274. /**
  275. * Document::db_updateObject()
  276. *
  277. * { Description }
  278. *
  279. * @param [type] $updateNulls
  280. */
  281. function db_updateObject( $table, &$object, $keyName, $updateNulls=true ) {
  282.     $fmtsql = "UPDATE $table SET %s WHERE %s";
  283.     foreach (get_object_vars( $object ) as $k => $v) {
  284.         if( is_array($v) or is_object($v) or $k[0] == '_' ) { // internal or NA field
  285.             continue;
  286.         }
  287.         if( $k == $keyName ) { // PK not to be updated
  288.             $where = "$keyName='" . db_escape( $v ) . "'";
  289.             continue;
  290.         }
  291.         if ($v === NULL && !$updateNulls) {
  292.             continue;
  293.         }
  294.         if( $v == '' ) {
  295.             $val = "''";
  296.         } else {
  297.             $val = "'" . db_escape( $v ) . "'";
  298.         }
  299.         $tmp[] = "$k=$val";
  300.     }
  301.     $sql = sprintf( $fmtsql, implode( ",", $tmp ) , $where );
  302.     return db_exec( $sql );
  303. }
  304.  
  305. /**
  306. * Document::db_dateConvert()
  307. *
  308. * { Description }
  309. *
  310. */
  311. function db_dateConvert( $src, &$dest, $srcFmt ) {
  312.     $result = strtotime( $src );
  313.     $dest = $result;
  314.     return ( $result != 0 );
  315. }
  316.  
  317. /**
  318. * Document::db_datetime()
  319. *
  320. * { Description }
  321. *
  322. * @param [type] $timestamp
  323. */
  324. function db_datetime( $timestamp = NULL ) {
  325.     if (!$timestamp) {
  326.         return NULL;
  327.     }
  328.     if (is_object($timestamp)) {
  329.         return $timestamp->toString( '%Y-%m-%d %H:%M:%S');
  330.     } else {
  331.         return strftime( '%Y-%m-%d %H:%M:%S', $timestamp );
  332.     }
  333. }
  334.  
  335. /**
  336. * Document::db_dateTime2locale()
  337. *
  338. * { Description }
  339. *
  340. */
  341. function db_dateTime2locale( $dateTime, $format ) {
  342.     if (intval( $dateTime)) {
  343.         $date = new CDate( $dateTime );
  344.         return $date->format( $format );
  345.     } else {
  346.         return null;
  347.     }
  348. }
  349.  
  350. /*
  351. * copy the hash array content into the object as properties
  352. * only existing properties of object are filled. when undefined in hash, properties wont be deleted
  353. * @param array the input array
  354. * @param obj byref the object to fill of any class
  355. * @param string
  356. * @param boolean
  357. * @param boolean
  358. */
  359. function bindHashToObject( $hash, &$obj, $prefix=NULL, $checkSlashes=true, $bindAll=false ) {
  360.     is_array( $hash ) or die( "bindHashToObject : hash expected" );
  361.     is_object( $obj ) or die( "bindHashToObject : object expected" );
  362.  
  363.     if ($bindAll) {
  364.         foreach ($hash as $k => $v) {
  365.             $obj->$k = ($checkSlashes && get_magic_quotes_gpc()) ? stripslashes( $hash[$k] ) : $hash[$k];
  366.         }
  367.     } else if ($prefix) {
  368.         foreach (get_object_vars($obj) as $k => $v) {
  369.             if (isset($hash[$prefix . $k ])) {
  370.                 $obj->$k = ($checkSlashes && get_magic_quotes_gpc()) ? stripslashes( $hash[$k] ) : $hash[$k];
  371.             }
  372.         }
  373.     } else {
  374.         foreach (get_object_vars($obj) as $k => $v) {
  375.             if (isset($hash[$k])) {
  376.                 $obj->$k = ($checkSlashes && get_magic_quotes_gpc()) ? stripslashes( $hash[$k] ) : $hash[$k];
  377.             }
  378.         }
  379.     }
  380.     //echo "obj="; print_r($obj); exit;
  381. }
  382. ?>
  383.