Db - Code Metrics - Inspection of "fix: corregir nombre y namespace en clase Db" - nelsonrojasn/pin - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — main ( 166306...644851 )

by Nelson

created 2025-12-04 15:32 UTC

Db A

↳ Parent: Project

Complexity

Total Complexity

Size/Duplication

Total Lines	245
Duplicated Lines	0 %

Importance

Changes

Metric	Value
eloc	68
dl	0
loc	245
rs	10
c	0
b	0
f	0
wmc	23

14 Methods

Rating	Name	Size	Complexity
A	commit()	3	1
A	_closeConnection()	3	1
A	findAll()	9	1
A	rollback()	3	1
A	findFirst()	7	3
A	beginTransaction()	3	1
A	__destruct()	3	1
A	execute()	8	1
A	_exec()	11	2
A	delete()	5	1
A	insert()	21	2
A	connect()	19	3
A	getScalar()	8	2
A	update()	21	3

<?php

namespace Pin\Libs;
use PDO;
use Exception;

/** 
 * Db
 * Clase para la gestión de acceso a la base de datos
 * y operaciones CRUD: Crear, Leer, update y Borrar
 * @author nelson rojas
 */
class Db
{
    /**
     * Base de datos a la que se conecta
     *
     * @var PDO
     */
    private static $_connection = null;


    /**
     * Sirve para conectarse a la base de datos
     * usando los parámetros de la clase Configuracion
     * @throws Exception
     */
    private static function connect()
    {

        if (isset(self::$_connection)) {
            return TRUE;
        }

        $db_config = Config::getDbConfig();

        try {
            self::$_connection = new PDO(
                $db_config['dsn'],
                $db_config['user'],
                $db_config['password'],
                $db_config['parameters']
            );
            return TRUE;
        } catch (Exception $e) {
            throw new Exception($e->getMessage());
        }
    }

    /**
     * Permite reutilizar sentencias para la ejecución de
     * consultas parametrizadas
     */
    private static function _exec(string $sql, array $parameters = null)
    {
        self::connect();

        $sentence = self::$_connection->prepare($sql);
        if (is_array($parameters)) {
            $sentence->execute($parameters);
        } else {
            $sentence->execute();
        }
        return $sentence;
    }

    /**
     * Obtiene filas (registros) desde la base de datos como array
     * @param string $sql
     * @param array $parameters
     *
     * @return array
     */
    public static function findAll(string $sql, array $parameters = null)
    {

        $sentence = self::_exec($sql, $parameters);

        $rows = $sentence->fetchAll(PDO::FETCH_ASSOC);
        $sentence->closeCursor();

        return $rows;
    }

    /**
     * Obtiene una fila (registro) desde la base de datos como array
     * @param string $sql
     * @param array $parameters
     *
     * @return array
     */
    public static function findFirst(string $sql, array $parameters = null)
    {
        $rows = self::findAll($sql, $parameters);
        if (isset($rows) && count($rows) > 0) {
            return $rows[0];
        } else {
            return null;
        }
    }

    /**
     * Obtiene un escalar (valor) desde la base de datos
     * @param string $sql
     *
     * @return mixed
     */
    public static function getScalar(string $sql)
    {
        $sentence = self::_exec($sql);

        $result = $sentence->fetch(PDO::FETCH_NUM);
        $sentence->closeCursor();

        return !empty($result) ? $result[0] : null;
    }

    /**
     * Ejecuta sentencias SQL para Crear, update o delete
     * Retorna la cantidad de filas afectadas con la consulta
     * @param string $sql
     * @param array $parameters
     *
     * @return int
     */
    private static function execute(string $sql, array $parameters = null)
    {

        $sentence = self::_exec($sql, $parameters);

        $affectedRows = $sentence->rowCount();

        return $affectedRows;
    }

    /**
     * Genera y ejecuta SQL para agregar un registro en la tabla indicada
     * Retorna último ID insertado
     * @param string $table_name
     * @param array $data
     *
     * @return string
     */
    public static function insert(string $table_name, array $data)
    {
        $attributes = '';
        $values = '';
        $parameters = [];

        foreach ($data as $key => $value) {
            $attributes .= $key . ',';
            $values .= ':' . $key . ',';
            $parameters[':' . $key] = $value;
        }

        $attributes = str_replace(',,', '', $attributes . ',');
        $values = str_replace(',,', '', $values . ',');

        $sql = "INSERT INTO " . $table_name . " (" . $attributes . ") ";
        $sql .= " VALUES (" . $values . ")";

        self::execute($sql, $parameters);

        return self::$_connection->lastInsertId();
    }

