TraceableDB.php

<?php
/* Copyright (C) 2023 Laurent Destailleur   <eldy@users.sourceforge.net>
 * Copyright (C) 2024-2026  MDW         <mdeweerd@users.noreply.github.com>
 * Copyright (C) 2024       Frédéric France             <frederic.france@free.fr>
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program. If not, see <https://www.gnu.org/licenses/>.
 */
 
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);
  }
 
  public function regexpsql($subject, $pattern, $sqlstring = 0): string
  {
    return $this->db->regexpsql($subject, $pattern, $sqlstring = 0);
  }
 
  // 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 function convertSQLFromMysql($line, $type = 'ddl')
  {
    return $this->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 DDLListTablesFull($database, $table = '')
  {
    return $this->db->DDLListTablesFull($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 escapeforlike($stringtoencode)
  {
    return $this->db->escapeforlike($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 isFullTracingEnabled()
  {
    if (isset($_COOKIE['debugbar_full_tracing'])) {
      return $_COOKIE['debugbar_full_tracing'] === '1';
    }
    return false;
  }
 
  protected function endTracing($sql, $resql)
  {
    $endTime     = microtime(true);
    $duration    = $endTime - $this->startTime;
    $endMemory   = memory_get_usage(true);
    $memoryDelta = $endMemory - $this->startMemory;
 
    // Capture backtrace for failed queries, or if full tracing is enabled
    $backtrace = null;
    if (!$resql || $this->isFullTracingEnabled()) {
      $backtrace = debug_backtrace(DEBUG_BACKTRACE_IGNORE_ARGS);
    }
 
    $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(),
      'backtrace'     => $backtrace
    );
  }
 
  public function connect($host, $login, $passwd, $name, $port = 0, $forcenew = false)
  {
    return $this->db->connect($host, $login, $passwd, $name, $port, $forcenew);
  }
 
  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);
  }
}