TraceableDB.php

<?php
 
require_once DOL_DOCUMENT_ROOT.'/core/db/DoliDB.class.php';
 
class TraceableDB extends DoliDB
{
  public $db; // cannot be protected because of parent declaration
  public $queries;
  protected $startTime;
  protected $startMemory;
  public $type;
  const LABEL = ''; // TODO: the right value should be $this->db::LABEL (but this is a constant? o_O)
  const VERSIONMIN = ''; // TODO: the same thing here, $this->db::VERSIONMIN is the right value
 
  public function __construct($db)
  {
    $this->db      = $db;
    $this->type    = $this->db->type;
    $this->queries = array();
  }
 
  public function ifsql($test, $resok, $resko)
  {
    return $this->db->ifsql($test, $resok, $resko);
  }
 
  // phpcs:disable PEAR.NamingConventions.ValidFunctionName.ScopeNotCamelCaps
  public function fetch_row($resultset)
  {
    // phpcs:enable
    return $this->db->fetch_row($resultset);
  }
 
  public function idate($param, $gm = 'tzserver')
  {
    return $this->db->idate($param, $gm);
  }
 
  public function lasterrno()
  {
    return $this->db->lasterrno();
  }
 
  public function begin($textinlog = '')
  {
    return $this->db->begin($textinlog);
  }
 
  public function DDLCreateDb($database, $charset = '', $collation = '', $owner = '')
  {
    return $this->db->DDLCreateDb($database, $charset, $collation, $owner);
  }
 
  public function getVersionArray()
  {
    return $this->db->getVersionArray();
  }
 
  public static function convertSQLFromMysql($line, $type = 'ddl')
  {
    return self::$db->convertSQLFromMysql($line);
  }
 
  // phpcs:disable PEAR.NamingConventions.ValidFunctionName.ScopeNotCamelCaps
  public function affected_rows($resultset)
  {
    // phpcs:enable
    return $this->db->affected_rows($resultset);
  }
 
  public function error()
  {
    return $this->db->error();
  }
 
  public function DDLListTables($database, $table = '')
  {
    return $this->db->DDLListTables($database, $table);
  }
 
  public function lastquery()
  {
    return $this->db->lastquery();
  }
 
  public function order($sortfield = null, $sortorder = null)
  {
    return $this->db->order($sortfield, $sortorder);
  }
 
  public function decrypt($value)
  {
    return $this->db->decrypt($value);
  }
 
  // phpcs:disable PEAR.NamingConventions.ValidFunctionName.ScopeNotCamelCaps
  public function fetch_array($resultset)
  {
    // phpcs:enable
    return $this->db->fetch_array($resultset);
  }
 
  public function lasterror()
  {
    return $this->db->lasterror();
  }
 
  public function escape($stringtoencode)
  {
    return $this->db->escape($stringtoencode);
  }
 
  public function escapeunderscore($stringtoencode)
  {
    return $this->db->escapeunderscore($stringtoencode);
  }
 
  public function escapeforlike($stringtoencode)
  {
    return str_replace(array('_', '\\', '%'), array('\_', '\\\\', '\%'), (string) $stringtoencode);
  }
 
  // phpcs:disable PEAR.NamingConventions.ValidFunctionName.ScopeNotCamelCaps
  public function last_insert_id($tab, $fieldid = 'rowid')
  {
    // phpcs:enable
    return $this->db->last_insert_id($tab, $fieldid);
  }
 
  public function getPathOfRestore()
  {
    return $this->db->getPathOfRestore();
  }
 
  public function rollback($log = '')
  {
    return $this->db->rollback($log);
  }
 
  public function query($query, $usesavepoint = 0, $type = 'auto', $result_mode = 0)
  {
    $this->startTracing();
 
    $resql = $this->db->query($query, $usesavepoint, $type, $result_mode);
 
    $this->endTracing($query, $resql);
 
    return $resql;
  }
 
  protected function startTracing()
  {
    $this->startTime   = microtime(true);
    $this->startMemory = memory_get_usage(true);
  }
 
  protected function endTracing($sql, $resql)
  {
    $endTime     = microtime(true);
    $duration    = $endTime - $this->startTime;
    $endMemory   = memory_get_usage(true);
    $memoryDelta = $endMemory - $this->startMemory;
 
    $this->queries[] = array(
      'sql'           => $sql,
      'duration'      => $duration,
      'memory_usage'  => $memoryDelta,
      'is_success'    => $resql ? true : false,
      'error_code'    => $resql ? null : $this->db->lasterrno(),
      'error_message' => $resql ? null : $this->db->lasterror()
    );
  }
 
