Ballybran\Database\QueryBuilder

Complexity

Total Complexity

39

Size/Duplication

Total Lines	302
Duplicated Lines	0 %

Importance

Changes	1
Bugs	0	Features	1

10 Methods

Rating	Name	Duplication	Size	Complexity
A	__call()	0	9	2
A	insert()	0	35	3
A	executeDelete()	0	3	1
B	delete()	0	41	7
A	executeUpdate()	0	8	2
B	select()	0	60	8
A	__construct()	0	4	1
B	update()	0	57	9
A	executeSelect()	0	15	3
A	executeInsert()	0	16	3

<?php
/**
 * KNUT7 K7F (https://marciozebedeu.com/)
 * KNUT7 K7F (tm) : Rapid Development Framework (https://marciozebedeu.com/)
 *
 * Licensed under The MIT License
 * For full copyright and license information, please see the LICENSE.txt
 * Redistributions of files must retain the above copyright notice.
 *
 * @link      https://github.com/knut7/framework/ for the canonical source repository
 * @copyright (c) 2015.  KNUT7  Software Technologies AO Inc. (https://marciozebedeu.com/)
 * @license   https://marciozebedeu.com/license/new-bsd New BSD License
 * @author    Marcio Zebedeu - artphoweb@artphoweb.com
 * @version   1.0.2
 */


namespace Ballybran\Database;
use Ballybran\Database\DBconnection;
use Ballybran\Database\Drives\QueryBuilderInterface;

/**
 * Class QueryBuilder
 * @method QueryBuilder table (string $table)
 * @method QueryBuilder join (string $join)
 * @method QueryBuilder fields (array $fields)
 * @method QueryBuilder where (array $where)
 * @method QueryBuilder order (array $order)
 * @method QueryBuilder group (array $group)
 * @method QueryBuilder having (array $having)
 * @method QueryBuilder limit (array $join)
 */
class QueryBuilder extends DBconnection
{
    /**
     * @var array
     */
    private $clausules = [];

    /**
     * @param $name
     * @param $arguments
     * @return $this
     */
    function __call($name , $arguments)
    {
        $clausule = $arguments[0];
        if (count( $arguments ) > 1) {
            $clausule = $arguments;
        }
        $this->clausules[strtolower( $name )] = $clausule;

        return $this;
    }

    /**
     * QueryBuilder constructor.
     * @param array $options
     */
    public function __construct(array $options)
    {
        parent::__construct( $options );
        $this->conn = $this->connection();

The property conn does not exist. Although not strictly required by PHP, it is generally a best practice to declare properties explicitly.

    }

    /**
     * @param array $values
     * @return string
     */
    public function insert(array $values = [] )
    {
        // recupera o nome da tabela
        // ou deixa uma marcação para mostrar que faltou informar esse campo
        $table = isset( $this->clausules['table'] ) ? $this->clausules['table'] : '<table>';

        // recupera o array dos campos
        // ou deixa uma marcação para mostrar que faltou informar esse campo
        $_fields = isset( $this->clausules['fields'] ) ? $this->clausules['fields'] : '<fields>';
//        $fields = implode( ', ' , $_fields );
//
//        // cria uma lista de rótulos para usar "prepared statement"
//        $_placeholders = array_map( function () {
//            return '?';
//        } , $_fields );
//        $placeholders = implode( ', ' , $_placeholders );

        krsort($_fields);

It seems like $_fields can also be of type string; however, parameter $array of krsort() does only seem to accept array, maybe add an additional type check?

//
        $fieldName = implode('`,`', array_keys($_fields));
        $fieldValues = ':' . implode(',:', array_keys($_fields));
        $this->_beginTransaction();

        $command = [];
        $command[] = 'INSERT INTO';
        $command[] = $table;
        $command[] = '(' . $fieldName . ')';
        $command[] = 'VALUES';
        $command[] = '(' . $fieldValues . ')';

        // INSERT INTO {table} ({fields}) VALUES ({values});
        // junta o comando
        $sql = implode( ' ' , $command );

        return $this->executeInsert( $sql , $values );

Are you sure the usage of $this->executeInsert($sql, $values) targeting Ballybran\Database\QueryBuilder::executeInsert() seems to always return null.

    }

    /**
     * @param $values
     * @return string
     */
    public function select($values = [])
    {
        // recupera o nome da tabela
        // ou deixa uma marcação para mostrar que faltou informar esse campo
        $table = isset( $this->clausules['table'] ) ? $this->clausules['table'] : '<table>';

        // recupera o array dos campos
        // ou deixa uma marcação para mostrar que faltou informar esse campo
        $_fields = isset( $this->clausules['fields'] ) ? $this->clausules['fields'] : '*';
        $fields = implode( ', ' , $_fields );

It seems like $_fields can also be of type string; however, parameter $pieces of implode() does only seem to accept array, maybe add an additional type check?

        $join = isset( $this->clausules['join'] ) ? $this->clausules['join'] : '';

        $command = [];
        $command[] = 'SELECT';
        $command[] = $fields;
        $command[] = 'FROM';
        $command[] = $table;
        if ($join) {
            $command[] = $join;
        }

        $clausules = [
            'where' => [
                'instruction' => 'WHERE' ,
                'separator' => ' ' ,
            ] ,
            'group' => [
                'instruction' => 'GROUP BY' ,
                'separator' => ', ' ,
            ] ,
            'order' => [
                'instruction' => 'ORDER BY' ,
                'separator' => ', ' ,
            ] ,
            'having' => [
                'instruction' => 'HAVING' ,
                'separator' => ' AND ' ,
            ] ,
            'limit' => [
                'instruction' => 'LIMIT' ,
                'separator' => ',' ,
            ] ,
        ];
        foreach ($clausules as $key => $clausule) {
            if (isset( $this->clausules[$key] )) {
                $value = $this->clausules[$key];
                if (is_array( $value )) {
                    $value = implode( $clausule['separator'] , $this->clausules[$key] );
                }
                $command[] = $clausule['instruction'] . ' ' . $value;
            }
        }

        // SELECT {fields} FROM <JOIN> {table} <WHERE> <GROUP> <ORDER> <HAVING> <LIMIT>;
        // junta o comando
        $sql = implode( ' ' , $command );
        var_dump($sql);

var_dump($sql) looks like debug code. Are you sure you do not want to remove it?

        return $this->executeSelect( $sql , $values );
    }

