CrudBuilder::deleteBuilder() - Code Metrics - Inspection of "correcao de class" - brunobmorais/php-database - Measure and Improve Code Quality continuously with Scrutinizer

Passed
Push — main ( b51950...376464 )

by BRUNO
created 2023-11-26 13:02 UTC
CrudBuilder::deleteBuilder() A

↳ Parent: CrudBuilder
Complexity

Conditions	2
Paths	3
Size

Total Lines	8
Code Lines	6
Duplication

Lines	0
Ratio	0 %
Importance

Changes
Metric	Value
cc	2
eloc	6
nc	3
nop	0
dl	0
loc	8
rs	10
c	0
b	0
f	0
<?php

namespace BMorais\Database;

/**
 * CLASS CrudBuilder
 * Basic class to make connection between the database and the application
 *
 * @author Bruno Morais <[email protected]>
 * @copyright MIT, bmorais.com
 * @package bmorais\database
 * @subpackage class
 * @access protected
 */
abstract class CrudBuilder extends Crud
{
    use DatalayerTrait;

    /**
    * @var array
     */
    private array $sqlPartsSelect = [
        'main'      => [],
        'join'      => [],
        'where'     => "",
        'andWhere'  => [],
        'orWhere'   => [],
        'groupBy'   => [],
        'having'    => [],
        'andHaving' => [],
        'orHaving'  => [],
        'orderBy'   => "",
        'addOrderBy'=> [],
        'limit'     => "",
        'offset'    => "",
    ];

    /**
     *
    * <code>
    *   $qb = $this->select('u.id, p.id')
    *           ->where('phonenumbers=?', [$number]);
    * </code>
    * @param string $fields
    * @param array $paramns
    * @return $this
     */
    public function selectBuilder(string $fields = "*", array $paramns = []): self
    {
        try {
            $query = "SELECT {$fields} FROM {$this->getTable()}";
            if (!empty($this->getTableAlias()))
                $query .= " AS {$this->getTableAlias()}";
            $this->add($query, "main", $paramns);
            return $this;
        } catch (\PDOException $e) {
            $this->setError($e);
interface ReturnsInt {
    public function returnsIntHinted(): int;
}

class MyClass implements ReturnsInt {
    public function returnsIntHinted(): int
    {
        if (foo()) {
            return 123;
        }
        // here: null is implicitly returned
    }
}
        }
    }

    /**
    * @param string $fields
    * @param array $paramns
    * @return $this
     */
    protected function insertBuilder(string $fields, array $paramns): self
    {
        try {
            $numparams = '';
            foreach ($paramns as $item) {
                $numparams .= ',?';
            }
            $numparams = substr($numparams, 1);
            $query = "INSERT INTO {$this->getTable()} ({$fields}) VALUES ({$numparams})";
            $this->add($query, "main", $paramns);
            return $this;
        } catch (\PDOException $e) {
            $this->setError($e);
interface ReturnsInt {
    public function returnsIntHinted(): int;
}

class MyClass implements ReturnsInt {
    public function returnsIntHinted(): int
    {
        if (foo()) {
            return 123;
        }
        // here: null is implicitly returned
    }
}
        }
    }

    /**
    * @param string $fields
    * @param array $paramns
    * @return $this
     */
    protected function updateBuilder(string $fields, array $paramns): self
    {
        try {
            $fields_T = '';
            $atributos = explode(',', $fields);

            foreach ($atributos as $item) {
                $fields_T .= ", {$item} = ?";
            }
            $fields_T = substr($fields_T, 2);
            $query = "UPDATE {{$this->getTable()}} SET {$fields_T}";
            $this->add($query, "main", $paramns);
            return $this;
        } catch (\PDOException $e) {
            $this->setError($e);
interface ReturnsInt {
    public function returnsIntHinted(): int;
}

class MyClass implements ReturnsInt {
    public function returnsIntHinted(): int
    {
        if (foo()) {
            return 123;
        }
        // here: null is implicitly returned
    }
}
        }
    }

    /**
    * @param string $fields
    * @param array $paramns
    * @return $this
     */
    protected function deleteBuilder(): self
    {
        try {
            $query = "DELETE FROM {$this->getTable()}";
            $this->add($query, "main");
            return $this;
        } catch (\PDOException $e) {
            $this->setError($e);
interface ReturnsInt {
    public function returnsIntHinted(): int;
}

class MyClass implements ReturnsInt {
    public function returnsIntHinted(): int
    {
        if (foo()) {
            return 123;
        }
        // here: null is implicitly returned
    }
}
        }
    }

    /**
    * @param string $query
    * @param array $paramns
    * @return $this
     */
    protected function query(string $query, array $paramns = []): self
    {
        try {
            $this->add($query, "main", $paramns);
            return $this;
        } catch (\PDOException $e) {
            $this->setError($e);
interface ReturnsInt {
    public function returnsIntHinted(): int;
}

class MyClass implements ReturnsInt {
    public function returnsIntHinted(): int
    {
        if (foo()) {
            return 123;
        }
        // here: null is implicitly returned
    }
}
        }
    }

