PotatoQuery::storeIn() - Code Metrics - Inspection of "Checkpoint 2 - Potato ORM" - andela-celisha-wigwe/PotatoORM - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#11)

by Elisha-Wigwe Chijioke

created 2016-03-23 16:28 UTC

PotatoQuery::storeIn() A

↳ Parent: PotatoQuery

Complexity

Conditions	2
Paths	2

Size

Total Lines	12
Code Lines	9

Duplication

Lines	0
Ratio	0 %

Importance

Changes	7
Bugs	5	Features	1

Metric	Value
c	7
b	5
f	1
dl	0
loc	12
rs	9.4285
cc	2
eloc	9
nc	2
nop	2

<?php

namespace Elchroy\PotatoORM;

use Elchroy\PotatoORMExceptions\FaultyExecutionException;
use Elchroy\PotatoORMExceptions\FaultyOrNoTableException;
use Elchroy\PotatoORMExceptions\NoRecordException;
use PDO;
use PDOException;

class PotatoQuery
{
    /**
     * [$connection The connection to be used to communicate with the database. To be instantiated during construction.].
     *
     * @var [type] PDO Connection.
     */
    public $connection;

    /**
     * Setup the connection to aid all queries.
     *
     * @param PotatoConnector|null $connector [description]
     */
    public function __construct(PotatoConnector $connector = null)
    {
        $connector = $connector == null ? new PotatoConnector() : $connector;
        $this->connection = $connector->connection;
    }

    /**
     * Get all records from the specified database table.
     *
     * @param string $table   The table name
     * @param string $columns The columns to be gotten from the database table
     *
     * @return array An array of objects, each representing a record fetched from the database table.
     */
    public function getFrom($table, $columns = '*')
    {
        $sql = "SELECT $columns FROM $table";
        $statement = $this->connection->prepare($sql);
        $statement == false ? $this->throwFaultyOrNoTableException($table) : '';
        $execution = $this->tryExecuting($statement);
function acceptsInteger($int) { }

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

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
        $result = $statement->fetchAll(PDO::FETCH_CLASS);
        $result == false ? $this->throwNoRecordException($table) : '';

        return $result;
    }

    /**
     * Get only one record from the datbase table, given the id of the record to be retrieved.
     *
     * @param string $table The database table name
     * @param int    $id    The id of the recored to be fethced.
     *
     * @return model object        The record fetched form the database table as an object
     */
    public function getOne($table, $id)
    {
        $sql = "SELECT * FROM $table WHERE id = :id ";
        $statement = $this->connection->prepare($sql);
        $statement == false ? $this->throwFaultyOrNoTableException($table) : '';
        $statement->bindParam(':id', $id);
        $execution = $this->tryExecuting($statement);
function acceptsInteger($int) { }

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

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
        $result = $statement->fetchObject($table);
        $result == false ? $this->throwNoRecordException($table, $id) : '';

        return $result;
    }

    /**
     * Store a new recored inside athe database table.
     *
     * @param string $table The table into which it is required to add a new record
     * @param string $data  An aray of the columns to be used for inseting into the database
     *
     * @return bool The result of the query execution. True if successful. False otherwise.
     */
    public function storeIn($table, $data)
    {
        $columnsString = $this->getColumns($data);
function acceptsInteger($int) { }

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

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
        $count = (int) count($data);
        $sql = "INSERT INTO $table $columnsString VALUES (".$this->putQuesMarks($count).')';
        $statement = $this->connection->prepare($sql);
        $statement == false ? $this->throwFaultyOrNoTableException($table) : '';
        $this->setBindForInsert($statement, array_values($data));
        $execution = $this->tryExecuting($statement);
function acceptsInteger($int) { }

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

// Instead of
acceptsInteger($x);

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

        return $execution;
    }

    /**
     * Try executoing a query given the statment.
     *
     * @param PDOStatemetn $statement The PDO statment to be executed.
     *
     * @return bool The result of executing a query. True for success, false for failure
     */
    public function tryExecuting($statement)
    {
        try {
            $execution = $statement->execute();
        } catch (PDOException $e) {
            $message = $e->getMessage();
            $this->throwFaultyExecutionException($message);
        }

        return $execution;
    }

    /**
     * Throw an exception when there is a problem with execution of a statement.
     *
     * @param string $message The message to be related in the event of this exception
     *
     * @return [type] [description]

     */
    public function throwFaultyExecutionException($message)
    {
        throw new FaultyExecutionException($message);
    }

    /**
     * The columns to be inserted into the SQL query.
     *
     * @param array $data An array of the columns to be used for inserting int ot he database.
     *
     * @return string A string made up of the columns for insert query enclode in parentheses
     */
    public function getColumns(array $data)
    {
        return '('.implode(', ', array_keys($data)).')';
    }

    /**
     * Bind parameters to the placeholders in the SQL queries. This is to avoid sql injection.
     *
     * @param [type]  $statement The PDOStatement to be used to the binding.

     * @param [array] $values    The result of binding parameters to an SQL query.

     */
    public function setBindForInsert($statement, $values)
    {
        $count = count($values);
        for ($i = 1; $i <= $count; $i++) {
            $statement->bindParam(($i), $values[$i - 1]);
        }
    }

    /**
     * Delete a record form a database table.
     *
     * @param [string] $table The table to be deleted from

     * @param [int]    $id    the ID of the record to be deleted

     *
     * @return [type] The result of the deletion execution.

     */
    public function deleteFrom($table, $id)
    {
        $sql = "DELETE FROM $table WHERE id = :id ";
        $statement = $this->connection->prepare($sql);
        $statement == false ? $this->throwFaultyOrNoTableException($table) : '';
        $statement->bindParam(':id', $id);
        $execution = $this->tryExecuting($statement);
function acceptsInteger($int) { }

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

// Instead of
acceptsInteger($x);

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

        return $execution;
    }

