Source for file jDb.class.php

Documentation is available at jDb.class.php

  1. <?php
  2. /**
  3. @package     jelix
  4. @subpackage  db
  5. @author      Laurent Jouanneau
  6. @contributor Yannick Le Guédart, Laurent Raufaste, Julien Issler
  7. @copyright   2005-2011 Laurent Jouanneau
  8. @copyright   2011 Julien Issler
  9. *
  10. *  API ideas of this class were get originally from the Copix project (CopixDbFactory, Copix 2.3dev20050901, http://www.copix.org)
  11. *  No lines of code are copyrighted by CopixTeam
  12. *
  13. @link      http://www.jelix.org
  14. @licence  http://www.gnu.org/licenses/lgpl.html GNU Lesser General Public Licence, see LICENCE file
  15. */
  16.  
  17. /**
  18.  *
  19.  */
  20. require(JELIX_LIB_PATH.'db/jDbConnection.class.php');
  21. require(JELIX_LIB_PATH.'db/jDbResultSet.class.php');
  22.  
  23. /**
  24.  * class that handles a sql query for a logger
  25.  */
  26. class jSQLLogMessage extends jLogMessage {
  27.  
  28.     protected $startTime = 0;
  29.     protected $endTime = 0;
  30.     protected $trace = array();
  31.     public $originalQuery = '';
  32.  
  33.     public function __construct($message{
  34.         $this->category = 'sql';
  35.         $this->message = $message;
  36.         $this->startTime = microtime(true);
  37.  
  38.         $this->trace = debug_backtrace();
  39.         array_shift($this->trace)// remove the current __construct call
  40.     }
  41.  
  42.     public function setRealQuery($sql{
  43.         $this->originalQuery = $this->message;
  44.         $this->message = $sql;
  45.     }
  46.  
  47.     public function endQuery({
  48.         $this->endTime = microtime(true);
  49.     }
  50.  
  51.     public function getTrace({
  52.         return $this->trace;
  53.     }
  54.  
  55.     public function getTime({
  56.         return $this->endTime - $this->startTime;
  57.     }
  58.  
  59.     public function getDao({
  60.         foreach ($this->trace as $t{
  61.             if (isset($t['class'])) {
  62.                 $dao '';
  63.                 $class $t['class'];
  64.                 if ($class == 'jDaoFactoryBase'{
  65.                     if (isset($t['object'])) {
  66.                         $class get_class($t['object']);
  67.                     }
  68.                     else {
  69.                         $class 'jDaoFactoryBase';
  70.                         $dao 'unknow dao, jDaoFactoryBase';
  71.                     }
  72.                 }
  73.                 if(preg_match('/^cDao_(.+)_Jx_(.+)_Jx_(.+)$/'$class$m)) {
  74.                     $dao $m[1].'~'.$m[2];
  75.                 }
  76.                 if ($dao && isset($t['function'])) {
  77.                     $dao.= '::'.$t['function'].'()';
  78.                 }
  79.                 if($dao)
  80.                     return $dao;
  81.             }
  82.         }
  83.         return '';
  84.     }
  85.  
  86.     public function getFormatedMessage({
  87.         $message $this->message."\n".$this->getTime().'ms';
  88.         $dao $this->getDao();
  89.         if ($dao)
  90.             $message.=', from dao:'.$dao."\n";
  91.         if ($this->message != $this->originalQuery)
  92.             $message.= 'Original query: '.$this->originalQuery."\n";
  93.  
  94.         $traceLog="";
  95.         foreach($this->trace as $k=>$t){
  96.             $traceLog.="\n\t$k\t".(isset($t['class'])?$t['class'].$t['type']:'').$t['function']."()\t";
  97.             $traceLog.=(isset($t['file'])?$t['file']:'[php]').' : '.(isset($t['line'])?$t['line']:'');
  98.         }
  99.  
  100.         return $message.$traceLog;
  101.     }
  102. }
  103.  
  104.  
  105. /**
  106.  * factory for database connector and other db utilities
  107.  * @package  jelix
  108.  * @subpackage db
  109.  */
  110. class jDb {
  111.  
  112.     /**
  113.     * return a database connector. It uses a temporay pool of connection to reuse
  114.     * currently opened connections.
  115.     *
  116.     * @param string  $name  profile name to use. if empty, use the default one
  117.     * @return jDbConnection  the connector
  118.     */
  119.     public static function getConnection ($name ''{
  120.         return jProfiles::getOrStoreInPool('jdb'$namearray('jDb''_createConnector'));
  121.     }
  122.  
  123.     /**
  124.      * create a new jDbWidget
  125.      * @param string  $name  profile name to use. if empty, use the default one
  126.      * @return jDbWidget 
  127.      */
  128.     public static function getDbWidget ($name null{
  129.         $dbw new jDbWidget(self::getConnection($name));
  130.         return $dbw;
  131.     }
  132.  
  133.     /**
  134.     * instancy a jDbTools object. Use jDbConnection::tools() instead.
  135.     * @param string $name profile name to use. if empty, use the default one
  136.     * @return jDbTools 
  137.     * @deprecated since 1.2
  138.     */
  139.     public static function getTools ($name null{
  140.         $cnx self::getConnection ($name);
  141.         return $cnx->tools();
  142.     }
  143.  
  144.     /**
  145.     * load properties of a connector profile
  146.     *
  147.     * a profile is a section in the profiles.ini.php file
  148.     *
  149.     * the given name can be a profile name (it should correspond to a section name
  150.     * in the ini file), or an alias of a profile. An alias is a parameter name
  151.     * in the global section of the ini file, and the value of this parameter
  152.     * should be a profile name.
  153.     *
  154.     * @param string   $name  profile name or alias of a profile name. if empty, use the default profile
  155.     * @param boolean  $noDefault  if true and if the profile doesn't exist, throw an error instead of getting the default profile
  156.     * @return array  properties
  157.     * @deprecated use jProfiles::get instead
  158.     */
  159.     public static function getProfile ($name=''$noDefault false{
  160.         return jProfiles::get('jdb'$name$noDefault);
  161.     }
  162.  
  163.     /**
  164.      * call it to test a profile (during an install for example)
  165.      * @param array  $profile  profile properties
  166.      * @return boolean  true if properties are ok
  167.      */
  168.     public function testProfile ($profile{
  169.         try {
  170.             self::_createConnector ($profile);
  171.             $ok true;
  172.         }
  173.         catch(Exception $e{
  174.             $ok false;
  175.         }
  176.         return $ok;
  177.     }
  178.  
  179.     /**
  180.     * create a connector. internal use (callback method for jProfiles)
  181.     * @param array  $profile  profile properties
  182.     * @return jDbConnection|jDbPDOConnection database connector
  183.     */
  184.     public static function _createConnector ($profile{
  185.         if ($profile['driver'== 'pdo' || (isset($profile['usepdo']&& $profile['usepdo'])) {
  186.             $dbh new jDbPDOConnection($profile);
  187.             return $dbh;
  188.         }
  189.         else {
  190.             $dbh jApp::loadPlugin($profile['driver']'db''.dbconnection.php'$profile['driver'].'DbConnection'$profile);
  191.             if (is_null($dbh))
  192.                 throw new jException('jelix~db.error.driver.notfound'$profile['driver']);
  193.             return $dbh;
  194.         }
  195.     }
  196.  
  197.     /**
  198.      * create a temporary new profile
  199.      * @param string $name the name of the profile
  200.      * @param array|string$params parameters of the profile. key=parameter name, value=parameter value.
  201.      *                       same kind of parameters we found in profiles.ini.php
  202.      *                       we can also indicate a name of an other profile, to create an alias
  203.      * @deprecated since 1.3, use jProfiles::createVirtualProfile instead
  204.      */
  205.     public static function createVirtualProfile ($name$params{
  206.         jProfiles::createVirtualProfile('jdb',$name$params);
  207.     }
  208.  
  209.     /**
  210.      * clear the loaded profiles to force to reload the db profiles file.
  211.      * WARNING: it closes all opened connections !
  212.      * @since 1.2
  213.      * @deprecated since 1.3, use jProfiles::clear instead
  214.      */
  215.     public static function clearProfiles({
  216.         jProfiles::clear();
  217.     }
  218.  
  219.     /**
  220.      * perform a convertion float to str. It takes care about the decimal separator
  221.      * which should be a '.' for SQL. Because when doing a native convertion float->str,
  222.      * PHP uses the local decimal separator, and so, we don't want that.
  223.      * @since 1.1.11
  224.      */
  225.     public static function floatToStr($value{
  226.         if (is_float($value)) // this is a float
  227.             return rtrim(sprintf('%.20F'$value)'0')// %F to not format with the local decimal separator
  228.         else if (is_integer($value))
  229.             return sprintf('%d'$value);
  230.         // this is probably a string, so we expect that it contains a numerical value
  231.         // is_numeric is true if the separator is ok for SQL
  232.         // (is_numeric doesn't accept thousand separators nor other character than '.' as decimal separator)
  233.         else if (is_numeric($value))
  234.             return $value;
  235.  
  236.         // we probably have a malformed float number here
  237.         // if so, floatval will ignore all character after an invalid character (a ',' for example)
  238.         // no warning, no exception here, to keep the same behavior of previous Jelix version
  239.         // in order to no break stable applications.
  240.         // FIXME: do a warning in next versions (> 1.2)
  241.         return (string)(floatval($value));
  242.     }
  243. }

Documentation generated on Wed, 24 Sep 2014 21:58:25 +0200 by phpDocumentor 1.4.3