    /**
    * @param string $texto
    * @param array $paramns
    * @return $this
     */
    protected function where(string $texto, array $paramns = []): self
    {
        try {
            $query = "WHERE {$texto}";
            $this->add($query, "where", $paramns);
            return $this;
        } catch (\PDOException $e) {
            $this->setError($e);
interface ReturnsInt {
    public function returnsIntHinted(): int;
}

class MyClass implements ReturnsInt {
    public function returnsIntHinted(): int
    {
        if (foo()) {
            return 123;
        }
        // here: null is implicitly returned
    }
}
        }
    }

    /**
    * @param string $condition
    * @param array $paramns
    * @return $this
     */
    protected function andWhere(string $condition, array $paramns = []): self
    {
        try {
            $query = "AND {$condition}";
            $this->add($query, "andWhere", $paramns);
            return $this;
        } catch (\PDOException $e) {
            $this->setError($e);
interface ReturnsInt {
    public function returnsIntHinted(): int;
}

class MyClass implements ReturnsInt {
    public function returnsIntHinted(): int
    {
        if (foo()) {
            return 123;
        }
        // here: null is implicitly returned
    }
}
        }
    }

    /**
    * @param string $condition
    * @param array $paramns
    * @return $this
     */
    protected function orWhere(string $condition, array $paramns = []): self
    {
        try {
            $query = "OR {$condition}";
            $this->add($query, "orWhere", $paramns);
            return $this;
        } catch (\PDOException $e) {
            $this->setError($e);
interface ReturnsInt {
    public function returnsIntHinted(): int;
}

class MyClass implements ReturnsInt {
    public function returnsIntHinted(): int
    {
        if (foo()) {
            return 123;
        }
        // here: null is implicitly returned
    }
}
        }
    }

    /**
    * @param string $parameter
    * @param $order
    * @return $this
     */
    protected function orderBy(string $parameter, $order = null): self
    {
        try {
            $query = "ORDER BY {$parameter} ".($order ?? 'ASC');
            $this->add($query, "orderBy");
            return $this;
        } catch (\PDOException $e) {
            $this->setError($e);
interface ReturnsInt {
    public function returnsIntHinted(): int;
}

class MyClass implements ReturnsInt {
    public function returnsIntHinted(): int
    {
        if (foo()) {
            return 123;
        }
        // here: null is implicitly returned
    }
}
        }
    }

    /**
    * @param string $parameter
    * @param $order
    * @return $this
     */
    protected function addOrderBy(string $parameter, $order = null): self
    {
        try {
            $query = ", {$parameter} ".($order ?? 'ASC')." ";
            $this->add($query, "addOrderBy");
            return $this;
        } catch (\PDOException $e) {
            $this->setError($e);
interface ReturnsInt {
    public function returnsIntHinted(): int;
}

class MyClass implements ReturnsInt {
    public function returnsIntHinted(): int
    {
        if (foo()) {
            return 123;
        }
        // here: null is implicitly returned
    }
}
        }
    }

    /**
    * @param string $texto
    * @return $this
     */
    protected function limit(string $texto): self
    {
        $query = "LIMIT {$texto}";
        $this->add($query,"limit");
        return $this;
    }

    /**
    * @param string $texto
    * @return $this
     */
    protected function offset(string $texto): self
    {
        try {
            $query = "OFFSET {$texto}";
            $this->add($query,"offset");
            return $this;
        } catch (\PDOException $e) {
            $this->setError($e);
interface ReturnsInt {
    public function returnsIntHinted(): int;
}

class MyClass implements ReturnsInt {
    public function returnsIntHinted(): int
    {
        if (foo()) {
            return 123;
        }
        // here: null is implicitly returned
    }
}
        }
    }

    /**
    * @param string $texto
    * @return $this
     */
    protected function groupBy(string $texto): self
    {
        try {
            $query = "GROUP BY {$texto}";
            $this->add($query,"groupBy");
            return $this;
        } catch (\PDOException $e) {
            $this->setError($e);
interface ReturnsInt {
    public function returnsIntHinted(): int;
}

class MyClass implements ReturnsInt {
    public function returnsIntHinted(): int
    {
        if (foo()) {
            return 123;
        }
        // here: null is implicitly returned
    }
}
        }
    }

    /**
    * @param string $texto
    * @return $this
     */
    protected function having(string $texto): self
    {
        try {
            $query = "HAVING {$texto}";
            $this->add($query,"having");
            return $this;
        } catch (\PDOException $e) {
            $this->setError($e);
interface ReturnsInt {
    public function returnsIntHinted(): int;
}

class MyClass implements ReturnsInt {
    public function returnsIntHinted(): int
    {
        if (foo()) {
            return 123;
        }
        // here: null is implicitly returned
    }
}
        }
    }