    /**
     * Update records in the datbase table.
     *
     * @param string  $table The table who record ois to be updated
     * @param [array] $data  [The update data in an array]

     *
     * @return [bool] [The result of executing an SQL update query. TRUE OR FALSE]

     */
    public function updateAt($table, $data)
    {
        $id = (int) $data['id']; // store the id in a variable.
        unset($data['id']);
        $upd = (string) $this->makeModify(array_keys($data)); // genertate the columns for the update statement.
        $sql = "UPDATE {$table} SET ".$upd.' WHERE id = :id_val';
        $statement = $this->connection->prepare($sql);
        $statement == false ? $this->throwFaultyOrNoTableException($table) : '';
        $this->setBindForUpdate($statement, $data);
        $statement->bindValue(':id_val', $id);
        $execution = $this->tryExecuting($statement);
function acceptsInteger($int) { }

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

// Instead of
acceptsInteger($x);

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

        return $execution;
    }

    /**
     * Bind parameters to the placeholders in the SQL queries. This is to avoid sql injection.
     *
     * @param [type]  $statement The PDOStatement to be used to the binding.

     * @param [array] $values    The result of binding parameters to an SQL query.
/**
 * @param array $germany
 * @param array $island
 * @param array $italy
 */
function finale($germany, $island) {
    return "2:1";
}
     */
    public function setBindForUpdate($statement, array $data)
    {
        $count = count($data);
$myVar = 'Value';
$higher = false;

if (rand(1, 6) > 3) {
    $higher = true;
} else {
    $higher = false;
}
        foreach ($data as $key => $value) {
            $statement->bindValue(":$key".'_val', $value);
        }
    }

    /**
     * [makeModify Modify the query string to enable the binding for update.
     *
     * @param array $columns [The columns to be updated]
     *
     * @return [string] [The string of the columns to be updated and their corresponidng value_tags/ placeholders] E.g name = :name_val

     */
    public function makeModify(array $columns)
    {
        $count = count($columns);
$myVar = 'Value';
$higher = false;

if (rand(1, 6) > 3) {
    $higher = true;
} else {
    $higher = false;
}
        $updateString = ''; // Start with an empty string
        foreach ($columns as $column) {
            $updateString .= $column.' = '.':'.$column.'_val, ';
        }

        return $updateString = trim($updateString, ', ');
$myVar = 'Value';
$higher = false;

if (rand(1, 6) > 3) {
    $higher = true;
} else {
    $higher = false;
}
    }

    /**
     * [putQuesMarks Prepare a set of question-marks to comple an insert query SQL string. THis enables queryh binding.
     *
     * @param int $count The numbe rof column to be inserted
     *
     * @return string A string with the number of  question marks needed for a complete insert query. E.g "?, ?"
     */
    public function putQuesMarks($count)
    {
        $str = '';
        for ($i = 0; $i < $count; $i++) {
            $str .= '?, ';
        }

        return $str = trim($str, ', '); // remove the last comma.
$myVar = 'Value';
$higher = false;

if (rand(1, 6) > 3) {
    $higher = true;
} else {
    $higher = false;
}
    }

    /**
     * [throwFaultyOrNoTableException Throw an exception if the table does not exist.
     *
     * @param string $table The table that foes not exist.
     *
     * @return [type] An exception with a custom message displayed when the databse table does not exist.

     */
    public function throwFaultyOrNoTableException($table)
    {
        $message = "There seems to be a problem. Please confirm if the '$table' table exists in the database.";
        throw new FaultyOrNoTableException($message);
    }

    /**
     * [throwNoRecordException Throw an Exception if there is no record found in the database table.]
     * This may mean that the table is empty ot that the record with the given ID is not foung.
     *
     * @param [string] $table [The table that is empty or does not have the record with the given ID.]

     * @param [int]    $id    [The ID of the record that does not exist in the databse table]

     *
     * @return [type] [description]

     */
    public function throwNoRecordException($table, $id = null)
    {
        $message = is_null($id) ? "The table ($table) is empty." : "Record $id : Not found found in this table ($table).";
        throw new NoRecordException($message);
    }
}


1			<?php
2
3			namespace Elchroy\PotatoORM;
4
5			use Elchroy\PotatoORMExceptions\FaultyExecutionException;
6			use Elchroy\PotatoORMExceptions\FaultyOrNoTableException;
7			use Elchroy\PotatoORMExceptions\NoRecordException;
8			use PDO;
9			use PDOException;
10
11			class PotatoQuery
12			{
13			/**
14			* [$connection The connection to be used to communicate with the database. To be instantiated during construction.].
15			*
16			* @var [type] PDO Connection.
17			*/
18			public $connection;
19
20			/**
21			* Setup the connection to aid all queries.
22			*
23			* @param PotatoConnector\|null $connector [description]
24			*/
25			public function __construct(PotatoConnector $connector = null)
26			{
27			$connector = $connector == null ? new PotatoConnector() : $connector;
28			$this->connection = $connector->connection;
29			}
30
31			/**
32			* Get all records from the specified database table.
33			*
34			* @param string $table The table name
35			* @param string $columns The columns to be gotten from the database table
36			*
37			* @return array An array of objects, each representing a record fetched from the database table.
38			*/
39			public function getFrom($table, $columns = '*')
40			{

andela-celisha-wigwe / PotatoORM

Pull Request — master (#11)

PotatoQuery::storeIn() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like