    /**
     * Genera y ejecuta SQL para actualizar uno o más registros en la tabla indicada
     * Retorna cantidad de filas afectadas
     * @param string $table_name
     * @param array $data
     * @param string $condition
     *
     * @return int
     */
    public static function update(string $table_name, array $data, string $condition = null)
    {
        $values = '';

        $parameters = [];

        foreach ($data as $key => $value) {
            $values .= "$key = :$key,";
            $parameters[':' . $key] = $value;
        }

        $values = str_replace(',,', '', $values . ',');

        $sql = "UPDATE " . $table_name;
        $sql .= " SET " . $values . " ";

        if (!empty($condition)) {
            $sql .= $condition;
        }

        return self::execute($sql, $parameters);
    }

    /**
     * Genera y ejecuta SQL para eliminar uno o más registro en la tabla indicada
     * Retorna cantidad de filas afectadas
     * @param string $table_name
     * @param string $condition
     * @param array $parameters
     *
     * @return int
     */
    public static function delete(string $table_name, string $condition, array $parameters = null)
    {
        $sql = "DELETE FROM " . $table_name . " " . $condition;

        return self::execute($sql, $parameters);
    }


    /**
     * Permite cerrar la conexión a la base de datos
     */
    private static function _closeConnection()
    {
        self::$_connection = null;
    }


    /**
     * Inicia una transacción en caso de requerirla
     */
    public static function beginTransaction()
    {
        self::$_connection->beginTransaction();
    }


    /**
     * Acepta los cambios realizados dentro de la transacción
     */
    public static function commit()
    {
        self::$_connection->commit();
    }


    /**
     * Rechaza los cambios realizados dentro de la transacción
     */
    public static function rollback()
    {
        self::$_connection->rollback();
    }


    /**
     * Cierra la conexión una vez que el objeto sale de memoria
     */
    public function __destruct()
    {
        self::_closeConnection();
    }

}