    /**
     * @param string $texto
     * @return $this
     */
    protected function andHaving(string $texto): self
    {
        try {
            $query = "AND {$texto}";
            $this->add($query,"andHaving");
            return $this;
        } catch (\PDOException $e) {
            $this->setError($e);
interface ReturnsInt {
    public function returnsIntHinted(): int;
}

class MyClass implements ReturnsInt {
    public function returnsIntHinted(): int
    {
        if (foo()) {
            return 123;
        }
        // here: null is implicitly returned
    }
}
        }
    }

    /**
     * @param string $codition
     * @return $this
     */
    protected function orHaving(string $codition): self
    {
        try {
            $query = "OR {$codition}";
            $this->add($query,"orHaving");
            return $this;
        } catch (\PDOException $e) {
            $this->setError($e);
interface ReturnsInt {
    public function returnsIntHinted(): int;
}

class MyClass implements ReturnsInt {
    public function returnsIntHinted(): int
    {
        if (foo()) {
            return 123;
        }
        // here: null is implicitly returned
    }
}
        }
    }

    /**
    * @param string $table
    * @param string $alias
    * @param string $codition
    * @return $this
     */
    protected function innerJoin(string $table, string $alias, string $codition): self
    {
        try {
            $query = "INNER JOIN {$table} AS {$alias} ON $codition";
            $this->add($query,"join");
            return $this;
        } catch (\PDOException $e) {
            $this->setError($e);
interface ReturnsInt {
    public function returnsIntHinted(): int;
}

class MyClass implements ReturnsInt {
    public function returnsIntHinted(): int
    {
        if (foo()) {
            return 123;
        }
        // here: null is implicitly returned
    }
}
        }
    }

    /**
    * @param string $table
    * @param string $alias
    * @param string $codition
    * @return $this
     */
    protected function leftJoin(string $table, string $alias, string $codition): self
    {
        try {
            $query = "LEFT JOIN {$table} AS {$alias} ON {$codition}";
            $this->add($query,"join");
            return $this;
        } catch (\PDOException $e) {
            $this->setError($e);
interface ReturnsInt {
    public function returnsIntHinted(): int;
}

class MyClass implements ReturnsInt {
    public function returnsIntHinted(): int
    {
        if (foo()) {
            return 123;
        }
        // here: null is implicitly returned
    }
}
        }
    }

    /**
    * @param string $table
    * @param string $alias
    * @param string $codition
    * @return $this
     */
    protected function rightJoin(string $table, string $alias, string $codition): self
    {
        try {
            $query = "RIGHT JOIN {$table} AS {$alias} ON $codition";
            $this->add($query,"join");
            return $this;
        } catch (\PDOException $e) {
            $this->setError($e);
interface ReturnsInt {
    public function returnsIntHinted(): int;
}

class MyClass implements ReturnsInt {
    public function returnsIntHinted(): int
    {
        if (foo()) {
            return 123;
        }
        // here: null is implicitly returned
    }
}
        }
    }

    /**
     * @return $this
     */
    protected function executeQuery(): self
    {
        try {
            foreach ($this->sqlPartsSelect as $key => $part){
                if (is_array($part)) {
                    foreach ($part as $item){
                        $this->query .= $item;
                    }
                } else {
                    $this->query .= $part;
                }

            }

            $this->executeSQL($this->query, $this->params);
            return $this;
        } catch (\PDOException $e) {
            $this->setError($e);
interface ReturnsInt {
    public function returnsIntHinted(): int;
}

class MyClass implements ReturnsInt {
    public function returnsIntHinted(): int
    {
        if (foo()) {
            return 123;
        }
        // here: null is implicitly returned
    }
}
        }
    }

    /**
    * @return void
     */
    protected function debug(): void
    {
        try {
            echo $this->query . '<pre>' . print_r($this->params) . '</pre>';
            echo $this->query . '<pre>' . /** @scrutinizer ignore-type */ print_r($this->params) . '</pre>';
            exit;

        } catch (\PDOException $e) {
            $this->setError($e);
        }
    }


    /**
    * @param string $query
    * @param string $type
    * @param array $params
    * @return void
     */
    private function add(string $query, string $type, array $params = []): void
    {
        $query = $query." ";
        try {
            if (is_array($this->sqlPartsSelect[$type])) {
                $this->sqlPartsSelect[$type][] = $query;
            } else {
                $this->sqlPartsSelect[$type] = $query;
            }

            if (!empty($params))
                $this->setParameter($params);
        } catch (\PDOException $e) {
            $this->setError($e);
        }
    }

}

brunobmorais / php-database

Push — main ( b51950...376464 )

CrudBuilder::deleteBuilder() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like
