midorikocak\nanodb\Database

Complexity

Total Complexity

24

Size/Duplication

Total Lines	134
Duplicated Lines	0 %

Test Coverage

Coverage

79.41%

Importance

Changes	1
Bugs	0	Features	1

20 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	4	1
A	select()	0	5	1
A	or()	0	4	1
A	update()	0	5	1
A	insert()	0	5	1
A	and()	0	4	1
A	lastInsertId()	0	3	1
A	reset()	0	3	1
A	offset()	0	4	1
A	orderBy()	0	8	3
A	execute()	0	4	1
A	delete()	0	5	1
A	rowCount()	0	3	1
A	between()	0	4	1
A	fetchAll()	0	6	2
A	fetch()	0	5	2
A	limit()	0	4	1
A	where()	0	4	1
A	count()	0	5	1
A	query()	0	5	1

<?php

declare(strict_types=1);

namespace midorikocak\nanodb;

use InvalidArgumentException;
use midorikocak\querymaker\QueryInterface;
use midorikocak\querymaker\QueryMaker;
use PDO;
use PDOStatement;

class Database implements DatabaseInterface
{
    private PDO $db;
    private ?QueryInterface $query = null;
    private ?PDOStatement $statement = null;

    public function __construct(PDO $db, ?QueryInterface $query = null)
    {
        $this->db = $db;
        $this->query = $query ?? new QueryMaker();
    }

    public function query(QueryInterface $query): self
    {
        $this->reset();
        $this->query = $query;
        return $this;
    }

    public function select($table, array $columns = ['*']): self
    {
        $this->reset();
        $this->query->select($table, $columns);

The method select() does not exist on null.

        return $this;
    }

    public function count($table): self
    {
        $this->reset();
        $this->query->count($table);
        return $this;
    }

    public function delete($table): self
    {
        $this->reset();
        $this->query->delete($table);
        return $this;
    }

    public function update($table, array $values): self
    {
        $this->reset();
        $this->query->update($table, $values);
        return $this;
    }

    public function insert($table, array $values): self
    {
        $this->reset();
        $this->query->insert($table, $values);
        return $this;
    }

    public function where($key, $value, string $operator = '='): self
    {
        $this->query->where($key, $value, $operator);
        return $this;
    }

    public function and($key, $value, string $operator = '='): self
    {
        $this->query->and($key, $value, $operator);
        return $this;
    }

    public function orderBy($key, $order = 'ASC'): self
    {
        if ($order !== 'DESC' && $order !== 'ASC') {
            throw new InvalidArgumentException('Invalid order value');
        }

        $this->query->orderBy($key, $order);
        return $this;
    }

    public function limit(int $limit): self
    {
        $this->query->limit($limit);
        return $this;
    }

    public function offset(int $offset): self
    {
        $this->query->offset($offset);
        return $this;
    }

    public function or($key, $value, string $operator = '='): self
    {
        $this->query->or($key, $value, $operator);
        return $this;
    }

    public function between($key, $before, $after): self
    {
        $this->query->between($key, $before, $after);
        return $this;
    }

    public function lastInsertId(): string
    {
        return $this->db->lastInsertId();
    }

    public function rowCount(): int
    {
        return $this->statement->rowCount();

The method rowCount() does not exist on null.

    }

    public function execute(): bool
    {
        $this->statement = $this->db->prepare($this->query->getStatement());
        return $this->statement->execute($this->query->getParams());
    }

    public function fetch(): array
    {
        $this->execute();
        $toReturn = $this->statement->fetch(PDO::FETCH_ASSOC);
        return $toReturn === false ? [] : $toReturn;
    }

    public function fetchAll(): array
    {
        $this->execute();

        $toReturn = $this->statement->fetchAll(PDO::FETCH_ASSOC);
        return $toReturn === false ? [] : $toReturn;
    }

    private function reset()
    {
        $this->statement = null;
    }
}