responsible\core\connect\DB

Complexity

Total Complexity

32

Size/Duplication

Total Lines	195
Duplicated Lines	0 %

Importance

Changes	1
Bugs	0	Features	0

14 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	9	1
A	ExceptionLog()	0	14	2
A	Connect()	0	24	2
A	CloseConnection()	0	3	1
A	lastInsertId()	0	3	1
A	row()	0	8	1
A	query()	0	12	6
A	BuildParams()	0	28	6
B	Init()	0	30	7
A	single()	0	4	1
A	column()	0	8	1
A	beginTransaction()	0	3	1
A	commit()	0	3	1
A	rollBack()	0	3	1

<?php

/*
 * PHP-PDO-MySQL-Class
 * https://github.com/lincanbin/PHP-PDO-MySQL-Class
 *
 * Copyright 2015 Canbin Lin (lincanbin@hotmail.com)
 * http://www.94cb.com/
 *
 * Licensed under the Apache License, Version 2.0:
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * A PHP MySQL PDO class similar to the the Python MySQLdb.
 */

namespace responsible\core\connect;

use PDO;

class DB
{
    private $Host;
    private $DBName;
    private $DBUser;
    private $DBPassword;
    private $DBPort;
    private $pdo;
    private $sQuery;
    private $bConnected = false;
    private $parameters;
    public $rowCount = 0;
    public $columnCount = 0;
    public $querycount = 0;

    public function __construct($Host, $DBName, $DBUser, $DBPassword, $DBPort = 3306)
    {
        $this->Host = $Host;
        $this->DBName = $DBName;
        $this->DBUser = $DBUser;
        $this->DBPassword = $DBPassword;
        $this->DBPort = $DBPort;
        $this->Connect();
        $this->parameters = array();
    }

    private function Connect()
    {
        try {
            $this->pdo = new PDO(
                'mysql:dbname=' . $this->DBName . ';host=' . $this->Host . ';port=' . $this->DBPort . ';charset=utf8',
                $this->DBUser,
                $this->DBPassword,
                array(
                    //For PHP 5.3.6 or lower
                    PDO::MYSQL_ATTR_INIT_COMMAND => "SET NAMES utf8",
                    PDO::ATTR_EMULATE_PREPARES => false,

                    //长连接
                    //PDO::ATTR_PERSISTENT => true,

                    PDO::ATTR_ERRMODE => PDO::ERRMODE_EXCEPTION,
                    PDO::MYSQL_ATTR_USE_BUFFERED_QUERY => true,
                )
            );

            $this->bConnected = true;
        } catch (PDOException $e) {

The type responsible\core\connect\PDOException was not found. Did you mean PDOException? If so, make sure to prefix the type with \.

            echo $this->ExceptionLog($e->getMessage());
            die();

Using exit here is not recommended.

        }
    }

    public function CloseConnection()
    {
        $this->pdo = null;
    }

    private function Init($query, $parameters = "")
    {
        if (!$this->bConnected) {
            $this->Connect();
        }
        try {
            $this->parameters = $parameters;
            $this->sQuery = $this->pdo->prepare($this->BuildParams($query, $this->parameters));

            if (!empty($this->parameters)) {
                if (array_key_exists(0, $parameters)) {
                    $parametersType = true;
                    array_unshift($this->parameters, "");
                    unset($this->parameters[0]);
                } else {
                    $parametersType = false;
                }
                foreach ($this->parameters as $column => $value) {
                    $this->sQuery->bindParam($parametersType ? intval($column) : ":" . $column, $this->parameters[$column]); //It would be query after loop end(before 'sQuery->execute()').It is wrong to use $value.
                }
            }

            $this->sQuery->execute();
            $this->querycount++;
        } catch (PDOException $e) {
            echo $this->ExceptionLog($e->getMessage(), $this->BuildParams($query));
            die();

Using exit here is not recommended.

        }

        $this->parameters = array();
    }

    private function BuildParams($query, $params = array())
    {
        if (!empty($params)) {
            $array_parameter_found = false;
            foreach ($params as $parameter_key => $parameter) {
                if (is_array($parameter)) {
                    $array_parameter_found = true;
                    $in = "";
                    foreach ($parameter as $key => $value) {
                        $name_placeholder = $parameter_key . "_" . $key;
                        // concatenates params as named placeholders
                        $in .= ":" . $name_placeholder . ", ";
                        // adds each single parameter to $params
                        $params[$name_placeholder] = $value;
                    }
                    $in = rtrim($in, ", ");
                    $query = preg_replace("/:" . $parameter_key . "/", $in, $query);
                    // removes array form $params
                    unset($params[$parameter_key]);
                }
            }

            // updates $this->params if $params and $query have changed
            if ($array_parameter_found) {
                $this->parameters = $params;
            }
        }
        return $query;
    }

    public function query($query, $params = null, $fetchmode = PDO::FETCH_ASSOC)
    {
        $query = trim(preg_replace('/\s+/', ' ', $query));
        $rawStatement = explode(" ", $query);
        $this->Init($query, $params);
        $statement = strtolower($rawStatement[0]);
        if ($statement === 'select' || $statement === 'show') {
            return $this->sQuery->fetchAll($fetchmode);
        } elseif ($statement === 'insert' || $statement === 'update' || $statement === 'delete') {
            return $this->sQuery->rowCount();
        } else {
            return null;
        }
    }

    public function lastInsertId()
    {
        return $this->pdo->lastInsertId();
    }

    public function column($query, $params = null)
    {
        $this->Init($query, $params);
        $resultColumn = $this->sQuery->fetchAll(PDO::FETCH_COLUMN);
        $this->rowCount = $this->sQuery->rowCount();
        $this->columnCount = $this->sQuery->columnCount();
        $this->sQuery->closeCursor();
        return $resultColumn;
    }

    public function row($query, $params = null, $fetchmode = PDO::FETCH_ASSOC)
    {
        $this->Init($query, $params);
        $resultRow = $this->sQuery->fetch($fetchmode);
        $this->rowCount = $this->sQuery->rowCount();
        $this->columnCount = $this->sQuery->columnCount();
        $this->sQuery->closeCursor();
        return $resultRow;
    }

    public function single($query, $params = null)
    {
        $this->Init($query, $params);
        return $this->sQuery->fetchColumn();
    }

    private function ExceptionLog($message, $sql = "")
    {
        $exception = 'Unhandled Exception. <br />';
        $exception .= $message;
        $exception .= "<br /> You can find the error back in the log.";

        if (!empty($sql)) {
            $message .= "\r\nRaw SQL : " . $sql;
        }

        //Prevent search engines to crawl
        header("HTTP/1.1 500 Internal Server Error");
        header("Status: 500 Internal Server Error");
        return $exception;
    }

    public function beginTransaction()
    {
        $this->pdo->beginTransaction();
    }

    public function commit()
    {
        $this->pdo->commit();
    }

    public function rollBack()
    {
        $this->pdo->rollBack();
    }
}