DatabaseQuery::insertQuery() - Code Metrics - Inspection of "Merge pull request #13 from andela-iadeniyi/1.0.0" - andela-iadeniyi/Potato-ORM - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( e30db1...245fbf )

by Adeniyi

created 2015-11-25 08:15 UTC

DatabaseQuery::insertQuery() A

↳ Parent: DatabaseQuery

Complexity

Conditions	1
Paths	1

Size

Total Lines	11
Code Lines	7

Duplication

Lines	0
Ratio	0 %

Importance

Changes	2
Bugs	0	Features	0

Metric	Value
c	2
b	0
f	0
dl	0
loc	11
rs	9.4286
cc	1
eloc	7
nc	1
nop	1

<?php
/**
 * This class handles building sql query statement and check
 * that the table exist in the database.
 *
 * @package Ibonly\PotatoORM\DatabaseQuery
 * @author  Ibraheem ADENIYI <[email protected]>
 * @license MIT <https://opensource.org/licenses/MIT>
 */

namespace Ibonly\PotatoORM;

use PDOException;
use Ibonly\PotatoORM\DatabaseQueryInterface;
use Ibonly\PotatoORM\ColumnNotExistExeption;
use Ibonly\PotatoORM\InvalidConnectionException;
use Ibonly\PotatoORM\TableDoesNotExistException;

class DatabaseQuery implements DatabaseQueryInterface
{
    /**
     * connect Setup database connection
     */
    protected static function connect()
    {
        return new DBConfig();
    }

    /**
     * sanitize(argument) Removes unwanted characters
     *
     * @param  $value
     *
     * @return  string
     */
    protected static function sanitize($value)
    {
        $value = trim($value);
        $value = htmlentities($value);
        return $value;
    }

    /**
     * checkConnection
     *
     * @param  $con
     *
     * @return string
     */
    protected static function checkConnection($con)
    {
        if( is_null($con) )
        {
            $con = self::connect();
        }
        return $con;
    }

    /**
     * checkTableExist Check if table already in the database
     *
     * @param  $tablename
     * @param  $con
     *
     * @return bool
     */
    public function checkTableExist($table, $con=NULL)

    {
        $connection = $this->checkConnection($con);
        $query = $connection->query("SELECT 1 FROM {$table} LIMIT 1");

        if( $query !== false )
        {
            return true;
        }
    }

    /**
     * checkTableName Return the table name
     *
     * @param  $tablename
     * @param  $con
     *
     * @return string
     */
    public static function checkTableName($tableName, $con=NULL)

    {
        $connection = self::checkConnection($con);
        // if( ! is_null($connection) )

        // {
            $query = $connection->query("SELECT 1 FROM {$tableName} LIMIT 1");

            if( $query !== false )
            {
                return $tableName;
            }
            throw new TableDoesNotExistException();
        // }
        // throw new InvalidConnectionException();

    }

    /**
     * checkColumn Check if column exist in table
     *
     * @param  $tableName
     * @param  $columnName
     * @param  $con
     *
     * @return string
     */
    protected static function checkColumn($tableName, $columnName, $con=NULL)
    {
        $connection = self::checkConnection($con);

            $result = $connection->prepare("SELECT {$columnName} FROM {$tableName}");

            $result->execute();
            if ( ! $result->columnCount() )
            {
                throw new ColumnNotExistExeption();
            }
            return $columnName;
    }

    /**
     * buildColumn  Build the column name
     *
     * @param  $data
     *
     * @return string
     */
    public static function buildColumn($data)

    {
        $counter = 0;
        $insertQuery = "";
        $arraySize = sizeof($data);

        foreach ( $data as $key => $value )
        {
            $counter++;
            $insertQuery .= self::sanitize($key);
            if( $arraySize > $counter )
                $insertQuery .= ", ";
        }
        return $insertQuery;
    }

    /**
     * buildValues  Build the column values
     *
     * @param  $data
     *
     * @return string
     */
    public static function buildValues($data)

    {
        $counter = 0;
        $insertQuery = "";
        $arraySize = sizeof($data);

        foreach ( $data as $key => $value )
        {
            $counter++;
            $insertQuery .= "'".self::sanitize($value) ."'";
            if( $arraySize > $counter )
                $insertQuery .= ", ";
        }
        return $insertQuery;
    }

    /**
     * buildClause  Build the clause value
     *
     * @param  $data
     *
     * @return string
     */
    protected static function buildClause($tableName, $data)

