SqlActions::closeCursor() - Code Metrics - Inspection of "Fix Call to undefined method BFWSql\SqlSelect::clo..." - bulton-fr/bfw-sql - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — 1.0 ( f5d42a...8b4e74 )

by Vermeulen

created 2016-05-12 11:14 UTC

SqlActions::closeCursor() A

↳ Parent: SqlActions

Complexity

Conditions	1
Paths	1

Size

Total Lines	4
Code Lines	2

Duplication

Lines	0
Ratio	0 %

Importance

Changes	1
Bugs	1	Features	0

Metric	Value
cc	1
eloc	2
c	1
b	1
f	0
nc	1
nop	0
dl	0
loc	4
rs	10

<?php
/**
 * Classes en rapport avec les sgdb
 * @author Vermeulen Maxime <[email protected]>
 * @version 1.0
 */

namespace BFWSql;

use \Exception;

/**
 * Classe parent aux classes Sql_Select, Sql_Insert, Sql_Update et Sql_Delete
 * Elle stock l'instance de pdo et définie quelques méthodes.
 * @package bfw-sql
 */
abstract class SqlActions implements \BFWSqlInterface\ISqlActions
{
    /**
     * @var $_kernel L'instance du Kernel
     */
    protected $_kernel;
    
    /**
     * @var $_sql L'instance de l'objet Sql
     */
    protected $_sql;
    
    /**
     * @var $PDO L'instance de pdo
     */
    protected $PDO;
    
    /**
     * @var $RequeteAssembler La requête final qui sera exécutée
     */
    protected $RequeteAssembler = '';
    
    /**
     * @var $modeleName Le nom de la table du modele
     */
    protected $modeleName = null;
    
    /**
     * @var $prefix Le préfix des tables
     */
    protected $prefix;
    
    /**
     * @var $prepare Permet de savoir si on utilise les requêtes préparées ou non
     */
    protected $prepareBool = true;
    
    /**
     * @var $table La table sur laquel agir
     */
    protected $table = '';
    
    /**
     * @var $champs Les données à insérer
     */
    protected $champs = array();
    
    /**
     * @var $where Les clauses where
     */
    protected $where = array();
    
    /**
     * @var $prepare Les arguments de la requête préparée
     */
    protected $prepare = array();
    
    /**
     * @var $prepare_option Les options pour la requête préparée
     */
    protected $prepare_option = array();
    
    /**
     * @var bool $no_result Permet de savoir si l'echec est du Ã  la requÃªte qui n'a rien renvoyÃ© ou une erreur
     */
    protected $no_result = false;
    
    /**
     * Constructeur de la classe
     * 
     * @param Sql $Sql : (ref) Instance de la classe Sql
     */
    public function __construct(Sql &$Sql)
    {
        $this->_sql = $Sql;
        $this->PDO  = $this->_sql->getPDO();
        
        $this->_kernel = getKernel();
        
        $this->prefix     = $Sql->getPrefix();;
        $this->modeleName = $Sql->getModeleName();
    }
    
    /**
     * Getter magique
     */
    public function __get($name)
    {
        return $this->$name;
    }
    
    /**
     * Permet de vérifier si la requête finale a été assemblé et si ce n'est pas le cas de lancer l'assemblage.
     * 
     * @return void
     */
    public function is_Assembler()
    {
        if($this->RequeteAssembler == '')
        {
            $this->assembler_requete();

        }
    }
    
    /**
     * Retourne la requête finale
     * 
     * @return string
     */
    public function assemble()
    {
        $this->is_Assembler();
        return $this->RequeteAssembler;
    }
    