    /**
     * @return int
     */
    public function update()
    {
        // recupera o nome da tabela
        // ou deixa uma marcação para mostrar que faltou informar esse campo
        $table = isset( $this->clausules['table'] ) ? $this->clausules['table'] : '<table>';

        $join = isset( $this->clausules['join'] ) ? $this->clausules['join'] : '';

        // recupera o array dos campos
        // ou deixa uma marcação para mostrar que faltou informar esse campo
        $_fields = isset( $this->clausules['fields'] ) ? $this->clausules['fields'] : '<fields>';


        ksort($_fields);

It seems like $_fields can also be of type string; however, parameter $array of ksort() does only seem to accept array, maybe add an additional type check?

        $fielDetail = null;

        foreach ($_fields as $key => $values) {
            $fielDetail .= "`$key`=:$key,";
        }

        $fielDetail = trim($fielDetail, ',');

        $command = [];
        $command[] = 'UPDATE';
        $command[] = $table;
        if ($join) {
            $command[] = $join;
        }
        $command[] = 'SET';
        $command[] = $fielDetail;

        $clausules = [
            'where' => [
                'instruction' => 'WHERE' ,
                'separator' => ' ' ,
            ],
            'limit' => [
                'instruction' => 'LIMIT' ,
                'separator' => ',' ,
            ] ,
        ];
        foreach ($clausules as $key => $clausule) {
            if (isset( $this->clausules[$key] )) {
                $value = $this->clausules[$key];
                if (is_array( $value )) {
                    $value = implode( $clausule['separator'] , $this->clausules[$key] );
                }
                $command[] = $clausule['instruction'] . ' ' . $value;
            }
        }

        // UPDATE {table} SET {set} <WHERE>
        // junta o comando
        $sql = implode( ' ' , $command );

        return $this->executeUpdate( $sql , $_fields );
    }

    /**
     * @param $filters
     * @return int
     */
    public function delete($filters = null )
    {
        // recupera o nome da tabela
        // ou deixa uma marcação para mostrar que faltou informar esse campo
        $table = isset( $this->clausules['table'] ) ? $this->clausules['table'] : '<table>';

        $join = isset( $this->clausules['join'] ) ? $this->clausules['join'] : '';

        $command = [];
        $command[] = 'DELETE FROM';
        $command[] = $table;
        if ($join) {
            $command[] = $join;
        }

        $clausules = [
            'where' => [
                'instruction' => 'WHERE' ,
                'separator' => ' ' ,
            ],
            'limit' => [
                'instruction' => 'LIMIT' ,
                'separator' => ',' ,
            ] ,

        ];
        foreach ($clausules as $key => $clausule) {
            if (isset( $this->clausules[$key] )) {
                $value = $this->clausules[$key];
                if (is_array( $value )) {
                    $value = implode( $clausule['separator'] , $this->clausules[$key] );
                }
                $command[] = $clausule['instruction'] . ' ' . $value;
            }
        }

        // DELETE FROM {table} <JOIN> <USING> <WHERE>
        // junta o comando
        $sql = implode( ' ' , $command );

        return $this->executeDelete( $sql , $filters );
    }

    private function executeSelect($sql , $value)
    {

        $stmt = $this->conn->prepare( $sql );

        foreach ($value as $key => $values) {
            return $stmt->bindValue( "$key" , $values );
        }
        $stmt->execute();

        do {

DoNode is not reachable.

            return $stmt->fetchAll( $fetchMode );
        } while (
            $stmt->nextRowset());
        $stmt->close();

    }

    private function executeInsert($sql , $value)
    {
        try {

            $this->_beginTransaction();

            $stmt = $this->conn->prepare($sql);
            foreach ($value as $key => $values) {
                $stmt->bindValue( ":$key" , $values );
            }
            $this->_commit();
            $stmt->execute();
            unset( $stmt );
        } catch (\Exception $e) {
            $this->_Rollback();
            echo 'error insert ' . $e->getMessage();
        }

    }


    private function executeUpdate($sql , $data)
    {
        $stmt = $this->conn->prepare($sql);
        foreach ($data as $key => $values) {
            $stmt->bindValue(":$key", $values);
        }

        return $stmt->execute();
    }

    private function executeDelete($sql , $value)

The parameter $value is not used and could be removed.

    {
        return $this->conn->exec($sql);

    }
}