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

Documentation generated on Wed, 04 Jan 2017 22:53:40 +0100 by phpDocumentor 1.4.3