    /**
     * Execute la requête (type INSERT, UPDATE et DELETE)
     * 
     * @throws \Exception Si la requête à echoué
     * 
     * @return \PDOStatement|integer|bool : La ressource de la requête exécuté si elle a réussi, false sinon.
     */
    public function execute()
    {
        $this->_sql->upNbQuery();
        $this->is_Assembler(); //On vérifie que la requête est bien généré
        
        //Gestion si c'est une requête préparé
        if($this->prepareBool)
        {
            //Prépare et exécute la requête.
            $req = $this->PDO->prepare($this->RequeteAssembler, $this->prepare_option);
            $req->execute($this->prepare);
            $erreur = $req->errorInfo();
        }
        else //Requête "normal"
        {
            //On exécute la requête
            $methodExecuted = 'exec';
            if(get_class($this) == '\BFWSql\SqlSelect') {$methodExecuted = 'query';}
            
            $req = $this->PDO->{$methodExecuted}($this->RequeteAssembler);
            
            //Récupération d'une éventuelle erreur
            $erreur = $this->PDO->errorInfo();
        }
        $this->req = $req;
class MyClass { }

$x = new MyClass();
$x->foo = true;
        
        //S'il y a une erreur, on génère une exception.
        if($erreur[0] != null && $erreur[0] != '00000')
        {
            throw new \Exception($erreur[2]);
        }
        else
        {
            //Si la requête à réussi, on retourne sa ressource
            if($req)
            {
                //On vérifie le nombre de résultat. S'il y a des résultat, on retourne la requête
                if($this->nb_result() > 0) {return $req;}
                else {$this->no_result = true;} //Si pas de résultat, on ne note
            }
        }
        
        //Retourne false si fail ou si pas de résultat.
        return false;
    }
    
    /**
     * Ferme le curseur, permettant à la requête d'être de nouveau exécutée
     * 
     * @see http://php.net/manual/fr/pdostatement.closecursor.php
     * 
     * @return void
     */
    public function closeCursor()
    {
        return $this->req->closeCursor();
    }
    
    /**
     * Retourne le nombre de ligne retourner par la requête
     * 
     * @return int|bool le nombre de ligne. false si ça a échoué.
     */
    public function nb_result()
    {
        //Si la requête n'a pas fail, on retourne directement le nombre de ligne
            if($this->req != false && is_object($this->req)) {return $this->req->rowCount();}
        elseif(is_integer($this->req)) {return $this->req;} //Si pdo->exec()
        else {return false;} //Fail : retourne false.
    }
    
    /**
     * Permet d'inserer sa propre requête directement sans avoir à utiliser les méthodes from etc
     * 
     * @param string $req La requête
     * 
     * @return void
     */
    public function query($req)
    {
        $this->RequeteAssembler = $req;
    }
    
    /**
     * Permet d'indiquer qu'on ne veux pas utiliser de requête préparée.
     */
    public function no_prepare()
    {
        $this->prepareBool = false;
    }
    
    /**
     * Définie les options pour la requête préparée
     * 
     * @param array $option Les options
     * 
     * @return void
     */
    public function set_prepare_option($option)
    {
        $this->prepare_option = $option;
    }
    
    /**
     * Permet d'ajouter une clause where à la requête
     * 
     * @param string     $cond    La condition du where
     * @param arrya|null $prepare (default: null) Les infos pour la requête préparé
     * 
     * @throws \Exception : Si la clé utilisé sur la requête préparé est déjà utilisé.
     * 
     * @return \BFWSql\SqlActions L'instance de l'objet courant.
     */
    public function where($cond, $prepare=null)
    {
        $this->where[] = $cond;
        if(func_num_args() > 1 && is_array($prepare))
        {
            foreach($prepare as $key => $val)

            {
                if(isset($this->prepare[$key]) && $this->prepare[$key] != $val)
                {
                    throw new \Exception('La clé '.$key.' pour la requête sql préparé est déjà utilisé avec une autre valeur.');
                }
                else
                {
                    $this->prepare[$key] = $val;
                }
            }
        }
        
        return $this;
    }
    
    /**
     * Permet de générer une clause where dans les requêtes
     * 
     * @return string : La clause where finale
     */
    protected function generateWhere()
    {
        $where = '';
        if(count($this->where) > 0) //S'il y a une partie where à faire
        {
            $where = ' WHERE ';
            //Boucle sur les conditions
            foreach($this->where as $val)
            {
                //S'il y a déjà une condition, on rajoute le AND
                if($where != ' WHERE ') {$where .= ' AND ';}
                $where .= $val;
            } 
        }
        
        return $where;
    }
    
    /**
     * Permet d'ajouter d'autres données à ajouter
     * 
     * @param array $champs Les données à ajouter : array('champSql' => 'données');
     * 
     * @return \BFWSql\SqlActions L'instance de l'objet courant.
     */
    public function addChamps($champs)
    {
        //Pour chaque champs
        foreach($champs as $column => $data)

        {
            //Vérifie que le champ n'est pas déjà modifié
            if(isset($this->champs[$column]) && $this->champs[$column] != $data)
            {
                throw new \Exception('Une valeur pour la colonne '.$column.' est déjà déclaré.');
            }
            
            //On ajoute à la liste des champs à modifier.
            $this->champs[$column] = $data;
        }
        
        return $this;
    }
    
