Source for file jDbConnection.class.php

Documentation is available at jDbConnection.class.php

  1. <?php
  2. /**
  3. @package     jelix
  4. @subpackage  db
  5. @author      Laurent Jouanneau, Gerald Croes
  6. @contributor Julien Issler
  7. @copyright   2005-2012 Laurent Jouanneau
  8. @copyright   2007-2009 Julien Issler
  9. @copyright 2001-2005 CopixTeam
  10. *  This class was get originally from the Copix project (CopixDbConnection, Copix 2.3dev20050901, http://www.copix.org)
  11. *  However only few lines of code are still copyrighted 2001-2005 CopixTeam (LGPL licence).
  12. *  Initial authors of this Copix classes are Gerald Croes and Laurent Jouanneau,
  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.  * @package  jelix
  20.  * @subpackage db
  21.  */
  22. abstract class jDbConnection {
  23.  
  24.     const FETCH_OBJ 5;
  25.     const FETCH_CLASS 8;
  26.     const FETCH_INTO 9;
  27.     const ATTR_AUTOCOMMIT 0;
  28.     const ATTR_PREFETCH 1;
  29.     const ATTR_TIMEOUT 2;
  30.     const ATTR_ERRMODE 3;
  31.     const ATTR_SERVER_VERSION 4;
  32.     const ATTR_SERVER_INFO 6;
  33.     const ATTR_CLIENT_VERSION 5;
  34.     const ATTR_CONNECTION_STATUS 7;
  35.     const ATTR_CASE 8;
  36.     const ATTR_CURSOR 10;
  37.     const ATTR_ORACLE_NULLS 11;
  38.     const ATTR_PERSISTENT 12;
  39.     const ATTR_DRIVER_NAME 16;
  40.     const CURSOR_FWDONLY 0;
  41.     const CURSOR_SCROLL 1;
  42.  
  43.     /**
  44.     * profile properties used by the connector
  45.     * @var array 
  46.     */
  47.     public $profile;
  48.  
  49.     /**
  50.      * The database type name (mysql, pgsql ...)
  51.      * It is not the driver name. Several drivers could connect to the same database
  52.      * type. This type name is often used to know whish SQL language we should use.
  53.      * @var string 
  54.      */
  55.     public $dbms;
  56.  
  57.     /**
  58.      * driver name
  59.      * @var string 
  60.      */
  61.     public $driverName = '';
  62.  
  63.     /**
  64.     * The last error message if any
  65.     * @var string 
  66.     */
  67.     public $msgError = '';
  68.  
  69.     /**
  70.      * last executed query
  71.      */
  72.     public $lastQuery;
  73.  
  74.     /**
  75.     * Are we using an automatic commit ?
  76.     * @var boolean 
  77.     */
  78.     private $_autocommit true;
  79.  
  80.     /**
  81.     * the internal connection.
  82.     */
  83.     protected $_connection = null;
  84.  
  85.     protected $_debugMode = false;
  86.     /**
  87.     * do a connection to the database, using properties of the given profile
  88.     * @param array $profile  profile properties
  89.     */
  90.     function __construct($profile{
  91.         $this->profile = $profile;
  92.         $this->dbms = $this->driverName = $profile['driver'];
  93.         $this->_connection = $this->_connect();
  94.         $this->_debugMode = true;
  95.     }
  96.  
  97.     function __destruct({
  98.         if ($this->_connection !== null{
  99.             $this->_disconnect ();
  100.         }
  101.     }
  102.  
  103.     /**
  104.     * Launch a SQL Query which returns rows (typically, a SELECT statement)
  105.     * @param string   $queryString   the SQL query
  106.     * @param integer  $fetchmode   FETCH_OBJ, FETCH_CLASS or FETCH_INTO
  107.     * @param string|object    $param   class name if FETCH_CLASS, an object if FETCH_INTO. else null.
  108.     * @param array  $ctoargs  arguments for the constructor if FETCH_CLASS
  109.     * @return  jDbResultSet|boolean False if the query has failed.
  110.     */
  111.     public function query ($queryString$fetchmode self::FETCH_OBJ$arg1 null$ctoargs null{
  112.         $this->lastQuery = $queryString;
  113.         if ($this->_debugMode{
  114.             $log new jSQLLogMessage($queryString);
  115.             $result $this->_doQuery ($queryString);
  116.             $log->endQuery();
  117.             jLog::log($log,'sql');
  118.         }
  119.         else {
  120.             $result $this->_doQuery ($queryString);
  121.         }
  122.         if ($fetchmode != self::FETCH_OBJ{
  123.             $result->setFetchMode($fetchmode$arg1$ctoargs);
  124.         }
  125.         return $result;
  126.     }
  127.  
  128.     /**
  129.     * Launch a SQL Query with limit parameter, so it returns only a subset of a result
  130.     * @param   string   $queryString   the SQL query
  131.     * @param   integer  $limitOffset   the offset of the first row to return
  132.     * @param   integer  $limitCount    the maximum of number of rows to return
  133.     * @return  jDbResultSet|boolean SQL Select. False if the query has failed.
  134.     */
  135.     public function limitQuery ($queryString$limitOffset$limitCount){
  136.         $this->lastQuery = $queryString;
  137.         if ($this->_debugMode{
  138.             $log new jSQLLogMessage($queryString);
  139.             $result $this->_doLimitQuery ($queryStringintval($limitOffset)intval($limitCount));
  140.             $log->endQuery();
  141.             $log->setRealQuery($this->lastQuery);
  142.             jLog::log($log,'sql');
  143.             return $result;
  144.         }
  145.         else {
  146.             return $this->_doLimitQuery ($queryStringintval($limitOffset)intval($limitCount));
  147.         }
  148.     }
  149.  
  150.     /**
  151.     * Launch a SQL Query (update, delete..) which doesn't return rows
  152.     * @param   string   $query   the SQL query
  153.     * @return  integer  the number of affected rows. False if the query has failed.
  154.     */
  155.     public function exec ($query{
  156.         $this->lastQuery = $query;
  157.         if ($this->_debugMode{
  158.             $log new jSQLLogMessage($query);
  159.             $result $this->_doExec ($query);
  160.             $log->endQuery();
  161.             jLog::log($log,'sql');
  162.             return $result;
  163.         }
  164.         else {
  165.             return $this->_doExec ($query);
  166.         }
  167.     }
  168.  
  169.     /**
  170.     * Escape and quotes strings.
  171.     * @param string $text   string to quote
  172.     * @param int $parameter_type unused, just for compatibility with PDO
  173.     * @return string escaped string
  174.     */
  175.     public function quote ($text$parameter_type 0{
  176.         // for compatibility with older jelix version
  177.         if ($parameter_type === false || $parameter_type === true)
  178.             trigger_error("signature of jDbConnection::quote has changed, you should use quote2()"E_USER_WARNING);
  179.         return "'".$this->_quote($textfalse)."'";
  180.     }
  181.  
  182.     /**
  183.     * Escape and quotes strings. if null, will only return the text "NULL"
  184.     * @param string $text   string to quote
  185.     * @param boolean $checknull if true, check if $text is a null value, and then return NULL
  186.     * @param boolean $binary  set to true if $text contains a binary string
  187.     * @return string escaped string
  188.     * @since 1.2
  189.     */
  190.     public function quote2 ($text$checknull=true$binary=false{
  191.         if ($checknull)
  192.             return (is_null ($text'NULL' "'".$this->_quote($text$binary)."'");
  193.         else
  194.             return "'".$this->_quote($text$binary)."'";
  195.     }
  196.  
  197.     /**
  198.      * enclose the field name
  199.      * @param string $fieldName the field name
  200.      * @return string the enclosed field name
  201.      * @since 1.1.1
  202.      */
  203.     public function encloseName ($fieldName{
  204.         return $fieldName;
  205.     }
  206.  
  207.     /**
  208.       * Prefix the given table with the prefix specified in the connection's profile
  209.       * If there's no prefix for the connection's profile, return the table's name unchanged.
  210.       *
  211.       * @param string $table the table's name
  212.       * @return string the prefixed table's name
  213.       * @author Julien Issler
  214.       * @since 1.0
  215.       */
  216.     public function prefixTable($table_name){
  217.         if(!isset($this->profile['table_prefix']))
  218.             return $table_name;
  219.         return $this->profile['table_prefix'].$table_name;
  220.     }
  221.  
  222.     /**
  223.       * Check if the current connection has a table prefix set
  224.       *
  225.       * @return boolean 
  226.       * @author Julien Issler
  227.       * @since 1.0
  228.       */
  229.     public function hasTablePrefix(){
  230.         return (isset($this->profile['table_prefix']&& $this->profile['table_prefix'!= '');
  231.     }
  232.  
  233.     /**
  234.     * sets the autocommit state
  235.     * @param boolean $state the status of autocommit
  236.     */
  237.     public function setAutoCommit($state=true){
  238.         $this->_autocommit $state;
  239.         $this->_autoCommitNotify ($this->_autocommit);
  240.     }
  241.  
  242.     /**
  243.      * begin a transaction. Call it before query, limitQuery, exec
  244.      * And then commit() or rollback()
  245.      */
  246.     abstract public function beginTransaction ();
  247.  
  248.     /**
  249.      * validate all queries and close a transaction
  250.      */
  251.     abstract public function commit ();
  252.  
  253.     /**
  254.      * cancel all queries of a transaction and close the transaction
  255.      */
  256.     abstract public function rollback ();
  257.  
  258.     /**
  259.      * prepare a query
  260.      * @param string $query a sql query with parameters
  261.      * @return statement a statement
  262.      */
  263.     abstract public function prepare ($query);
  264.  
  265.     /**
  266.      * @return string the last error description
  267.      */
  268.     abstract public function errorInfo();
  269.  
  270.     /**
  271.      * @return integer the last error code
  272.      */
  273.     abstract public function errorCode();
  274.  
  275.     /**
  276.      * return the id value of the last inserted row.
  277.      * Some driver need a sequence name, so give it at first parameter
  278.      * @param string $fromSequence the sequence name
  279.      * @return integer the id value
  280.      */
  281.     abstract public function lastInsertId($fromSequence='');
  282.  
  283.     /**
  284.      *
  285.      * @param integer $id the attribut id
  286.      * @return string the attribute value
  287.      * @see PDO::getAttribute()
  288.      */
  289.     abstract public function getAttribute($id);
  290.  
  291.     /**
  292.      * 
  293.      * @param integer $id the attribut id
  294.      * @param string $value the attribute value
  295.      * @see PDO::setAttribute()
  296.      */
  297.     abstract public function setAttribute($id$value);
  298.  
  299.     /**
  300.      * return the maximum value of the given primary key in a table
  301.      * @param string $fieldName the name of the primary key
  302.      * @param string $tableName the name of the table
  303.      * @return integer the maximum value
  304.      */
  305.     public function lastIdInTable($fieldName$tableName){
  306.         $rs $this->query ('SELECT MAX('.$fieldName.') as ID FROM '.$tableName);
  307.         if (($rs !== null&& $r $rs->fetch ()){
  308.             return $r->ID;
  309.         }
  310.         return 0;
  311.     }
  312.  
  313.     /**
  314.     * Notify the changes on autocommit
  315.     * Drivers may overload this
  316.     * @param boolean $state the new state of autocommit
  317.     */
  318.     abstract protected function _autoCommitNotify ($state);
  319.  
  320.     /**
  321.     * return a connection identifier or false/null if there is an error
  322.     * @return integer connection identifier
  323.     */
  324.     abstract protected function _connect ();
  325.  
  326.     /**
  327.     * do a disconnection
  328.     * (no need to do a test on the connection id)
  329.     */
  330.     abstract protected function _disconnect ();
  331.  
  332.     /**
  333.     * do a query which return results
  334.     * @return jDbResultSet/boolean 
  335.     */
  336.     abstract protected function _doQuery ($queryString);
  337.     /**
  338.     * do a query which return nothing
  339.     * @return jDbResultSet/boolean 
  340.     */
  341.     abstract protected function _doExec ($queryString);
  342.  
  343.     /**
  344.     * do a query which return a limited number of results
  345.     * @return jDbResultSet/boolean 
  346.     */
  347.     abstract protected function _doLimitQuery ($queryString$offset$number);
  348.  
  349.     /**
  350.     * do the escaping of a string.
  351.     * you should override it into the driver
  352.     * @param string $text the text to escape
  353.     * @param boolean $binary true if the content of the string is a binary content
  354.     */
  355.     protected function _quote($text$binary){
  356.         return addslashes($text);
  357.     }
  358.     
  359.     /**
  360.      * @var jDbTools 
  361.      * @since 1.2
  362.      */
  363.     protected $_tools = null;
  364.     
  365.     /**
  366.      * @return jDbTools 
  367.      * @since 1.2
  368.      */
  369.     public function tools ({
  370.         if (!$this->_tools{
  371.             require_once(jApp::config()->_pluginsPathList_db[$this->driverName].$this->driverName.'.dbtools.php');
  372.             $class $this->driverName.'DbTools';
  373.             $this->_tools = new $class($this);
  374.         }
  375.  
  376.         return $this->_tools;
  377.     }
  378.  
  379.  
  380.     /**
  381.      * @var jDbSchema 
  382.      * @since 1.2
  383.      */
  384.     protected $_schema = null;
  385.     
  386.     /**
  387.      * @return jDbSchema 
  388.      * @since 1.2
  389.      */
  390.     public function schema ({
  391.         if (!$this->_schema{
  392.             require_once(jApp::config()->_pluginsPathList_db[$this->driverName].$this->driverName.'.dbschema.php');
  393.             $class $this->driverName.'DbSchema';
  394.             $this->_schema = new $class($this);
  395.         }
  396.  
  397.         return $this->_schema;
  398.     }
  399.     
  400. }

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