  public function connect($host, $login, $passwd, $name, $port = 0)
  {
    return $this->db->connect($host, $login, $passwd, $name, $port);
  }
 
  public function plimit($limit = 0, $offset = 0)
  {
    return $this->db->plimit($limit, $offset);
  }
 
  public function getServerParametersValues($filter = '')
  {
    return $this->db->getServerParametersValues($filter);
  }
 
  public function getServerStatusValues($filter = '')
  {
    return $this->db->getServerStatusValues($filter);
  }
 
  public function getDefaultCollationDatabase()
  {
    return $this->db->getDefaultCollationDatabase();
  }
 
  // phpcs:disable PEAR.NamingConventions.ValidFunctionName.ScopeNotCamelCaps
  public function num_rows($resultset)
  {
    // phpcs:enable
    return $this->db->num_rows($resultset);
  }
 
  public function getPathOfDump()
  {
    return $this->db->getPathOfDump();
  }
 
  public function getDriverInfo()
  {
    return $this->db->getDriverInfo();
  }
 
  public function errno()
  {
    return $this->db->errno();
  }
 
  public function DDLCreateTable($table, $fields, $primary_key, $type, $unique_keys = null, $fulltext_keys = null, $keys = null)
  {
    return $this->db->DDLCreateTable($table, $fields, $primary_key, $type, $unique_keys, $fulltext_keys, $keys);
  }
 
  public function DDLDropTable($table)
  {
    return $this->db->DDLDropTable($table);
  }
 
  public function getListOfCharacterSet()
  {
    return $this->db->getListOfCharacterSet();
  }
 
  public function DDLAddField($table, $field_name, $field_desc, $field_position = "")
  {
    return $this->db->DDLAddField($table, $field_name, $field_desc, $field_position);
  }
 
  public function DDLDropField($table, $field_name)
  {
    return $this->db->DDLDropField($table, $field_name);
  }
 
  public function DDLUpdateField($table, $field_name, $field_desc)
  {
    return $this->db->DDLUpdateField($table, $field_name, $field_desc);
  }
 
  public function getListOfCollation()
  {
    return $this->db->getListOfCollation();
  }
 
  public function DDLDescTable($table, $field = "")
  {
    return $this->db->DDLDescTable($table, $field);
  }
 
  public function getVersion()
  {
    return $this->db->getVersion();
  }
 
  public function getDefaultCharacterSetDatabase()
  {
    return $this->db->getDefaultCharacterSetDatabase();
  }
 
  public function DDLCreateUser($dolibarr_main_db_host, $dolibarr_main_db_user, $dolibarr_main_db_pass, $dolibarr_main_db_name)
  {
    return $this->db->DDLCreateUser($dolibarr_main_db_host, $dolibarr_main_db_user, $dolibarr_main_db_pass, $dolibarr_main_db_name);
  }
 
  // phpcs:disable PEAR.NamingConventions.ValidFunctionName.ScopeNotCamelCaps
  public function jdate($string, $gm = false)
  {
    // phpcs:enable
    return $this->db->jdate($string, $gm);
  }
 
  public function encrypt($fieldorvalue, $withQuotes = 1)
  {
    return $this->db->encrypt($fieldorvalue, $withQuotes);
  }
 
  public function commit($log = '')
  {
    return $this->db->commit($log);
  }
 
  public function DDLInfoTable($table)
  {
    return $this->db->DDLInfoTable($table);
  }
 
  public function free($resultset = null)
  {
    $this->db->free($resultset);
  }
 
  public function close()
  {
    return $this->db->close();
  }
 
  public function lastqueryerror()
  {
    return $this->db->lastqueryerror();
  }
 
  public function DDLGetConnectId()
  {
    return $this->db->DDLGetConnectId();
  }
 
  // phpcs:disable PEAR.NamingConventions.ValidFunctionName.ScopeNotCamelCaps
  public function fetch_object($resultset)
  {
    // phpcs:enable
    return $this->db->fetch_object($resultset);
  }
 
  // phpcs:disable PEAR.NamingConventions.ValidFunctionName.ScopeNotCamelCaps
  public function select_db($database)
  {
    // phpcs:enable
    return $this->db->select_db($database);
  }
}