[ Index ]
 

Code source de Dolibarr 2.0.1

Accédez au Source d'autres logiciels libres

Classes | Fonctions | Variables | Constantes | Tables

title

Body

[fermer]

/htdocs/lib/ -> mysql.lib.php (source)

   1  <?php
   2  /* Copyright (C) 2001      Fabien Seisen        <seisen@linuxfr.org>
   3   * Copyright (C) 2002-2005 Rodolphe Quiedeville <rodolphe@quiedeville.org>
   4   * Copyright (C) 2004-2005 Laurent Destailleur  <eldy@users.sourceforge.net>
   5   *
   6   * This program is free software; you can redistribute it and/or modify
   7   * it under the terms of the GNU General Public License as published by
   8   * the Free Software Foundation; either version 2 of the License, or
   9   * (at your option) any later version.
  10   *
  11   * This program is distributed in the hope that it will be useful,
  12   * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14   * GNU General Public License for more details.
  15   *
  16   * You should have received a copy of the GNU General Public License
  17   * along with this program; if not, write to the Free Software
  18   * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  19   *
  20   * $Id: mysql.lib.php,v 1.72.2.1 2006/01/21 15:03:16 eldy Exp $
  21   * $Source: /cvsroot/dolibarr/dolibarr/htdocs/lib/mysql.lib.php,v $
  22   */
  23  
  24  /**
  25          \file       htdocs/lib/mysql.lib.php
  26          \brief      Fichier de la classe permettant de gérer une base mysql
  27          \author     Fabien Seisen
  28          \author     Rodolphe Quiedeville.
  29          \author     Laurent Destailleur.
  30          \version    $Revision: 1.72.2.1 $
  31  */
  32  
  33  
  34  /**
  35          \class      DoliDb
  36          \brief      Classe permettant de gérér la database de dolibarr
  37  */
  38  
  39  class DoliDb
  40  {
  41      var $db;                      // Handler de base
  42      var $type='mysql';            // Nom du gestionnaire
  43  
  44      var $results;                 // Resultset de la dernière requete
  45  
  46      var $connected;               // 1 si connecté, 0 sinon
  47      var $database_selected;       // 1 si base sélectionné, 0 sinon
  48      var $database_name;              // Nom base sélectionnée
  49      var $transaction_opened;      // 1 si une transaction est en cours, 0 sinon
  50      var $lastquery;
  51      
  52      var $ok;
  53      var $error;
  54      
  55      // Constantes pour conversion code erreur MySql en code erreur générique
  56      var $errorcode_map = array(
  57      1004 => 'DB_ERROR_CANNOT_CREATE',
  58      1005 => 'DB_ERROR_CANNOT_CREATE',
  59      1006 => 'DB_ERROR_CANNOT_CREATE',
  60      1007 => 'DB_ERROR_ALREADY_EXISTS',
  61      1008 => 'DB_ERROR_CANNOT_DROP',
  62      1046 => 'DB_ERROR_NODBSELECTED',
  63      1050 => 'DB_ERROR_TABLE_ALREADY_EXISTS',
  64      1051 => 'DB_ERROR_NOSUCHTABLE',
  65      1054 => 'DB_ERROR_NOSUCHFIELD',
  66      1060 => 'DB_ERROR_COLUMN_ALREADY_EXISTS',
  67      1061 => 'DB_ERROR_KEY_NAME_ALREADY_EXISTS', 
  68      1062 => 'DB_ERROR_RECORD_ALREADY_EXISTS',
  69      1064 => 'DB_ERROR_SYNTAX',
  70      1091 => 'DB_ERROR_NOSUCHFIELD',
  71      1100 => 'DB_ERROR_NOT_LOCKED',
  72      1136 => 'DB_ERROR_VALUE_COUNT_ON_ROW',
  73      1146 => 'DB_ERROR_NOSUCHTABLE',
  74      1048 => 'DB_ERROR_CONSTRAINT',
  75      1216 => 'DB_ERROR_NO_PARENT',
  76      1217 => 'DB_ERROR_CHILD_EXISTS'
  77      );
  78  
  79      /**
  80              \brief      Ouverture d'une connection vers le serveur et éventuellement une database.
  81              \param      type        Type de base de données (mysql ou pgsql)
  82              \param        host        Addresse de la base de données
  83              \param        user        Nom de l'utilisateur autorisé
  84              \param        pass        Mot de passe
  85              \param        name        Nom de la database
  86              \param        newlink     ???
  87              \return     int            1 en cas de succès, 0 sinon
  88      */
  89      function DoliDb($type='mysql', $host, $user, $pass, $name='', $newlink=0)
  90      {
  91          global $conf,$langs;
  92          $this->transaction_opened=0;
  93  
  94          //print "Name DB: $host,$user,$pass,$name<br>";
  95  
  96          if (! function_exists("mysql_connect"))
  97          {
  98              $this->connected = 0;
  99              $this->ok = 0;
 100              $this->error="Mysql PHP functions are not available in this version of PHP";
 101              dolibarr_syslog("DoliDB::DoliDB : Mysql PHP functions are not available in this version of PHP");
 102              return $this->ok;
 103          }
 104  
 105          if (! $host)
 106          {
 107              $this->connected = 0;
 108              $this->ok = 0;
 109              $this->error=$langs->trans("ErrorWrongHostParameter");
 110              dolibarr_syslog("DoliDB::DoliDB : Erreur Connect, wrong host parameters");
 111              return $this->ok;
 112          }
 113  
 114          // Essai connexion serveur
 115          $this->db = $this->connect($host, $user, $pass, $name, $newlink);
 116  
 117          if ($this->db)
 118          {
 119              $this->connected = 1;
 120              $this->ok = 1;
 121          }
 122          else
 123          {
 124              // host, login ou password incorrect
 125              $this->connected = 0;
 126              $this->ok = 0;
 127              dolibarr_syslog("DoliDB::DoliDB : Erreur Connect");
 128          }
 129  
 130          // Si connexion serveur ok et si connexion base demandée, on essaie connexion base
 131          if ($this->connected && $name)
 132          {
 133              if ($this->select_db($name) == 1)
 134              {
 135                  $this->database_selected = 1;
 136                  $this->database_name = $name;
 137                  $this->ok = 1;
 138              }
 139              else
 140              {
 141                  $this->database_selected = 0;
 142                  $this->database_name = '';
 143                  $this->ok = 0;
 144                  $this->error=$this->error();
 145                  dolibarr_syslog("DoliDB::DoliDB : Erreur Select_db");
 146              }
 147          }
 148          else
 149          {
 150              // Pas de selection de base demandée, ok ou ko
 151              $this->database_selected = 0;
 152          }
 153  
 154          return $this->ok;
 155      }
 156  
 157      /**
 158              \brief      Selectionne une database.
 159              \param        database        Nom de la database
 160              \return        resource
 161      */
 162      function select_db($database)
 163      {
 164          return mysql_select_db($database, $this->db);
 165      }
 166  
 167      /**
 168              \brief      Connection vers le serveur
 169              \param        host        addresse de la base de données
 170              \param        login        nom de l'utilisateur autoris
 171              \param        passwd        mot de passe
 172              \param        name        nom de la database (ne sert pas sous mysql, sert sous pgsql)
 173              \return        resource    handler d'accès à la base
 174      */
 175      function connect($host, $login, $passwd, $name)
 176      {
 177          $this->db  = @mysql_connect($host, $login, $passwd);
 178          //print "Resultat fonction connect: ".$this->db;
 179          return $this->db;
 180      }
 181  
 182  
 183      /**
 184              \brief          Renvoie la version du serveur
 185              \return            string      Chaine version
 186      */
 187      function getVersion()
 188      {
 189          $resql=$this->query('SELECT VERSION()');
 190          $row=$this->fetch_row($resql);
 191          return $row[0];
 192      }
 193          
 194          
 195      /**
 196              \brief          Renvoie l'id de la connection
 197              \return            string      Id connection
 198      */
 199      function getConnectId()
 200      {
 201          $resql=$this->query('SELECT CONNECTION_ID()');
 202          $row=$this->fetch_row($resql);
 203          return $row[0];
 204      }
 205  
 206  
 207      /**
 208              \brief          Renvoie la commande sql qui donne les droits sur les tables
 209              \return            string      Requete sql
 210      */
 211      function getGrantForUserQuery($databaseuser)
 212      {
 213          return '';
 214      }
 215          
 216          
 217      /**
 218              \brief          Création d'une nouvelle base de donnée
 219              \param            database        nom de la database à créer
 220              \return            resource        resource définie si ok, null si ko
 221              \remarks        Ne pas utiliser les fonctions xxx_create_db (xxx=mysql, ...) car elles sont deprecated
 222      */
 223      function create_db($database)
 224      {
 225          $ret=$this->query('CREATE DATABASE '.$database);
 226          //print "database=".$this->database_name." ret=".$ret." mysqlerror=".mysql_error($this->db);
 227          return $ret;
 228      }
 229          
 230         
 231      /**
 232          \brief      Copie d'un handler de database.
 233          \return        resource
 234      */
 235  
 236      function dbclone()
 237      {
 238          $db2 = new DoliDb("", "", "", "", "");
 239          $db2->db = $this->db;
 240          return $db2;
 241      }
 242  
 243      /**
 244              \brief      Ouverture d'une connection vers une database.
 245              \param        host        Adresse de la base de données
 246              \param        login        Nom de l'utilisateur autorisé
 247              \param        passwd        Mot de passe
 248              \param        name        Nom de la database (ne sert pas sous mysql, sert sous pgsql)
 249              \return        resource    Handler d'accès à la base
 250      */
 251  
 252      function pconnect($host, $login, $passwd, $name)
 253      {
 254          $this->db  = mysql_pconnect($host, $login, $passwd);
 255          return $this->db;
 256      }
 257  
 258      /**
 259          \brief      Fermeture d'une connection vers une database.
 260          \return        resource
 261      */
 262  
 263      function close()
 264      {
 265          return mysql_close($this->db);
 266      }
 267  
 268  
 269      /**
 270          \brief      Debut d'une transaction.
 271          \return        int         1 si ouverture transaction ok ou deja ouverte, 0 en cas d'erreur
 272      */
 273  
 274      function begin()
 275      {
 276          if (! $this->transaction_opened)
 277          {
 278              $ret=$this->query("BEGIN");
 279              if ($ret) $this->transaction_opened++;
 280              return $ret;
 281          }
 282          else
 283          {
 284              $this->transaction_opened++;
 285              return 1;
 286          }
 287      }
 288  
 289      /**
 290          \brief      Validation d'une transaction
 291          \return        int         1 si validation ok ou niveau de transaction non ouverte, 0 en cas d'erreur
 292      */
 293  
 294      function commit()
 295      {
 296          if ($this->transaction_opened==1)
 297          {
 298              $ret=$this->query("COMMIT");
 299              if ($ret) $this->transaction_opened=0;
 300              return $ret;
 301          }
 302          else
 303          {
 304              $this->transaction_opened--;
 305              return 1;
 306          }
 307      }
 308  
 309      /**
 310          \brief      Annulation d'une transaction et retour aux anciennes valeurs
 311          \return        int         1 si annulation ok ou transaction non ouverte, 0 en cas d'erreur
 312      */
 313  
 314      function rollback()
 315      {
 316          if ($this->transaction_opened)
 317          {
 318              $ret=$this->query("ROLLBACK");
 319              $this->transaction_opened=0;
 320              return $ret;
 321          }
 322          else
 323          {
 324              return 1;
 325          }
 326      }
 327  
 328      /**
 329          \brief      Effectue une requete et renvoi le resultset de réponse de la base
 330          \param        query        Contenu de la query
 331          \return        resource    Resultset de la reponse
 332      */
 333  
 334      function query($query)
 335      {
 336          $query = trim($query);
 337  
 338          if (! $this->database_name)
 339          {
 340              // Ordre SQL ne nécessitant pas de connexion à une base (exemple: CREATE DATABASE)
 341              $ret = mysql_query($query, $this->db);
 342          }
 343          else
 344          {
 345              $ret = mysql_db_query($this->database_name, $query, $this->db);
 346          }
 347          
 348          if (! eregi("^COMMIT",$query) && ! eregi("^ROLLBACK",$query)) {
 349              // Si requete utilisateur, on la sauvegarde ainsi que son resultset
 350              $this->lastquery=$query;
 351              $this->results = $ret;
 352          }
 353  
 354          return $ret;
 355      }
 356  
 357      /**
 358          \brief      Renvoie les données de la requete.
 359          \param        nb            Contenu de la query
 360          \param        fieldname    Nom du champ
 361          \return        resource
 362      */
 363  
 364      function result($nb, $fieldname)
 365      {
 366          return mysql_result($this->results, $nb, $fieldname);
 367      }
 368  
 369      /**
 370          \brief      Renvoie la ligne courante (comme un objet) pour le curseur resultset.
 371          \param      resultset   Curseur de la requete voulue
 372          \return        resource
 373      */
 374  
 375      function fetch_object($resultset=0)
 376      {
 377          // Si le resultset n'est pas fourni, on prend le dernier utilisé sur cette connexion
 378          if (! is_resource($resultset)) { $resultset=$this->results; }
 379          return mysql_fetch_object($resultset);
 380      }
 381  
 382      /**
 383          \brief      Renvoie les données dans un tableau.
 384          \param      resultset   Curseur de la requete voulue
 385          \return        array
 386      */
 387  
 388      function fetch_array($resultset=0)
 389      {
 390          // Si le resultset n'est pas fourni, on prend le dernier utilisé sur cette connexion
 391          if (! is_resource($resultset)) { $resultset=$this->results; }
 392          return mysql_fetch_array($resultset);
 393      }
 394  
 395      /**
 396          \brief      Renvoie les données comme un tableau.
 397          \param      resultset   Curseur de la requete voulue
 398          \return        array
 399      */
 400  
 401      function fetch_row($resultset=0)
 402      {
 403          // Si le resultset n'est pas fourni, on prend le dernier utilisé sur cette connexion
 404          if (! is_resource($resultset)) { $resultset=$this->results; }
 405          return mysql_fetch_row($resultset);
 406      }
 407  
 408      /**
 409          \brief      Obtient les données d'un colonne et renvoie les données sous forme d'objet.
 410          \param      resultset   Curseur de la requete voulue
 411          \return     array
 412      */
 413  
 414      function fetch_field($resultset=0)
 415      {
 416          // Si le resultset n'est pas fourni, on prend le dernier utilisé sur cette connexion
 417          if (! is_resource($resultset)) { $resultset=$this->results; }
 418          return mysql_fetch_field($resultset);
 419      }
 420  
 421      /**
 422          \brief      Renvoie le nombre de lignes dans le resultat d'une requete SELECT
 423          \see        affected_rows
 424          \param      resultset   Curseur de la requete voulue
 425          \return     int            Nombre de lignes
 426      */
 427  
 428      function num_rows($resultset=0)
 429      {
 430          // Si le resultset n'est pas fourni, on prend le dernier utilisé sur cette connexion
 431          if (! is_resource($resultset)) { $resultset=$this->results; }
 432          return mysql_num_rows($resultset);
 433      }
 434  
 435      /**
 436          \brief      Renvoie le nombre de lignes dans le resultat d'une requete INSERT, DELETE ou UPDATE
 437          \see        num_rows
 438          \param      resultset   Curseur de la requete voulue
 439          \return     int            Nombre de lignes
 440      */
 441  
 442      function affected_rows($resultset=0)
 443      {
 444          // Si le resultset n'est pas fourni, on prend le dernier utilisé sur cette connexion
 445          if (! is_resource($resultset)) { $resultset=$this->results; }
 446          // mysql necessite un link de base pour cette fonction contrairement
 447          // a pqsql qui prend un resultset
 448          return mysql_affected_rows($this->db);
 449      }
 450  
 451  
 452      /**
 453          \brief      Renvoie le nombre de champs dans le resultat de la requete.
 454          \param      resultset   Curseur de la requete voulue
 455          \return        int
 456      */
 457  
 458      function num_fields($resultset=0)
 459      {
 460          // Si le resultset n'est pas fourni, on prend le dernier utilisé sur cette connexion
 461          if (! is_resource($resultset)) { $resultset=$this->results; }
 462          return mysql_num_fields($resultset);
 463      }
 464  
 465      /**
 466          \brief      Libère le dernier resultset utilisé sur cette connexion.
 467          \param      resultset   Curseur de la requete voulue
 468      */
 469  
 470      function free($resultset=0)
 471      {
 472          // Si le resultset n'est pas fourni, on prend le dernier utilisé sur cette connexion
 473          if (! is_resource($resultset)) { $resultset=$this->results; }
 474          // Si resultset en est un, on libere la mémoire
 475          if (is_resource($resultset)) mysql_free_result($resultset);
 476      }
 477  
 478      /**
 479          \brief      Défini les limites de la requète.
 480          \param        limit       nombre maximum de lignes retournées
 481          \param        offset      numéro de la ligne à partir de laquelle recupérer les lignes
 482          \return        string      chaine exprimant la syntax sql de la limite
 483      */
 484  
 485      function plimit($limit=0,$offset=0)
 486      {
 487          global $conf;
 488          if (! $limit) $limit=$conf->liste_limit;
 489          if ($offset > 0) return " LIMIT $offset,$limit ";
 490          else return " LIMIT $limit ";
 491      }
 492  
 493  
 494      /**
 495          \brief      Formatage (par la base de données) d'un champ de la base au format tms ou Date (YYYY-MM-DD HH:MM:SS)
 496                      afin de retourner une donnée toujours au format universel date tms unix.
 497                      Fonction à utiliser générer les SELECT.
 498          \param        param       Date au format text à convertir
 499          \return        date        Date au format tms.
 500      */
 501      function pdate($param)
 502      {
 503          return "unix_timestamp(".$param.")";
 504      }
 505  
 506      /**
 507          \brief      Formatage (par la base de données) d'un champ tms
 508                      afin de retourner une donnée au format text YYYYMMDDHHMMSS.
 509                      Fonction à utiliser pour générer les INSERT.
 510          \param        param       Date tms à convertir
 511          \return        string      Date au format text YYYYMMDDHHMMSS.
 512      */
 513      function qdate($param)
 514      {
 515          return "from_unixtime(".$param.")";
 516      }
 517  
 518      /**
 519          \brief      Formatage (par PHP) de la date en texte.
 520                      Fonction à utiliser pour générer les INSERT.
 521          \param        param       Date tms à convertir
 522          \return        date        Date au format text YYYYMMDDHHMMSS.
 523      */
 524      function idate($param)
 525      {
 526          return strftime("%Y%m%d%H%M%S",$param);
 527      }
 528  
 529  
 530      /**
 531          \brief      Formatage d'un if SQL
 532          \param        test            chaine test
 533          \param        resok           resultat si test egal
 534          \param        resko           resultat si test non egal
 535          \return        string          chaine formaté SQL
 536      */
 537      function ifsql($test,$resok,$resko)
 538      {
 539          return 'IF('.$test.','.$resok.','.$resko.')';
 540      }
 541      
 542  
 543      /**
 544          \brief      Renvoie la derniere requete soumise par la methode query()
 545          \return        lastquery
 546      */
 547  
 548      function lastquery()
 549      {
 550          return $this->lastquery;
 551      }
 552  
 553      /**
 554          \brief     Renvoie le code erreur generique de l'operation precedente.
 555          \return    error_num       (Exemples: DB_ERROR_TABLE_ALREADY_EXISTS, DB_ERROR_RECORD_ALREADY_EXISTS...)
 556      */
 557  
 558      function errno()
 559      {
 560          if (! $this->connected) {
 561              // Si il y a eu echec de connection, $this->db n'est pas valide.
 562              return 'DB_ERROR_FAILED_TO_CONNECT';
 563          }
 564          else {
 565              if (isset($this->errorcode_map[mysql_errno($this->db)])) {
 566                  return $this->errorcode_map[mysql_errno($this->db)];
 567              }
 568              $errno=mysql_errno($this->db);
 569              return ($errno?'DB_ERROR_'.$errno:'0');
 570          }
 571      }
 572  
 573      /**
 574          \brief     Renvoie le texte de l'erreur mysql de l'operation precedente.
 575          \return    error_text
 576      */
 577  
 578      function error()
 579      {
 580          if (! $this->connected) {
 581              // Si il y a eu echec de connection, $this->db n'est pas valide pour mysql_error.
 582              return 'Not connected. Check setup parameters in conf/conf.php file and your mysql client and server versions';
 583          }
 584          else {
 585              return mysql_error($this->db);
 586          }
 587      }
 588  
 589      /**
 590          \brief     Récupère l'id genéré par le dernier INSERT.
 591          \param     tab     Nom de la table concernée par l'insert. Ne sert pas sous MySql mais requis pour compatibilité avec Postgresql
 592          \return    int     id
 593      */
 594  
 595      function last_insert_id($tab)
 596      {
 597          return mysql_insert_id($this->db);
 598      }
 599  
 600      /**
 601          \brief      Retourne le dsn pear
 602          \return     dsn
 603      */
 604  
 605      function getdsn($db_type,$db_user,$db_pass,$db_host,$dbname)
 606      {
 607          $pear = $db_type.'://'.$db_user.':'.$db_pass.'@'.
 608          $db_host.'/'.$db_name;
 609  
 610          return $pear;
 611      }
 612  
 613      /**
 614          \brief      Liste des tables dans une database.
 615          \param        database    Nom de la database
 616          \return        resource
 617      */
 618  
 619      function list_tables($database)
 620      {
 621          $this->results = mysql_list_tables($database, $this->db);
 622          return $this->results;
 623      }
 624  
 625  
 626      function setLastQuery($s)
 627      {
 628          $this->lastquery=$s;
 629      }
 630  
 631  
 632      /**
 633          \brief      Renvoie toutes les données comme un tableau.
 634          \param      sql         Requete sql
 635          \param      datas       Tableau de données pour retour
 636          \return        int         >0 si ok, <0 si ko
 637      */
 638      function fetch_all_rows($sql, &$datas)
 639      {
 640          $datas = array();
 641      
 642          $resql = $this->query($sql);
 643          if ($resql)
 644          {
 645              $i = 0;
 646              $num = $this->num_rows($resql);
 647      
 648              while ($i < $num)
 649              {
 650                  $row = $this->fetch_row($resql);
 651                  array_push($datas, $row[0]);
 652                  $i++;
 653              }
 654          }
 655          else
 656          {
 657              print $this->error();
 658              return -1;
 659          }
 660          return 1;
 661      }
 662  
 663  }
 664  
 665  ?>


Généré le : Mon Nov 26 12:29:37 2007 par Balluche grâce à PHPXref 0.7
  Clicky Web Analytics