Db - Code Metrics - nelsonrojasn/pin - Measure and Improve Code Quality continuously with Scrutinizer

Db A
last analyzed 2024-11-12 22:56 UTC

↳ Parent: Project

Complexity

Total Complexity

Size/Duplication

Total Lines	245
Duplicated Lines	0 %

Importance

Changes

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

14 Methods

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

<?php

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

nelsonrojasn / pin

Db A last analyzed 2024-11-12 22:56 UTC

Complexity

Size/Duplication

Importance

14 Methods

Duplication Side-by-Side

Filter issues like

Db A
last analyzed 2024-11-12 22:56 UTC