    {
        $counter = 0;
        $updateQuery = "";
        $arraySize = sizeof($data);

        foreach ( $data as $key => $value )
        {
            $counter++;
            $columnName = self::checkColumn($tableName, self::sanitize($key));
            $updateQuery .= $columnName ." = '".self::sanitize($value)."'";
            if ( $arraySize > $counter )
            {
                $updateQuery .= ", ";
            }
        }
        return $updateQuery;
    }

    /**
     * selectAllQuery
     *
     * @return string
     */
    public static function selectAllQuery($tableName)
    {
        return "SELECT * FROM {$tableName}";
    }

    /**
     * whereAndClause
     *
     * @return string
     */
    public static function whereAndClause($tableName, $data, $condition)

    {
        $where = "";
        $counter = 0;
        $arraySize = sizeof($data);

        foreach ( $data as $key => $value )
        {
            $counter++;
            $columnName = self::checkColumn($tableName, self::sanitize($key));
            $where .= $columnName ." = '".self::sanitize($value)."'";
            if ( $arraySize > $counter )
            {
                $where .= " " . $condition . " ";
            }
        }

        return $where;
    }

    /**
     * selectQuery
     *
     * @return string
     */
    public static function selectQuery($tableName, $data, $condition, $connection)
    {
        $query = "";
$myVar = 'Value';
$higher = false;

if (rand(1, 6) > 3) {
    $higher = true;
} else {
    $higher = false;
}
        try
        {
            $arraySize = sizeof($data);
            if( $arraySize > 1 && $condition == NULL)
            {
                $query = "Please Supply the condition";
            }
            else
            {
                $columnName = self::whereAndClause($tableName, $data, $condition);
                $query =  "SELECT * FROM $tableName WHERE $columnName";
            }
        } catch ( PDOException $e ) {
            $query = $e->getMessage();
        }

        return $query;
    }

    /**
     * insertQuery
     *
     * @return string
     */
    public function insertQuery($tableName)
    {
        $data = ( array )$this;
        array_shift($data);

        $columnNames = self::buildColumn($data);
        $values = self::buildValues($data);
        $insertQuery = "INSERT INTO $tableName ({$columnNames}) VALUES ({$values})";

        return $insertQuery;
    }

    /**
     * updateQuery
     *
     * @return string
     */
    public function updateQuery($tableName)
    {
        $data = ( array ) $this;
        $data = array_slice ($data, 2);

        $values = self::buildClause($tableName, $data);
        $updateQuery = "UPDATE $tableName SET {$values} WHERE id = ". self::sanitize($this->id);
class MyClass { }

$x = new MyClass();
$x->foo = true;

        return $updateQuery;
    }
}

