Db::connect() - Code Metrics - nelsonrojasn/pin - Measure and Improve Code Quality continuously with Scrutinizer

Db::connect() A
last analyzed 2025-12-08 21:20 UTC

↳ Parent: Db

Complexity

Conditions	3
Paths	3

Size

Total Lines	19
Code Lines	12

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	3
eloc	12
nc	3
nop	0
dl	0
loc	19
rs	9.8666
c	0
b	0
f	0

<?php

namespace Pin\Libs;
use PDO;
use Exception;
use Pin\Libs\Config;

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

nelsonrojasn / pin

Db::connect() A last analyzed 2025-12-08 21:20 UTC

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like

Db::connect() A
last analyzed 2025-12-08 21:20 UTC