    /**
     * Permet d'appeler l'observeur d'événement
     * 
     * @param array|null $params : (default: null) Permet d'ajouter des infos à passer au notifier
     * 
     * @return void
     */
    protected function callObserver($params=null)
    {
        $paramsNotifier = array(
            'value' => 'REQ_SQL',
            'REQ_SQL' => $this->RequeteAssembler,
            'instance' => $this
        );
        
        if($params !== null)
        {
            $paramsNotifier = array_merge($params, $paramsNotifier);
        }
        
        $this->_kernel->notifyObserver($paramsNotifier);
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
    }
}
?>


1		<?php
2		/**
3		* Classes en rapport avec les sgdb
4		* @author Vermeulen Maxime <[email protected]>
5		* @version 1.0
6		*/
7
8		namespace BFWSql;
9
10		use \Exception;
11
12		/**
13		* Classe parent aux classes Sql_Select, Sql_Insert, Sql_Update et Sql_Delete
14		* Elle stock l'instance de pdo et définie quelques méthodes.
15		* @package bfw-sql
16		*/
17		abstract class SqlActions implements \BFWSqlInterface\ISqlActions
18		{
19		/**
20		* @var $_kernel L'instance du Kernel
21		*/
22		protected $_kernel;
23
24		/**
25		* @var $_sql L'instance de l'objet Sql
26		*/
27		protected $_sql;
28
29		/**
30		* @var $PDO L'instance de pdo
31		*/
32		protected $PDO;
33
34		/**
35		* @var $RequeteAssembler La requête final qui sera exécutée
36		*/
37		protected $RequeteAssembler = '';
38
39		/**
40		* @var $modeleName Le nom de la table du modele
41		*/
42		protected $modeleName = null;
43
44		/**
45		* @var $prefix Le préfix des tables
46		*/
47		protected $prefix;
48
49		/**
50		* @var $prepare Permet de savoir si on utilise les requêtes préparées ou non
51		*/
52		protected $prepareBool = true;
53
54		/**
55		* @var $table La table sur laquel agir
56		*/
57		protected $table = '';
58
59		/**
60		* @var $champs Les données à insérer
61		*/
62		protected $champs = array();
63
64		/**
65		* @var $where Les clauses where
66		*/
67		protected $where = array();
68
69		/**
70		* @var $prepare Les arguments de la requête préparée
71		*/
72		protected $prepare = array();
73
74		/**
75		* @var $prepare_option Les options pour la requête préparée
76		*/
77		protected $prepare_option = array();
78
79		/**
80		* @var bool $no_result Permet de savoir si l'echec est du Ã la requÃªte qui n'a rien renvoyÃ© ou une erreur
81		*/
82		protected $no_result = false;
83
84		/**
85		* Constructeur de la classe
86		*
87		* @param Sql $Sql : (ref) Instance de la classe Sql
88		*/
89		public function __construct(Sql &$Sql)
90		{
91		$this->_sql = $Sql;
92		$this->PDO = $this->_sql->getPDO();
93
94		$this->_kernel = getKernel();
95
96		$this->prefix = $Sql->getPrefix();;
97		$this->modeleName = $Sql->getModeleName();
98		}
99
100		/**
101		* Getter magique
102		*/
103		public function __get($name)
104		{
105		return $this->$name;
106		}
107
108		/**
109		* Permet de vérifier si la requête finale a été assemblé et si ce n'est pas le cas de lancer l'assemblage.
110		*
111		* @return void
112		*/
113		public function is_Assembler()
114		{
115		if($this->RequeteAssembler == '')
116		{
117		$this->assembler_requete();
		0 ignored issues – show Bug introduced 2016-03-27 13:38 UTC by Report Bug Copy Issue Report The method `assembler_requete()` does not exist on `BFWSql\SqlActions`. Did you maybe mean `assemble()`? This check marks calls to methods that do not seem to exist on an object. This is most likely the result of a method being renamed without all references to it being renamed likewise. Loading history...
118		}
119		}
120
121		/**
122		* Retourne la requête finale
123		*
124		* @return string
125		*/
126		public function assemble()
127		{
128		$this->is_Assembler();
129		return $this->RequeteAssembler;
130		}
131
132		/**
133		* Execute la requête (type INSERT, UPDATE et DELETE)
134		*
135		* @throws \Exception Si la requête à echoué
136		*
137		* @return \PDOStatement\|integer\|bool : La ressource de la requête exécuté si elle a réussi, false sinon.
138		*/
139		public function execute()
140		{
141		$this->_sql->upNbQuery();
142		$this->is_Assembler(); //On vérifie que la requête est bien généré
143
144		//Gestion si c'est une requête préparé
145		if($this->prepareBool)
146		{
147		//Prépare et exécute la requête.
148		$req = $this->PDO->prepare($this->RequeteAssembler, $this->prepare_option);
149		$req->execute($this->prepare);
150		$erreur = $req->errorInfo();
151		}
152		else //Requête "normal"
153		{
154		//On exécute la requête
155		$methodExecuted = 'exec';
156		if(get_class($this) == '\BFWSql\SqlSelect') {$methodExecuted = 'query';}
157
158		$req = $this->PDO->{$methodExecuted}($this->RequeteAssembler);
159
160		//Récupération d'une éventuelle erreur
161		$erreur = $this->PDO->errorInfo();
162		}
163		$this->req = $req;
		0 ignored issues – show Bug introduced 2016-03-27 13:38 UTC by Report Bug Copy Issue Report The property `req` does not exist. Did you maybe forget to declare it? In PHP it is possible to write to properties without declaring them. For example, the following is perfectly valid PHP code: class MyClass { } $x = new MyClass(); $x->foo = true; Generally, it is a good practice to explictly declare properties to avoid accidental typos and provide IDE auto-completion: class MyClass { public $foo; } $x = new MyClass(); $x->foo = true; Loading history...
164
165		//S'il y a une erreur, on génère une exception.
166		if($erreur[0] != null && $erreur[0] != '00000')
167		{
168		throw new \Exception($erreur[2]);
169		}
170		else
171		{
172		//Si la requête à réussi, on retourne sa ressource
173		if($req)
174		{
175		//On vérifie le nombre de résultat. S'il y a des résultat, on retourne la requête
176		if($this->nb_result() > 0) {return $req;}
177		else {$this->no_result = true;} //Si pas de résultat, on ne note
178		}
179		}
180
181		//Retourne false si fail ou si pas de résultat.
182		return false;
183		}
184
185		/**
186		* Ferme le curseur, permettant à la requête d'être de nouveau exécutée
187		*
188		* @see http://php.net/manual/fr/pdostatement.closecursor.php
189		*
190		* @return void
191		*/
192		public function closeCursor()
193		{
194		return $this->req->closeCursor();
195		}
196
197		/**
198		* Retourne le nombre de ligne retourner par la requête
199		*
200		* @return int\|bool le nombre de ligne. false si ça a échoué.
201		*/
202		public function nb_result()
203		{
204		//Si la requête n'a pas fail, on retourne directement le nombre de ligne
205		if($this->req != false && is_object($this->req)) {return $this->req->rowCount();}
206		elseif(is_integer($this->req)) {return $this->req;} //Si pdo->exec()
207		else {return false;} //Fail : retourne false.
208		}
209
210		/**
211		* Permet d'inserer sa propre requête directement sans avoir à utiliser les méthodes from etc
212		*
213		* @param string $req La requête
214		*
215		* @return void
216		*/
217		public function query($req)
218		{
219		$this->RequeteAssembler = $req;
220		}
221
222		/**
223		* Permet d'indiquer qu'on ne veux pas utiliser de requête préparée.
224		*/
225		public function no_prepare()
226		{
227		$this->prepareBool = false;
228		}
229
230		/**
231		* Définie les options pour la requête préparée
232		*
233		* @param array $option Les options
234		*
235		* @return void
236		*/
237		public function set_prepare_option($option)
238		{
239		$this->prepare_option = $option;
240		}
241
242		/**
243		* Permet d'ajouter une clause where à la requête
244		*
245		* @param string $cond La condition du where
246		* @param arrya\|null $prepare (default: null) Les infos pour la requête préparé
247		*
248		* @throws \Exception : Si la clé utilisé sur la requête préparé est déjà utilisé.
249		*
250		* @return \BFWSql\SqlActions L'instance de l'objet courant.
251		*/
252		public function where($cond, $prepare=null)
253		{
254		$this->where[] = $cond;
255		if(func_num_args() > 1 && is_array($prepare))
256		{
257	View Code Duplication	foreach($prepare as $key => $val)
		0 ignored issues – show Duplication introduced 2016-03-27 13:38 UTC by Report Bug Copy Issue Report This code seems to be duplicated across your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
258		{
259		if(isset($this->prepare[$key]) && $this->prepare[$key] != $val)
260		{
261		throw new \Exception('La clé '.$key.' pour la requête sql préparé est déjà utilisé avec une autre valeur.');
262		}
263		else
264		{
265		$this->prepare[$key] = $val;
266		}
267		}
268		}
269
270		return $this;
271		}
272
273		/**
274		* Permet de générer une clause where dans les requêtes
275		*
276		* @return string : La clause where finale
277		*/
278		protected function generateWhere()
279		{
280		$where = '';
281		if(count($this->where) > 0) //S'il y a une partie where à faire
282		{
283		$where = ' WHERE ';
284		//Boucle sur les conditions
285		foreach($this->where as $val)
286		{
287		//S'il y a déjà une condition, on rajoute le AND
288		if($where != ' WHERE ') {$where .= ' AND ';}
289		$where .= $val;
290		}
291		}
292
293		return $where;
294		}
295
296		/**
297		* Permet d'ajouter d'autres données à ajouter
298		*
299		* @param array $champs Les données à ajouter : array('champSql' => 'données');
300		*
301		* @return \BFWSql\SqlActions L'instance de l'objet courant.
302		*/
303		public function addChamps($champs)
304		{
305		//Pour chaque champs
306	View Code Duplication	foreach($champs as $column => $data)
		0 ignored issues – show Duplication introduced 2016-03-27 13:38 UTC by Report Bug Copy Issue Report This code seems to be duplicated across your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
307		{
308		//Vérifie que le champ n'est pas déjà modifié
309		if(isset($this->champs[$column]) && $this->champs[$column] != $data)
310		{
311		throw new \Exception('Une valeur pour la colonne '.$column.' est déjà déclaré.');
312		}
313
314		//On ajoute à la liste des champs à modifier.
315		$this->champs[$column] = $data;
316		}
317
318		return $this;
319		}
320
321		/**
322		* Permet d'appeler l'observeur d'événement
323		*
324		* @param array\|null $params : (default: null) Permet d'ajouter des infos à passer au notifier
325		*
326		* @return void
327		*/
328		protected function callObserver($params=null)
329		{
330		$paramsNotifier = array(
331		'value' => 'REQ_SQL',
332		'REQ_SQL' => $this->RequeteAssembler,
333		'instance' => $this
334		);
335
336		if($params !== null)
337		{
338		$paramsNotifier = array_merge($params, $paramsNotifier);
339		}
340
341		$this->_kernel->notifyObserver($paramsNotifier);
		0 ignored issues – show Documentation introduced 2016-03-27 13:38 UTC by Report Bug Copy Issue Report `$paramsNotifier` is of type `array`, but the function expects a `string`. It seems like the type of the argument is not accepted by the function/method which you are calling. In some cases, in particular if PHP’s automatic type-juggling kicks in this might be fine. In other cases, however this might be a bug. We suggest to add an explicit type cast like in the following example: function acceptsInteger($int) { } $x = '123'; // string "123" // Instead of acceptsInteger($x); // we recommend to use acceptsInteger((integer) $x); Loading history...
342		}
343		}
344		?>
		0 ignored issues – show Best Practice introduced 2016-03-27 13:38 UTC by Report Bug Copy Issue Report It is not recommended to use PHP's closing tag `?>` in files other than templates. Using a closing tag in PHP files that only contain PHP code is not recommended as you might accidentally add whitespace after the closing tag which would then be output by PHP. This can cause severe problems, for example headers cannot be sent anymore. A simple precaution is to leave off the closing tag as it is not required, and it also has no negative effects whatsoever. Loading history...

bulton-fr / bfw-sql

Push — 1.0 ( f5d42a...8b4e74 )

SqlActions::closeCursor() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like