Ibonly\PotatoORM\DatabaseQuery

Complexity

Total Complexity

29

Size/Duplication

Total Lines	270
Duplicated Lines	33.33 %

Coupling/Cohesion

Components	1
Dependencies	3

Importance

Changes	13
Bugs	0	Features	1

14 Methods

Rating	Name	Duplication	Size	Complexity
A	connect()	0	4	1
A	sanitize()	0	6	1
A	checkConnection()	0	8	2
A	checkTableExist()	9	9	2
A	checkTableName()	14	14	2
A	checkColumn()	0	12	2
A	buildColumn()	15	15	3
A	buildValues()	15	15	3
A	buildClause()	18	18	3
A	selectAllQuery()	0	4	1
A	whereAndClause()	19	19	3
A	selectQuery()	0	21	4
A	insertQuery()	0	11	1
A	updateQuery()	0	10	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 <ibonly01@gmail.com>
 * @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)

This method seems to be duplicated in your project.

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

The method query cannot be called on $connection (of type string).

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

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

This method seems to be duplicated in your project.

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

59% of this comment could be valid code. Did you maybe forget this after debugging?

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

The method query cannot be called on $connection (of type string).

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

56% of this comment could be valid code. Did you maybe forget this after debugging?

    }

    /**
     * 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}");

The method prepare cannot be called on $connection (of type string).

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

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

This method seems to be duplicated in your project.

    {
        $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)

This method seems to be duplicated in your project.

    {
        $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)

This method seems to be duplicated in your project.

    {
        $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)

This method seems to be duplicated in your project.

    {
        $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 = "";

$query is not used, you could remove the assignment.

        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);

The property id does not exist. Did you maybe forget to declare it?

        return $updateQuery;
    }
}