1		<?php
2		/**
3		* This class handles building sql query statement and check
4		* that the table exist in the database.
5		*
6		* @package Ibonly\PotatoORM\DatabaseQuery
7		* @author Ibraheem ADENIYI <[email protected]>
8		* @license MIT <https://opensource.org/licenses/MIT>
9		*/
10
11		namespace Ibonly\PotatoORM;
12
13		use PDOException;
14		use Ibonly\PotatoORM\DatabaseQueryInterface;
15		use Ibonly\PotatoORM\ColumnNotExistExeption;
16		use Ibonly\PotatoORM\InvalidConnectionException;
17		use Ibonly\PotatoORM\TableDoesNotExistException;
18
19		class DatabaseQuery implements DatabaseQueryInterface
20		{
21		/**
22		* connect Setup database connection
23		*/
24		protected static function connect()
25		{
26		return new DBConfig();
27		}
28
29		/**
30		* sanitize(argument) Removes unwanted characters
31		*
32		* @param $value
33		*
34		* @return string
35		*/
36		protected static function sanitize($value)
37		{
38		$value = trim($value);
39		$value = htmlentities($value);
40		return $value;
41		}
42
43		/**
44		* checkConnection
45		*
46		* @param $con
47		*
48		* @return string
49		*/
50		protected static function checkConnection($con)
51		{
52		if( is_null($con) )
53		{
54		$con = self::connect();
55		}
56		return $con;
57		}
58
59		/**
60		* checkTableExist Check if table already in the database
61		*
62		* @param $tablename
63		* @param $con
64		*
65		* @return bool
66		*/
67	View Code Duplication	public function checkTableExist($table, $con=NULL)
		0 ignored issues – show Duplication introduced 2015-11-22 09:13 UTC by Report Bug Copy Issue Report This method seems to be duplicated in 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...
68		{
69		$connection = $this->checkConnection($con);
70		$query = $connection->query("SELECT 1 FROM {$table} LIMIT 1");
		0 ignored issues – show Bug introduced 2015-11-22 09:13 UTC by Report Bug Copy Issue Report The method `query` cannot be called on `$connection` (of type `string`). Methods can only be called on objects. This check looks for methods being called on variables that have been inferred to never be objects. Loading history...
71		if( $query !== false )
72		{
73		return true;
74		}
75		}
76
77		/**
78		* checkTableName Return the table name
79		*
80		* @param $tablename
81		* @param $con
82		*
83		* @return string
84		*/
85	View Code Duplication	public static function checkTableName($tableName, $con=NULL)
		0 ignored issues – show Duplication introduced 2015-11-22 09:13 UTC by Report Bug Copy Issue Report This method seems to be duplicated in 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...
86		{
87		$connection = self::checkConnection($con);
88		// if( ! is_null($connection) )
		0 ignored issues – show Unused Code Comprehensibility introduced 2015-11-22 09:13 UTC by Report Bug Copy Issue Report `59%` of this comment could be valid code. Did you maybe forget this after debugging? Sometimes obsolete code just ends up commented out instead of removed. In this case it is better to remove the code once you have checked you do not need it. The code might also have been commented out for debugging purposes. In this case it is vital that someone uncomments it again or your project may behave in very unexpected ways in production. This check looks for comments that seem to be mostly valid code and reports them. Loading history...
89		// {
90		$query = $connection->query("SELECT 1 FROM {$tableName} LIMIT 1");
		0 ignored issues – show Bug introduced 2015-11-22 09:13 UTC by Report Bug Copy Issue Report The method `query` cannot be called on `$connection` (of type `string`). Methods can only be called on objects. This check looks for methods being called on variables that have been inferred to never be objects. Loading history...
91		if( $query !== false )
92		{
93		return $tableName;
94		}
95		throw new TableDoesNotExistException();
96		// }
97		// throw new InvalidConnectionException();
		0 ignored issues – show Unused Code Comprehensibility introduced 2015-11-22 09:13 UTC by Report Bug Copy Issue Report `56%` of this comment could be valid code. Did you maybe forget this after debugging? Sometimes obsolete code just ends up commented out instead of removed. In this case it is better to remove the code once you have checked you do not need it. The code might also have been commented out for debugging purposes. In this case it is vital that someone uncomments it again or your project may behave in very unexpected ways in production. This check looks for comments that seem to be mostly valid code and reports them. Loading history...
98		}
99
100		/**
101		* checkColumn Check if column exist in table
102		*
103		* @param $tableName
104		* @param $columnName
105		* @param $con
106		*
107		* @return string
108		*/
109		protected static function checkColumn($tableName, $columnName, $con=NULL)
110		{
111		$connection = self::checkConnection($con);
112
113		$result = $connection->prepare("SELECT {$columnName} FROM {$tableName}");
		0 ignored issues – show Bug introduced 2015-11-22 09:13 UTC by Report Bug Copy Issue Report The method `prepare` cannot be called on `$connection` (of type `string`). Methods can only be called on objects. This check looks for methods being called on variables that have been inferred to never be objects. Loading history...
114		$result->execute();
115		if ( ! $result->columnCount() )
116		{
117		throw new ColumnNotExistExeption();
118		}
119		return $columnName;
120		}
121
122		/**
123		* buildColumn Build the column name
124		*
125		* @param $data
126		*
127		* @return string
128		*/
129	View Code Duplication	public static function buildColumn($data)
		0 ignored issues – show Duplication introduced 2015-11-22 09:13 UTC by Report Bug Copy Issue Report This method seems to be duplicated in 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...
130		{
131		$counter = 0;
132		$insertQuery = "";
133		$arraySize = sizeof($data);
134
135		foreach ( $data as $key => $value )
136		{
137		$counter++;
138		$insertQuery .= self::sanitize($key);
139		if( $arraySize > $counter )
140		$insertQuery .= ", ";
141		}
142		return $insertQuery;
143		}
144
145		/**
146		* buildValues Build the column values
147		*
148		* @param $data
149		*
150		* @return string
151		*/
152	View Code Duplication	public static function buildValues($data)
		0 ignored issues – show Duplication introduced 2015-11-22 09:13 UTC by Report Bug Copy Issue Report This method seems to be duplicated in 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...
153		{
154		$counter = 0;
155		$insertQuery = "";
156		$arraySize = sizeof($data);
157
158		foreach ( $data as $key => $value )
159		{
160		$counter++;
161		$insertQuery .= "'".self::sanitize($value) ."'";
162		if( $arraySize > $counter )
163		$insertQuery .= ", ";
164		}
165		return $insertQuery;
166		}
167
168		/**
169		* buildClause Build the clause value
170		*
171		* @param $data
172		*
173		* @return string
174		*/
175	View Code Duplication	protected static function buildClause($tableName, $data)
		0 ignored issues – show Duplication introduced 2015-11-22 09:13 UTC by Report Bug Copy Issue Report This method seems to be duplicated in 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...
176		{
177		$counter = 0;
178		$updateQuery = "";
179		$arraySize = sizeof($data);
180
181		foreach ( $data as $key => $value )
182		{
183		$counter++;
184		$columnName = self::checkColumn($tableName, self::sanitize($key));
185		$updateQuery .= $columnName ." = '".self::sanitize($value)."'";
186		if ( $arraySize > $counter )
187		{
188		$updateQuery .= ", ";
189		}
190		}
191		return $updateQuery;
192		}
193
194		/**
195		* selectAllQuery
196		*
197		* @return string
198		*/
199		public static function selectAllQuery($tableName)
200		{
201		return "SELECT * FROM {$tableName}";
202		}
203
204		/**
205		* whereAndClause
206		*
207		* @return string
208		*/
209	View Code Duplication	public static function whereAndClause($tableName, $data, $condition)
		0 ignored issues – show Duplication introduced 2015-11-22 09:13 UTC by Report Bug Copy Issue Report This method seems to be duplicated in 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...
210		{
211		$where = "";
212		$counter = 0;
213		$arraySize = sizeof($data);
214
215		foreach ( $data as $key => $value )
216		{
217		$counter++;
218		$columnName = self::checkColumn($tableName, self::sanitize($key));
219		$where .= $columnName ." = '".self::sanitize($value)."'";
220		if ( $arraySize > $counter )
221		{
222		$where .= " " . $condition . " ";
223		}
224		}
225
226		return $where;
227		}
228
229		/**
230		* selectQuery
231		*
232		* @return string
233		*/
234		public static function selectQuery($tableName, $data, $condition, $connection)
235		{
236		$query = "";
		0 ignored issues – show Unused Code introduced 2015-11-22 09:13 UTC by Report Bug Copy Issue Report `$query` is not used, you could remove the assignment. This check looks for variable assignements that are either overwritten by other assignments or where the variable is not used subsequently. $myVar = 'Value'; $higher = false; if (rand(1, 6) > 3) { $higher = true; } else { $higher = false; } Both the `$myVar` assignment in line 1 and the `$higher` assignment in line 2 are dead. The first because `$myVar` is never used and the second because `$higher` is always overwritten for every possible time line. Loading history...
237		try
238		{
239		$arraySize = sizeof($data);
240		if( $arraySize > 1 && $condition == NULL)
241		{
242		$query = "Please Supply the condition";
243		}
244		else
245		{
246		$columnName = self::whereAndClause($tableName, $data, $condition);
247		$query = "SELECT * FROM $tableName WHERE $columnName";
248		}
249		} catch ( PDOException $e ) {
250		$query = $e->getMessage();
251		}
252
253		return $query;
254		}
255
256		/**
257		* insertQuery
258		*
259		* @return string
260		*/
261		public function insertQuery($tableName)
262		{
263		$data = ( array )$this;
264		array_shift($data);
265
266		$columnNames = self::buildColumn($data);
267		$values = self::buildValues($data);
268		$insertQuery = "INSERT INTO $tableName ({$columnNames}) VALUES ({$values})";
269
270		return $insertQuery;
271		}
272
273		/**
274		* updateQuery
275		*
276		* @return string
277		*/
278		public function updateQuery($tableName)
279		{
280		$data = ( array ) $this;
281		$data = array_slice ($data, 2);
282
283		$values = self::buildClause($tableName, $data);
284		$updateQuery = "UPDATE $tableName SET {$values} WHERE id = ". self::sanitize($this->id);
		0 ignored issues – show Bug introduced 2015-11-22 09:13 UTC by Report Bug Copy Issue Report The property `id` 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...
285
286		return $updateQuery;
287		}
288		}

andela-iadeniyi / Potato-ORM

Push — master ( e30db1...245fbf )

DatabaseQuery::insertQuery() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like