1			<?php
2
3			namespace Pin\Libs;
4			use PDO;
5			use Exception;
6
7			/**
8			* Db
9			* Clase para la gestión de acceso a la base de datos
10			* y operaciones CRUD: Crear, Leer, update y Borrar
11			* @author nelson rojas
12			*/
13			class Db
14			{
15			/**
16			* Base de datos a la que se conecta
17			*
18			* @var PDO
19			*/
20			private static $_connection = null;
21
22
23			/**
24			* Sirve para conectarse a la base de datos
25			* usando los parámetros de la clase Configuracion
26			* @throws Exception
27			*/
28			private static function connect()
29			{
30
31			if (isset(self::$_connection)) {
32			return TRUE;
33			}
34
35			$db_config = Config::getDbConfig();
36
37			try {
38			self::$_connection = new PDO(
39			$db_config['dsn'],
40			$db_config['user'],
41			$db_config['password'],
42			$db_config['parameters']
43			);
44			return TRUE;
45			} catch (Exception $e) {
46			throw new Exception($e->getMessage());
47			}
48			}
49
50			/**
51			* Permite reutilizar sentencias para la ejecución de
52			* consultas parametrizadas
53			*/
54			private static function _exec(string $sql, array $parameters = null)
55			{
56			self::connect();
57
58			$sentence = self::$_connection->prepare($sql);
59			if (is_array($parameters)) {
60			$sentence->execute($parameters);
61			} else {
62			$sentence->execute();
63			}
64			return $sentence;
65			}
66
67			/**
68			* Obtiene filas (registros) desde la base de datos como array
69			* @param string $sql
70			* @param array $parameters
71			*
72			* @return array
73			*/
74			public static function findAll(string $sql, array $parameters = null)
75			{
76
77			$sentence = self::_exec($sql, $parameters);
78
79			$rows = $sentence->fetchAll(PDO::FETCH_ASSOC);
80			$sentence->closeCursor();
81
82			return $rows;
83			}
84
85			/**
86			* Obtiene una fila (registro) desde la base de datos como array
87			* @param string $sql
88			* @param array $parameters
89			*
90			* @return array
91			*/
92			public static function findFirst(string $sql, array $parameters = null)
93			{
94			$rows = self::findAll($sql, $parameters);
95			if (isset($rows) && count($rows) > 0) {
96			return $rows[0];
97			} else {
98			return null;
99			}
100			}
101
102			/**
103			* Obtiene un escalar (valor) desde la base de datos
104			* @param string $sql
105			*
106			* @return mixed
107			*/
108			public static function getScalar(string $sql)
109			{
110			$sentence = self::_exec($sql);
111
112			$result = $sentence->fetch(PDO::FETCH_NUM);
113			$sentence->closeCursor();
114
115			return !empty($result) ? $result[0] : null;
116			}
117
118			/**
119			* Ejecuta sentencias SQL para Crear, update o delete
120			* Retorna la cantidad de filas afectadas con la consulta
121			* @param string $sql
122			* @param array $parameters
123			*
124			* @return int
125			*/
126			private static function execute(string $sql, array $parameters = null)
127			{
128
129			$sentence = self::_exec($sql, $parameters);
130
131			$affectedRows = $sentence->rowCount();
132
133			return $affectedRows;
134			}
135
136			/**
137			* Genera y ejecuta SQL para agregar un registro en la tabla indicada
138			* Retorna último ID insertado
139			* @param string $table_name
140			* @param array $data
141			*
142			* @return string
143			*/
144			public static function insert(string $table_name, array $data)
145			{
146			$attributes = '';
147			$values = '';
148			$parameters = [];
149
150			foreach ($data as $key => $value) {
151			$attributes .= $key . ',';
152			$values .= ':' . $key . ',';
153			$parameters[':' . $key] = $value;
154			}
155
156			$attributes = str_replace(',,', '', $attributes . ',');
157			$values = str_replace(',,', '', $values . ',');
158
159			$sql = "INSERT INTO " . $table_name . " (" . $attributes . ") ";
160			$sql .= " VALUES (" . $values . ")";
161
162			self::execute($sql, $parameters);
163
164			return self::$_connection->lastInsertId();
165			}
166
167			/**
168			* Genera y ejecuta SQL para actualizar uno o más registros en la tabla indicada
169			* Retorna cantidad de filas afectadas
170			* @param string $table_name
171			* @param array $data
172			* @param string $condition
173			*
174			* @return int
175			*/
176			public static function update(string $table_name, array $data, string $condition = null)
177			{
178			$values = '';
179
180			$parameters = [];
181
182			foreach ($data as $key => $value) {
183			$values .= "$key = :$key,";
184			$parameters[':' . $key] = $value;
185			}
186
187			$values = str_replace(',,', '', $values . ',');
188
189			$sql = "UPDATE " . $table_name;
190			$sql .= " SET " . $values . " ";
191
192			if (!empty($condition)) {
193			$sql .= $condition;
194			}
195
196			return self::execute($sql, $parameters);
197			}
198
199			/**
200			* Genera y ejecuta SQL para eliminar uno o más registro en la tabla indicada
201			* Retorna cantidad de filas afectadas
202			* @param string $table_name
203			* @param string $condition
204			* @param array $parameters
205			*
206			* @return int
207			*/
208			public static function delete(string $table_name, string $condition, array $parameters = null)
209			{
210			$sql = "DELETE FROM " . $table_name . " " . $condition;
211
212			return self::execute($sql, $parameters);
213			}
214
215
216			/**
217			* Permite cerrar la conexión a la base de datos
218			*/
219			private static function _closeConnection()
220			{
221			self::$_connection = null;
222			}
223
224
225			/**
226			* Inicia una transacción en caso de requerirla
227			*/
228			public static function beginTransaction()
229			{
230			self::$_connection->beginTransaction();
231			}
232
233
234			/**
235			* Acepta los cambios realizados dentro de la transacción
236			*/
237			public static function commit()
238			{
239			self::$_connection->commit();
240			}
241
242
243			/**
244			* Rechaza los cambios realizados dentro de la transacción
245			*/
246			public static function rollback()
247			{
248			self::$_connection->rollback();
249			}
250
251
252			/**
253			* Cierra la conexión una vez que el objeto sale de memoria
254			*/
255			public function __destruct()
256			{
257			self::_closeConnection();
258			}
259
260			}
261

nelsonrojasn / pin

Push — main ( 166306...644851 )

Db A

Complexity

Size/Duplication

Importance

14 Methods

Duplication Side-by-Side

Filter issues like